@ectplsm/relic 0.1.0

package/dist/core/usecases/sync.js

@@ -0,0 +1,94 @@
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { Inject } from "./inject.js";
+import { Extract } from "./extract.js";
+const DEFAULT_OPENCLAW_DIR = join(homedir(), ".openclaw");
+/**
+ * Sync — OpenClawのagentsディレクトリをスキャンし、
+ * 一致するEngramをinject / memoryをextractする。
+ *
+ * 初回スキャン後は、呼び出し側がファイル監視を行い、
+ * 変更検知時に syncMemory() を呼ぶ。
+ */
+export class Sync {
+    repository;
+    inject;
+    extract;
+    constructor(repository) {
+        this.repository = repository;
+        this.inject = new Inject(repository);
+        this.extract = new Extract(repository);
+    }
+    /**
+     * OpenClawのagentsディレクトリをスキャンし、
+     * Engramが存在するagentにはinject、全agentからmemoryをextractする。
+     */
+    async initialSync(openclawDir) {
+        const baseDir = openclawDir ?? DEFAULT_OPENCLAW_DIR;
+        const agentsDir = join(baseDir, "agents");
+        if (!existsSync(agentsDir)) {
+            throw new SyncAgentsDirNotFoundError(agentsDir);
+        }
+        const targets = await this.scanAgents(agentsDir);
+        const injected = [];
+        const extracted = [];
+        for (const target of targets) {
+            // Engramがあるagentにはpersonaを注入
+            if (target.hasEngram) {
+                try {
+                    await this.inject.execute(target.engramId, { openclawDir });
+                    injected.push(target.engramId);
+                }
+                catch {
+                    // inject失敗は警告として続行
+                }
+            }
+            // 全agentからmemoryを抽出
+            try {
+                await this.extract.execute(target.engramId, {
+                    openclawDir,
+                });
+                extracted.push(target.engramId);
+            }
+            catch {
+                // extract失敗（新規Engramでname未指定等）はスキップ
+            }
+        }
+        return { injected, extracted, targets };
+    }
+    /**
+     * 特定agentのmemoryを同期（ファイル変更検知時に呼ばれる）
+     */
+    async syncMemory(engramId, openclawDir) {
+        await this.extract.execute(engramId, { openclawDir });
+    }
+    /**
+     * agentsディレクトリをスキャンしてターゲット一覧を返す
+     */
+    async scanAgents(agentsDir) {
+        const entries = await readdir(agentsDir, { withFileTypes: true });
+        const targets = [];
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const agentPath = join(agentsDir, entry.name, "agent");
+            if (!existsSync(agentPath))
+                continue;
+            const engram = await this.repository.get(entry.name);
+            targets.push({
+                engramId: entry.name,
+                agentPath,
+                hasEngram: engram !== null,
+            });
+        }
+        return targets;
+    }
+}
+export class SyncAgentsDirNotFoundError extends Error {
+    constructor(path) {
+        super(`OpenClaw agents directory not found at ${path}`);
+        this.name = "SyncAgentsDirNotFoundError";
+    }
+}

package/dist/interfaces/cli/commands/extract.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerExtractCommand(program: Command): void;

package/dist/interfaces/cli/commands/extract.js

@@ -0,0 +1,41 @@
+import { LocalEngramRepository } from "../../../adapters/local/index.js";
+import { Extract, WorkspaceNotFoundError, WorkspaceEmptyError, EngramAlreadyExistsError, ExtractNameRequiredError, } from "../../../core/usecases/index.js";
+import { resolveEngramsPath } from "../../../shared/config.js";
+export function registerExtractCommand(program) {
+    program
+        .command("extract")
+        .description("Extract an Engram from an OpenClaw workspace")
+        .requiredOption("-e, --engram <id>", "Engram ID (= agent name)")
+        .option("--name <name>", "Engram display name (required for new Engrams)")
+        .option("--openclaw <dir>", "Override OpenClaw directory path (default: ~/.openclaw)")
+        .option("-p, --path <dir>", "Override engrams directory path")
+        .option("-f, --force", "Overwrite existing Engram persona files")
+        .action(async (opts) => {
+        const engramsPath = await resolveEngramsPath(opts.path);
+        const repo = new LocalEngramRepository(engramsPath);
+        const extract = new Extract(repo);
+        try {
+            const result = await extract.execute(opts.engram, {
+                name: opts.name,
+                openclawDir: opts.openclaw,
+                force: opts.force,
+            });
+            console.log(`Extracted "${result.engramName}" from ${result.sourcePath}`);
+            console.log(`  Files read: ${result.filesRead.join(", ")}`);
+            console.log(`  Saved as Engram: ${result.engramId}`);
+            if (result.memoryMerged) {
+                console.log(`  Memory entries merged into existing Engram`);
+            }
+        }
+        catch (err) {
+            if (err instanceof WorkspaceNotFoundError ||
+                err instanceof WorkspaceEmptyError ||
+                err instanceof EngramAlreadyExistsError ||
+                err instanceof ExtractNameRequiredError) {
+                console.error(`Error: ${err.message}`);
+                process.exit(1);
+            }
+            throw err;
+        }
+    });
+}

