@ectplsm/relic 0.5.2 → 0.5.3

package/dist/core/usecases/memory-search.js

@@ -1,59 +0,0 @@
-/**
- * MemorySearch — Engramのメモリエントリをキーワード検索する
- */
-export class MemorySearch {
-    repository;
-    constructor(repository) {
-        this.repository = repository;
-    }
-    async search(engramId, query, limit = 5) {
-        const engram = await this.repository.get(engramId);
-        if (!engram) {
-            throw new MemoryEngramNotFoundError(engramId);
-        }
-        if (!engram.files.memoryEntries) {
-            return [];
-        }
-        const queryLower = query.toLowerCase();
-        const results = [];
-        // Search entries from newest to oldest
-        const entries = Object.entries(engram.files.memoryEntries).sort(([a], [b]) => b.localeCompare(a));
-        for (const [date, content] of entries) {
-            const lines = content.split("\n");
-            const matchedLines = lines.filter((line) => line.toLowerCase().includes(queryLower));
-            if (matchedLines.length > 0) {
-                results.push({ date, content, matchedLines });
-            }
-            if (results.length >= limit)
-                break;
-        }
-        return results;
-    }
-    async get(engramId, date) {
-        const engram = await this.repository.get(engramId);
-        if (!engram) {
-            throw new MemoryEngramNotFoundError(engramId);
-        }
-        const content = engram.files.memoryEntries?.[date];
-        if (!content) {
-            return null;
-        }
-        return { date, content };
-    }
-    async listDates(engramId) {
-        const engram = await this.repository.get(engramId);
-        if (!engram) {
-            throw new MemoryEngramNotFoundError(engramId);
-        }
-        if (!engram.files.memoryEntries) {
-            return [];
-        }
-        return Object.keys(engram.files.memoryEntries).sort((a, b) => b.localeCompare(a));
-    }
-}
-export class MemoryEngramNotFoundError extends Error {
-    constructor(id) {
-        super(`Engram "${id}" not found`);
-        this.name = "MemoryEngramNotFoundError";
-    }
-}

package/dist/core/usecases/mikoshi-clone.d.ts

@@ -1,29 +0,0 @@
-import type { EngramRepository } from "../ports/engram-repository.js";
-import type { MikoshiClient } from "../ports/mikoshi.js";
-export interface MikoshiCloneResult {
-    engramId: string;
-    engramName: string;
-    cloudEngramId: string;
-}
-export declare class MikoshiCloneAlreadyExistsError extends Error {
-    readonly engramId: string;
-    constructor(engramId: string);
-}
-export declare class MikoshiCloneCloudNotFoundError extends Error {
-    readonly sourceEngramId: string;
-    constructor(sourceEngramId: string);
-}
-export declare class MikoshiClonePersonaMissingError extends Error {
-    readonly cloudEngramId: string;
-    constructor(cloudEngramId: string);
-}
-export declare class MikoshiClone {
-    private readonly localRepo;
-    private readonly mikoshi;
-    constructor(localRepo: EngramRepository, mikoshi: MikoshiClient);
-    /**
-     * Clone a remote Engram from Mikoshi to local.
-     * Fails if the local Engram already exists.
-     */
-    execute(engramId: string): Promise<MikoshiCloneResult>;
-}

package/dist/core/usecases/mikoshi-clone.js

