plugin-architecture

Document the daemon-based architecture with SSE and HTTP adapters.

2|1|Updated Apr 10, 2023
One-click install
npx skills add https://github.com/popoffvg/dotfiles --skill plugin-architecture-popoffvg
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: plugin-architecture
Source: https://github.com/popoffvg/dotfiles/tree/main/harness/plugins/memory-keeper/skills/plugin-architecture
Command: npx skills add https://github.com/popoffvg/dotfiles --skill plugin-architecture-popoffvg

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Architecture reference for the memory-keeper plugin provides a centralized model for understanding the daemon, adapters, and core library to aid onboarding, debugging, and change planning. This guide describes how the daemon coordinates a SQLite queue, the two-adapter pattern (Claude Code SSE and Pi HTTP), and the core library interfaces to enable reliable end-to-end processing.

Core Features & Use Cases

  • Single daemon architecture: One long-lived process coordinating a SQLite queue, drain loop, and logging for persistent state.
  • Two-adapter pattern: Claude Code SSE client and Pi HTTP adapter share a unified workflow with the daemon.
  • Extensible core library: Pure TypeScript modules for memory, queue, processor, and server components enabling reuse and testability.

Quick Start

Start the memory-keeper daemon in a development environment and verify the Claude Code and Pi integration touchpoints.

Frequently Asked Questions about plugin-architecture

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How does the memory-keeper daemon architecture handle queue processing and state persistence?

The memory-keeper daemon architecture uses a single long-lived process coordinating a SQLite queue and drain loop to maintain persistent state. This daemon-based design enables reliable queue-based async processing across Claude Code and Pi integrations.

What is the two-adapter pattern used for in memory-keeper plugin architecture?

The two-adapter pattern in the memory-keeper architecture connects a Claude Code SSE client and a Pi HTTP adapter to the central daemon. Both adapters share a unified workflow, enabling end-to-end processing across different interface protocols.

How do I start debugging issues across the daemon, Claude Code SSE, and Pi HTTP integrations?

Start debugging the memory-keeper architecture by examining the single daemon state, then trace interactions through the SSE and REST interfaces. Verify the core library interactions and queue-based async processing to isolate integration failures.

Can I extend the memory-keeper core library with custom TypeScript modules for memory and queue processing?

The memory-keeper core library provides pure TypeScript modules for memory, queue, processor, and server components. This extensible architecture enables reuse and testability when planning changes or adding custom processing logic.

Does the memory-keeper architecture support REST interfaces alongside SSE for adapter communication?

The memory-keeper architecture documents both SSE and REST interfaces within its two-adapter pattern. The Claude Code adapter uses SSE while the Pi adapter uses HTTP, both coordinating through the central daemon and unified core library.

What are the limitations of relying on a single daemon state for queue-based async processing?

The single daemon architecture in memory-keeper coordinates one process for the SQLite queue and logging. When the daemon is not running, queue-based async processing stops, making the daemon a single point of failure for persistent state operations.