package/dist/interfaces/cli/commands/init.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerInitCommand(program: Command): void;

package/dist/interfaces/cli/commands/init.js

@@ -0,0 +1,19 @@
+import { Init } from "../../../core/usecases/init.js";
+export function registerInitCommand(program) {
+    program
+        .command("init")
+        .description("Initialize ~/.relic/ directory and config")
+        .action(async () => {
+        const init = new Init();
+        const result = await init.execute();
+        if (result.created) {
+            console.log("Initialized RELIC:");
+            console.log(`  Config:  ${result.configPath}`);
+            console.log(`  Engrams: ${result.engramsPath}`);
+        }
+        else {
+            console.log("Already initialized.");
+            console.log(`  Config:  ${result.configPath}`);
+        }
+    });
+}

package/dist/interfaces/cli/commands/inject.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerInjectCommand(program: Command): void;

package/dist/interfaces/cli/commands/inject.js

@@ -0,0 +1,33 @@
+import { LocalEngramRepository } from "../../../adapters/local/index.js";
+import { Inject, InjectEngramNotFoundError, InjectAgentNotFoundError, } from "../../../core/usecases/index.js";
+import { resolveEngramsPath } from "../../../shared/config.js";
+export function registerInjectCommand(program) {
+    program
+        .command("inject")
+        .description("Inject an Engram into an OpenClaw workspace")
+        .requiredOption("-e, --engram <id>", "Engram ID to inject (= agent name)")
+        .option("--to <agent>", "Inject into a different agent name")
+        .option("--openclaw <dir>", "Override OpenClaw directory path (default: ~/.openclaw)")
+        .option("-p, --path <dir>", "Override engrams directory path")
+        .action(async (opts) => {
+        const engramsPath = await resolveEngramsPath(opts.path);
+        const repo = new LocalEngramRepository(engramsPath);
+        const inject = new Inject(repo);
+        try {
+            const result = await inject.execute(opts.engram, {
+                to: opts.to,
+                openclawDir: opts.openclaw,
+            });
+            console.log(`Injected "${result.engramName}" into ${result.targetPath}`);
+            console.log(`  Files written: ${result.filesWritten.join(", ")}`);
+        }
+        catch (err) {
+            if (err instanceof InjectEngramNotFoundError ||
+                err instanceof InjectAgentNotFoundError) {
+                console.error(`Error: ${err.message}`);
+                process.exit(1);
+            }
+            throw err;
+        }
+    });
+}

package/dist/interfaces/cli/commands/list.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerListCommand(program: Command): void;

package/dist/interfaces/cli/commands/list.js

@@ -0,0 +1,30 @@
+import { LocalEngramRepository } from "../../../adapters/local/index.js";
+import { ListEngrams } from "../../../core/usecases/index.js";
+import { resolveEngramsPath } from "../../../shared/config.js";
+export function registerListCommand(program) {
+    program
+        .command("list")
+        .description("List all Engrams in Mikoshi")
+        .option("-p, --path <dir>", "Override engrams directory path")
+        .action(async (opts) => {
+        const engramsPath = await resolveEngramsPath(opts.path);
+        const repo = new LocalEngramRepository(engramsPath);
+        const listEngrams = new ListEngrams(repo);
+        const engrams = await listEngrams.execute();
+        if (engrams.length === 0) {
+            console.log("No Engrams found.");
+            console.log(`  Path: ${engramsPath}`);
+            return;
+        }
+        console.log(`Engrams (${engrams.length}):\n`);
+        for (const e of engrams) {
+            const tags = e.tags?.length ? ` [${e.tags.join(", ")}]` : "";
+            console.log(`  ${e.id}`);
+            console.log(`    ${e.name}${tags}`);
+            if (e.description) {
+                console.log(`    ${e.description}`);
+            }
+            console.log();
+        }
+    });
+}