@@ -1,94 +0,0 @@
-// ---------------------------------------------------------------------------
-// Errors
-// ---------------------------------------------------------------------------
-export class MikoshiCloneAlreadyExistsError extends Error {
-    engramId;
-    constructor(engramId) {
-        super(`Engram "${engramId}" already exists locally. Use "relic mikoshi pull" to update it.`);
-        this.engramId = engramId;
-        this.name = "MikoshiCloneAlreadyExistsError";
-    }
-}
-export class MikoshiCloneCloudNotFoundError extends Error {
-    sourceEngramId;
-    constructor(sourceEngramId) {
-        super(`Engram "${sourceEngramId}" not found on Mikoshi`);
-        this.sourceEngramId = sourceEngramId;
-        this.name = "MikoshiCloneCloudNotFoundError";
-    }
-}
-export class MikoshiClonePersonaMissingError extends Error {
-    cloudEngramId;
-    constructor(cloudEngramId) {
-        super(`Remote Engram "${cloudEngramId}" is missing SOUL.md or IDENTITY.md`);
-        this.cloudEngramId = cloudEngramId;
-        this.name = "MikoshiClonePersonaMissingError";
-    }
-}
-// ---------------------------------------------------------------------------
-// Usecase
-// ---------------------------------------------------------------------------
-export class MikoshiClone {
-    localRepo;
-    mikoshi;
-    constructor(localRepo, mikoshi) {
-        this.localRepo = localRepo;
-        this.mikoshi = mikoshi;
-    }
-    /**
-     * Clone a remote Engram from Mikoshi to local.
-     * Fails if the local Engram already exists.
-     */
-    async execute(engramId) {
-        // 1. ローカルに既に存在 → エラー
-        const existing = await this.localRepo.get(engramId);
-        if (existing) {
-            throw new MikoshiCloneAlreadyExistsError(engramId);
-        }
-        // 2. クラウド検索
-        const cloudEngram = await this.mikoshi.getEngramBySourceId(engramId);
-        if (!cloudEngram)
-            throw new MikoshiCloneCloudNotFoundError(engramId);
-        // 3. Detail 取得 (persona content 込み)
-        const detail = await this.mikoshi.getEngram(cloudEngram.id);
-        const { soul, identity } = extractPersona(detail);
-        if (!soul || !identity) {
-            throw new MikoshiClonePersonaMissingError(cloudEngram.id);
-        }
-        // 4. ローカルに新規作成
-        const now = new Date().toISOString();
-        await this.localRepo.save({
-            meta: {
-                id: engramId,
-                name: detail.name,
-                description: detail.description ?? undefined,
-                tags: detail.tags,
-                createdAt: now,
-                updatedAt: now,
-            },
-            files: {
-                soul,
-                identity,
-            },
-        });
-        return {
-            engramId,
-            engramName: detail.name,
-            cloudEngramId: cloudEngram.id,
-        };
-    }
-}
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function extractPersona(detail) {
-    let soul;
-    let identity;
-    for (const f of detail.personaFiles) {
-        if (f.fileType === "SOUL")
-            soul = f.content;
-        if (f.fileType === "IDENTITY")
-            identity = f.content;
-    }
-    return { soul, identity };
-}

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

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

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

@@ -1,37 +0,0 @@
-import { LocalEngramRepository } from "../../../adapters/local/index.js";
-import { Extract, WorkspaceNotFoundError, WorkspaceEmptyError, AlreadyExtractedError, } from "../../../core/usecases/index.js";
-import { resolveEngramsPath, resolveOpenclawPath } from "../../../shared/config.js";
-export function registerExtractCommand(program) {
-    program
-        .command("extract")
-        .description("Create a new Engram from an OpenClaw agent workspace")
-        .option("-a, --agent <name>", "OpenClaw agent name to extract from (default: main)")
-        .option("--name <name>", "Engram display name (defaults to 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 openclawDir = await resolveOpenclawPath(opts.openclaw);
-        const repo = new LocalEngramRepository(engramsPath);
-        const extract = new Extract(repo);
-        try {
-            const agentName = opts.agent ?? "main";
-            const result = await extract.execute(agentName, {
-                name: opts.name,
-                openclawDir,
-            });
-            console.log(`Extracted "${result.engramName}" from ${result.sourcePath}`);
-            console.log(`  Files read: ${result.filesRead.join(", ")}`);
-            console.log(`  Saved as Engram: ${result.engramId}`);
-        }
-        catch (err) {
-            if (err instanceof WorkspaceNotFoundError ||
-                err instanceof WorkspaceEmptyError ||
-                err instanceof AlreadyExtractedError) {
-                console.error(`Error: ${err.message}`);
-                process.exit(1);
-            }
-            throw err;
-        }
-    });
-}

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

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

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