package/dist/interfaces/cli/commands/shell.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerShellCommands(program: Command): void;

package/dist/interfaces/cli/commands/shell.js

@@ -0,0 +1,69 @@
+import { resolve } from "node:path";
+import { LocalEngramRepository } from "../../../adapters/local/index.js";
+import { Summon, EngramNotFoundError } from "../../../core/usecases/index.js";
+import { resolveEngramsPath } from "../../../shared/config.js";
+import { ClaudeShell } from "../../../adapters/shells/claude-shell.js";
+import { GeminiShell } from "../../../adapters/shells/gemini-shell.js";
+import { CodexShell } from "../../../adapters/shells/codex-shell.js";
+import { CopilotShell } from "../../../adapters/shells/copilot-shell.js";
+const SHELLS = [
+    {
+        name: "claude",
+        description: "Summon an Engram into Claude Code CLI",
+        create: () => new ClaudeShell(),
+    },
+    {
+        name: "gemini",
+        description: "Summon an Engram into Gemini CLI",
+        create: () => new GeminiShell(),
+    },
+    {
+        name: "codex",
+        description: "Summon an Engram into Codex CLI",
+        create: () => new CodexShell(),
+    },
+    {
+        name: "copilot",
+        description: "Summon an Engram into GitHub Copilot CLI",
+        create: () => new CopilotShell(),
+    },
+];
+export function registerShellCommands(program) {
+    for (const shell of SHELLS) {
+        program
+            .command(shell.name)
+            .description(shell.description)
+            .requiredOption("-e, --engram <id>", "Engram ID to summon")
+            .option("-p, --path <dir>", "Override engrams directory path")
+            .option("--cwd <dir>", "Working directory for the Shell (default: current directory)")
+            .allowUnknownOption(true)
+            .action(async (opts, cmd) => {
+            const launcher = shell.create();
+            // Shell利用可能チェック
+            const available = await launcher.isAvailable();
+            if (!available) {
+                console.error(`Error: ${launcher.name} is not installed or not in PATH.`);
+                process.exit(1);
+            }
+            // Engram取得 & プロンプト生成
+            const engramsPath = await resolveEngramsPath(opts.path);
+            const repo = new LocalEngramRepository(engramsPath);
+            const summon = new Summon(repo);
+            try {
+                const result = await summon.execute(opts.engram);
+                console.log(`Summoning "${result.engramName}" into ${launcher.name}...\n`);
+                // --engram, --path, --cwd 以外の引数をShellにパススルー
+                const extraArgs = cmd.args;
+                const cwd = opts.cwd ? resolve(opts.cwd) : process.cwd();
+                await launcher.launch(result.prompt, extraArgs, cwd);
+            }
+            catch (err) {
+                if (err instanceof EngramNotFoundError) {
+                    console.error(`Error: ${err.message}`);
+                    process.exit(1);
+                }
+                throw err;
+            }
+        });
+    }
+}

package/dist/interfaces/cli/commands/show.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerShowCommand(program: Command): void;

package/dist/interfaces/cli/commands/show.js

@@ -0,0 +1,26 @@
+import { LocalEngramRepository } from "../../../adapters/local/index.js";
+import { Summon, EngramNotFoundError } from "../../../core/usecases/index.js";
+import { resolveEngramsPath } from "../../../shared/config.js";
+export function registerShowCommand(program) {
+    program
+        .command("show")
+        .description("Show an Engram's composed prompt")
+        .argument("<id>", "Engram ID to show")
+        .option("-p, --path <dir>", "Override engrams directory path")
+        .action(async (id, opts) => {
+        const engramsPath = await resolveEngramsPath(opts.path);
+        const repo = new LocalEngramRepository(engramsPath);
+        const summon = new Summon(repo);
+        try {
+            const result = await summon.execute(id);
+            console.log(result.prompt);
+        }
+        catch (err) {
+            if (err instanceof EngramNotFoundError) {
+                console.error(`Error: ${err.message}`);
+                process.exit(1);
+            }
+            throw err;
+        }
+    });
+}

package/dist/interfaces/cli/commands/sync.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerSyncCommand(program: Command): void;

package/dist/interfaces/cli/commands/sync.js

@@ -0,0 +1,91 @@
+import { watch } from "node:fs";
+import { join } from "node:path";
+import { LocalEngramRepository } from "../../../adapters/local/index.js";
+import { Sync, SyncAgentsDirNotFoundError, } from "../../../core/usecases/index.js";
+import { resolveEngramsPath } from "../../../shared/config.js";
+export function registerSyncCommand(program) {
+    program
+        .command("sync")
+        .description("Watch OpenClaw agents and auto-sync with Engrams")
+        .option("--openclaw <dir>", "Override OpenClaw directory path (default: ~/.openclaw)")
+        .option("-p, --path <dir>", "Override engrams directory path")
+        .action(async (opts) => {
+        const engramsPath = await resolveEngramsPath(opts.path);
+        const repo = new LocalEngramRepository(engramsPath);
+        const sync = new Sync(repo);
+        try {
+            console.log("Starting Relic sync...");
+            // 初回同期
+            const result = await sync.initialSync(opts.openclaw);
+            if (result.injected.length > 0) {
+                console.log(`  Injected: ${result.injected.join(", ")}`);
+            }
+            if (result.extracted.length > 0) {
+                console.log(`  Extracted memory: ${result.extracted.join(", ")}`);
+            }
+            if (result.targets.length === 0) {
+                console.log("  No agents found.");
+                return;
+            }
+            // ファイル監視を開始
+            const watchers = startWatching(result.targets, sync, opts.openclaw);
+            console.log(`\nWatching ${result.targets.length} agent(s) for memory changes...`);
+            console.log("Press Ctrl+C to stop.\n");
+            // Ctrl+C でクリーンアップ
+            const cleanup = () => {
+                console.log("\nStopping sync...");
+                for (const w of watchers) {
+                    w.close();
+                }
+                process.exit(0);
+            };
+            process.on("SIGINT", cleanup);
+            process.on("SIGTERM", cleanup);
+            // プロセスを維持
+            await new Promise(() => { });
+        }
+        catch (err) {
+            if (err instanceof SyncAgentsDirNotFoundError) {
+                console.error(`Error: ${err.message}`);
+                process.exit(1);
+            }
+            throw err;
+        }
+    });
+}
+function startWatching(targets, sync, openclawDir) {
+    const watchers = [];
+    // デバウンス用タイマー
+    const debounceTimers = new Map();
+    for (const target of targets) {
+        const memoryDir = join(target.agentPath, "memory");
+        try {
+            const watcher = watch(memoryDir, { recursive: true }, (_event, filename) => {
+                if (!filename?.endsWith(".md"))
+                    return;
+                // デバウンス（同一agentの連続変更を500msでまとめる）
+                const existing = debounceTimers.get(target.engramId);
+                if (existing)
+                    clearTimeout(existing);
+                debounceTimers.set(target.engramId, setTimeout(async () => {
+                    debounceTimers.delete(target.engramId);
+                    try {
+                        await sync.syncMemory(target.engramId, openclawDir);
+                        const now = new Date().toLocaleTimeString();
+                        console.log(`[${now}] Synced memory: ${target.engramId} (${filename})`);
+                    }
+                    catch {
+                        // sync失敗は警告のみ
+                        console.error(`[warn] Failed to sync memory for ${target.engramId}`);
+                    }
+                }, 500));
+            });
+            watchers.push(watcher);
+        }
+        catch {
+            // memory/ ディレクトリが存在しない場合はスキップ
+            // （エージェントにまだメモリがない）
+        }
+    }
+    return watchers;
+}

package/dist/interfaces/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/interfaces/cli/index.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { registerInitCommand } from "./commands/init.js";
+import { registerListCommand } from "./commands/list.js";
+import { registerShowCommand } from "./commands/show.js";
+import { registerShellCommands } from "./commands/shell.js";
+import { registerInjectCommand } from "./commands/inject.js";
+import { registerExtractCommand } from "./commands/extract.js";
+import { registerSyncCommand } from "./commands/sync.js";
+const program = new Command();
+program
+    .name("relic")
+    .description("PROJECT RELIC — Engram injection system for AI constructs")
+    .version("0.1.0");
+registerInitCommand(program);
+registerListCommand(program);
+registerShowCommand(program);
+registerShellCommands(program);
+registerInjectCommand(program);
+registerExtractCommand(program);
+registerSyncCommand(program);
+program.parse();

package/dist/interfaces/mcp/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};