@@ -1,34 +0,0 @@
-import { LocalEngramRepository } from "../../../adapters/local/index.js";
-import { Inject, InjectEngramNotFoundError, InjectWorkspaceNotFoundError, } from "../../../core/usecases/index.js";
-import { resolveEngramsPath, resolveOpenclawPath } 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 openclawDir = await resolveOpenclawPath(opts.openclaw);
-        const repo = new LocalEngramRepository(engramsPath);
-        const inject = new Inject(repo);
-        try {
-            const result = await inject.execute(opts.engram, {
-                to: opts.to,
-                openclawDir,
-            });
-            console.log(`Injected "${result.engramName}" into ${result.targetPath}`);
-            console.log(`  Files written: ${result.filesWritten.join(", ")}`);
-        }
-        catch (err) {
-            if (err instanceof InjectEngramNotFoundError ||
-                err instanceof InjectWorkspaceNotFoundError) {
-                console.error(`Error: ${err.message}`);
-                process.exit(1);
-            }
-            throw err;
-        }
-    });
-}

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

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

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

@@ -1,47 +0,0 @@
-import { LocalEngramRepository } from "../../../adapters/local/index.js";
-import { Sync, SyncOpenclawDirNotFoundError, } from "../../../core/usecases/index.js";
-import { resolveEngramsPath } from "../../../shared/config.js";
-export function registerSyncCommand(program) {
-    program
-        .command("sync")
-        .description("Bidirectional memory sync between Relic Engrams and OpenClaw workspaces")
-        .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, engramsPath);
-        try {
-            const result = await sync.execute(opts.openclaw);
-            if (result.synced.length === 0 && result.skipped.length === 0) {
-                console.log("No OpenClaw workspaces found.");
-                return;
-            }
-            for (const s of result.synced) {
-                const details = [];
-                if (s.memoryFilesMerged > 0) {
-                    details.push(`${s.memoryFilesMerged} memory file(s)`);
-                }
-                if (s.memoryIndexMerged) {
-                    details.push("MEMORY.md");
-                }
-                if (details.length > 0) {
-                    console.log(`  ${s.engramId}: merged ${details.join(", ")}`);
-                }
-                else {
-                    console.log(`  ${s.engramId}: already in sync`);
-                }
-            }
-            if (result.skipped.length > 0) {
-                console.log(`  Skipped (no matching Engram): ${result.skipped.join(", ")}`);
-            }
-        }
-        catch (err) {
-            if (err instanceof SyncOpenclawDirNotFoundError) {
-                console.error(`Error: ${err.message}`);
-                process.exit(1);
-            }
-            throw err;
-        }
-    });
-}

package/dist/shared/memory-inbox.d.ts

@@ -1,78 +0,0 @@
-/**
- * MemoryInbox — ファイルベースのメモリ受付口 + セッションログ
- *
- * LLMが inbox.md に追記すると、fs.watchで検知して処理する。
- * inbox.md は書き溜め式で、セッションを跨いで追記され続ける。
- * 処理済みエントリ数は inbox.cursor に永続化され、
- * クラッシュ後の再起動でも正確に未処理分だけを回収できる。
- *
- * エントリの種別:
- *   - `[memory] ...` → memory/*.md に永続化される記憶
- *   - タグ無し       → inbox.md にログとして残るだけ（会話サマリー等）
- *
- * フォーマット:
- *   各エントリは `---` (前後に改行) で区切る。
- *
- * 例:
- *   Discussed improving RELIC's memory system.
- *   ---
- *   Implemented inbox-based approach for cross-LLM persistence.
- *   ---
- *   [memory] User prefers Bun over Node.js for all TypeScript projects.
- *   ---
- *   [memory] Project RELIC uses clean architecture with Zod for validation.
- */
-export declare class MemoryInbox {
-    private readonly engramId;
-    private readonly engramsPath;
-    private watcher;
-    private processedCount;
-    private processing;
-    private memorySaved;
-    private logCount;
-    private savedEntries;
-    readonly inboxPath: string;
-    private readonly cursorPath;
-    constructor(engramId: string, engramsPath: string);
-    /**
-     * Inboxを起動する。
-     *
-     * 1. cursorファイルから前回の処理済み位置を復元
-     * 2. inbox.md の未処理エントリを回収（クラッシュ回復）
-     * 3. fs.watch で監視開始
-     */
-    start(): Promise<MemoryInboxRecoveryResult>;
-    /**
-     * 監視を停止し、最終掃引を行う。
-     * inbox.md はそのまま残す（書き溜め式）。
-     */
-    stop(): Promise<MemoryInboxResult>;
-    /**
-     * ファイル全体をパースし、未処理のエントリだけを処理する。
-     *
-     * - `[memory]` タグ付き → MemoryWrite で永続化
-     * - タグ無し → カウントのみ（inbox.md にログとして残る）
-     *
-     * 処理成功ごとにカーソルを永続化するため、
-     * 途中でクラッシュしても処理済み分は再処理されない。
-     */
-    private processNewEntries;
-    private loadCursor;
-    private saveCursor;
-}
-export interface MemoryInboxResult {
-    /** memory/*.md に永続化されたエントリ数 */
-    memories: number;
-    /** ログとして記録されたエントリ数 */
-    logs: number;
-    /** 永続化されたメモリの内容 */
-    entries: string[];
-}
-export interface MemoryInboxRecoveryResult {
-    /** 回収されたメモリ数 */
-    recoveredMemories: number;
-    /** 回収されたログ数 */
-    recoveredLogs: number;
-    /** 回収されたメモリの内容 */
-    entries: string[];
-}

package/dist/shared/memory-inbox.js

@@ -1,168 +0,0 @@
-import { watch, existsSync, writeFileSync, readFileSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { MemoryWrite } from "../core/usecases/memory-write.js";
-const INBOX_FILE = "inbox.md";
-const CURSOR_FILE = "inbox.cursor";
-const ENTRY_SEPARATOR = /\n---\n/;
-const MEMORY_TAG = /^\[memory\]\s*/i;
-/**
- * MemoryInbox — ファイルベースのメモリ受付口 + セッションログ
- *
- * LLMが inbox.md に追記すると、fs.watchで検知して処理する。
- * inbox.md は書き溜め式で、セッションを跨いで追記され続ける。
- * 処理済みエントリ数は inbox.cursor に永続化され、
- * クラッシュ後の再起動でも正確に未処理分だけを回収できる。
- *
- * エントリの種別:
- *   - `[memory] ...` → memory/*.md に永続化される記憶
- *   - タグ無し       → inbox.md にログとして残るだけ（会話サマリー等）
- *
- * フォーマット:
- *   各エントリは `---` (前後に改行) で区切る。
- *
- * 例:
- *   Discussed improving RELIC's memory system.
- *   ---
- *   Implemented inbox-based approach for cross-LLM persistence.
- *   ---
- *   [memory] User prefers Bun over Node.js for all TypeScript projects.
- *   ---
- *   [memory] Project RELIC uses clean architecture with Zod for validation.
- */
-export class MemoryInbox {
-    engramId;
-    engramsPath;
-    watcher = null;
-    processedCount = 0;
-    processing = false;
-    memorySaved = 0;
-    logCount = 0;
-    savedEntries = [];
-    inboxPath;
-    cursorPath;
-    constructor(engramId, engramsPath) {
-        this.engramId = engramId;
-        this.engramsPath = engramsPath;
-        const engramDir = join(engramsPath, engramId);
-        this.inboxPath = join(engramDir, INBOX_FILE);
-        this.cursorPath = join(engramDir, CURSOR_FILE);
-    }
-    /**
-     * Inboxを起動する。
-     *
-     * 1. cursorファイルから前回の処理済み位置を復元
-     * 2. inbox.md の未処理エントリを回収（クラッシュ回復）
-     * 3. fs.watch で監視開始
-     */
-    async start() {
-        if (!existsSync(this.inboxPath)) {
-            writeFileSync(this.inboxPath, "", "utf-8");
-        }
-        this.processedCount = this.loadCursor();
-        const recovered = await this.processNewEntries();
-        this.watcher = watch(this.inboxPath, async (eventType) => {
-            if (eventType === "change") {
-                await this.processNewEntries();
-            }
-        });
-        this.watcher.on("error", () => { });
-        return {
-            recoveredMemories: recovered.memories,
-            recoveredLogs: recovered.logs,
-            entries: recovered.savedEntries,
-        };
-    }
-    /**
-     * 監視を停止し、最終掃引を行う。
-     * inbox.md はそのまま残す（書き溜め式）。
-     */
-    async stop() {
-        if (this.watcher) {
-            this.watcher.close();
-            this.watcher = null;
-        }
-        await this.processNewEntries();
-        return {
-            memories: this.memorySaved,
-            logs: this.logCount,
-            entries: this.savedEntries,
-        };
-    }
-    /**
-     * ファイル全体をパースし、未処理のエントリだけを処理する。
-     *
-     * - `[memory]` タグ付き → MemoryWrite で永続化
-     * - タグ無し → カウントのみ（inbox.md にログとして残る）
-     *
-     * 処理成功ごとにカーソルを永続化するため、
-     * 途中でクラッシュしても処理済み分は再処理されない。
-     */
-    async processNewEntries() {
-        if (this.processing)
-            return { memories: 0, logs: 0, savedEntries: [] };
-        this.processing = true;
-        const result = { memories: 0, logs: 0, savedEntries: [] };
-        try {
-            if (!existsSync(this.inboxPath))
-                return result;
-            const fullContent = await readFile(this.inboxPath, "utf-8");
-            if (!fullContent.trim())
-                return result;
-            const allEntries = fullContent
-                .split(ENTRY_SEPARATOR)
-                .map((e) => e.trim())
-                .filter((e) => e.length > 0);
-            const newEntries = allEntries.slice(this.processedCount);
-            if (newEntries.length === 0)
-                return result;
-            const writer = new MemoryWrite(this.engramsPath);
-            for (const raw of newEntries) {
-                const isMemory = MEMORY_TAG.test(raw);
-                if (isMemory) {
-                    const content = raw.replace(MEMORY_TAG, "").trim();
-                    try {
-                        await writer.execute(this.engramId, content);
-                        this.memorySaved++;
-                        this.savedEntries.push(content);
-                        result.memories++;
-                        result.savedEntries.push(content);
-                    }
-                    catch (err) {
-                        console.error(`[relic:inbox] Failed to save memory: ${err}`);
-                    }
-                }
-                else {
-                    this.logCount++;
-                    result.logs++;
-                }
-                this.processedCount++;
-                this.saveCursor();
-            }
-        }
-        finally {
-            this.processing = false;
-        }
-        return result;
-    }
-    loadCursor() {
-        if (!existsSync(this.cursorPath))
-            return 0;
-        try {
-            const raw = readFileSync(this.cursorPath, "utf-8").trim();
-            const n = parseInt(raw, 10);
-            return Number.isNaN(n) ? 0 : n;
-        }
-        catch {
-            return 0;
-        }
-    }
-    saveCursor() {
-        try {
-            writeFileSync(this.cursorPath, String(this.processedCount), "utf-8");
-        }
-        catch {
-            /* best effort */
-        }
-    }
-}

package/dist/shared/session-recorder.d.ts

@@ -1,47 +0,0 @@
-/**
- * SessionRecorder — PTYストリームから会話履歴とメモリを記録する
- *
- * 役割:
- * 1. full_history.md に全会話を蓄積（ANSI除去済みテキスト）
- * 2. ストリーム中の [memory] タグを検出し memory/*.md に永続化
- *
- * full_history.md は無限に蓄積され続ける。セッションごとにヘッダーが挿入される。
- */
-export declare class SessionRecorder {
-    private readonly engramId;
-    private readonly engramsPath;
-    readonly historyPath: string;
-    private memoryBuffer;
-    private memorySaved;
-    private savedEntries;
-    constructor(engramId: string, engramsPath: string);
-    /**
-     * セッション開始。ヘッダーを full_history.md に追記する。
-     */
-    start(shellName: string): void;
-    /**
-     * PTYストリームのデータを処理する。
-     * spawnShellWithPty の onData コールバックから呼ぶ。
-     *
-     * - ANSI除去してfull_history.mdに追記
-     * - [memory] タグを検出してバッファに溜める
-     */
-    onData(rawData: string): void;
-    /**
-     * セッション終了。残りのバッファを処理する。
-     */
-    stop(): Promise<SessionRecorderResult>;
-    /**
-     * memoryBuffer から完成した行を取り出し、[memory] タグを検出して永続化する。
-     * final=true の場合は残りのバッファも全て処理する。
-     */
-    private flushMemoryBuffer;
-}
-export interface SessionRecorderResult {
-    /** memory/*.md に永続化されたメモリ数 */
-    memories: number;
-    /** 永続化されたメモリの内容 */
-    entries: string[];
-    /** full_history.md のパス */
-    historyPath: string;
-}