@ectplsm/relic 0.5.2 → 0.5.4

package/README.md

@@ -2,7 +2,9 @@
 |:---:|:---:|
 
 # Relic: AI Persona Injection System
-![NPM Downloads](https://img.shields.io/npm/dt/%40ectplsm%2Frelic)
+[![NPM Version](https://img.shields.io/npm/v/%40ectplsm%2Frelic)](https://www.npmjs.com/package/@ectplsm/relic)
+[![NPM Downloads](https://img.shields.io/npm/dt/%40ectplsm%2Frelic)](https://www.npmjs.com/package/@ectplsm/relic)
+[![License](https://img.shields.io/npm/l/%40ectplsm%2Frelic)](https://github.com/ectplsm/relic/blob/main/LICENCE.md)
 
 <img src="assets/relic-hero.svg" alt="PROJECT RELIC" width="720">
 
@@ -25,12 +27,10 @@ Relic manages AI **Engrams** (memory + personality) and injects them across codi
 
 ## Requirements
 
-- Node.js 18 or later
+- Node.js 18.14.1 or later
 
 ## Install
 
-<img alt="version badge" src="https://img.shields.io/github/v/release/ectplsm/relic?filter=*.*.*">
-
 ```bash
 npm install -g @ectplsm/relic
 ```
@@ -208,6 +208,29 @@ Upcoming milestones that shape where Relic is heading:
 - **Structured memory decomposition** — break `MEMORY.md` down into episodic, semantic, and procedural memory so the Construct can recall the right kind of knowledge at the right time.
 - **Memory Wiki on llm-wiki** — build a navigable memory wiki on top of [llm-wiki](https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f), turning long-term memory into a browsable, linkable knowledge base instead of flat Markdown.
 
+## Development
+
+We welcome contributions! To set up the project locally for development:
+
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/ectplsm/relic.git
+   cd relic
+   ```
+2. Install dependencies:
+   ```bash
+   npm install
+   ```
+3. Available scripts:
+   - `npm run build`: Compile TypeScript into the `dist/` directory.
+   - `npm run typecheck`: Run the TypeScript compiler without emitting files.
+   - `npm run dev:cli`: Run the CLI in development mode (using `tsx`).
+   - `npm run dev:mcp`: Run the MCP server in development mode (using `tsx`).
+   - `npm run release:prepare -- <version>`: Generate release notes, validate the package, create and push the version commit and annotated tag, then create a draft GitHub Release. Codex generates the notes by default; use `--no-ai-notes`, `--notes-file <path>`, or `--dry-run` when needed.
+   - After reviewing the draft, run `gh workflow run release.yml --ref main -f tag=v<version>` to publish the package and GitHub Release. Before the first release, create a protected GitHub Environment named `npm`: restrict deployment branches to `main`, limit required reviewers to trusted release maintainers, and disable administrator bypass. Then configure npm Trusted Publishing for `ectplsm/relic`, workflow `release.yml`, environment `npm`, with direct publishing enabled. No long-lived npm token is used.
+
+Before contributing, please read [CLAUDE.md](./CLAUDE.md) for strict coding conventions, parent documents, and PR rules.
+
 ## License
 
-[MIT](./LICENCE.md)
+This project is licensed under the MIT License - see the [LICENCE.md](./LICENCE.md) file for details.

package/dist/adapters/shells/codex-hook.d.ts

@@ -5,11 +5,11 @@ export declare const CODEX_HOOK_SCRIPT_PATH: string;
  */
 export declare function writeCodexHookScript(): void;
 /**
- * Codex CLI の Stop フックを settings.json に登録する。
+ * Codex CLI の Stop フックを hooks.json に登録する。
  * 既にセットアップ済みの場合はスキップ。
  */
-export declare function setupCodexHook(): void;
+export declare function setupCodexHook(cwd?: string): void;
 /**
  * Stop フックがセットアップ済みか確認する。
  */
-export declare function isCodexHookSetup(): boolean;
+export declare function isCodexHookSetup(cwd?: string): boolean;

package/dist/adapters/shells/codex-hook.js

@@ -1,10 +1,10 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
+import { resolveCodexHome, resolveCodexHooksPath } from "./codex-paths.js";
 const RELIC_DIR = join(homedir(), ".relic");
 const HOOKS_DIR = join(RELIC_DIR, "hooks");
 export const CODEX_HOOK_SCRIPT_PATH = join(HOOKS_DIR, "codex-stop.js");
-const CODEX_HOOKS_PATH = join(homedir(), ".codex", "hooks.json");
 const RELIC_HOOK_COMMAND = `node ${join(HOOKS_DIR, "codex-stop.js")}`;
 /**
  * Stop hook スクリプトの内容。
@@ -88,17 +88,17 @@ export function writeCodexHookScript() {
     writeFileSync(CODEX_HOOK_SCRIPT_PATH, HOOK_SCRIPT, { encoding: "utf-8", mode: 0o755 });
 }
 /**
- * Codex CLI の Stop フックを settings.json に登録する。
+ * Codex CLI の Stop フックを hooks.json に登録する。
  * 既にセットアップ済みの場合はスキップ。
  */
-export function setupCodexHook() {
-    // ~/.codex/hooks.json に Stop フックを登録
-    const codexDir = join(homedir(), ".codex");
+export function setupCodexHook(cwd = process.cwd()) {
+    const codexDir = resolveCodexHome(cwd);
+    const codexHooksPath = resolveCodexHooksPath(cwd);
     mkdirSync(codexDir, { recursive: true });
     let hooksConfig = {};
-    if (existsSync(CODEX_HOOKS_PATH)) {
+    if (existsSync(codexHooksPath)) {
         try {
-            hooksConfig = JSON.parse(readFileSync(CODEX_HOOKS_PATH, "utf-8"));
+            hooksConfig = JSON.parse(readFileSync(codexHooksPath, "utf-8"));
         }
         catch {
             hooksConfig = {};
@@ -123,18 +123,19 @@ export function setupCodexHook() {
         },
     ];
     hooksConfig.hooks = hooks;
-    writeFileSync(CODEX_HOOKS_PATH, JSON.stringify(hooksConfig, null, 2), "utf-8");
+    writeFileSync(codexHooksPath, JSON.stringify(hooksConfig, null, 2), "utf-8");
 }
 /**
  * Stop フックがセットアップ済みか確認する。
  */
-export function isCodexHookSetup() {
+export function isCodexHookSetup(cwd = process.cwd()) {
+    const codexHooksPath = resolveCodexHooksPath(cwd);
     if (!existsSync(CODEX_HOOK_SCRIPT_PATH))
         return false;
-    if (!existsSync(CODEX_HOOKS_PATH))
+    if (!existsSync(codexHooksPath))
         return false;
     try {
-        const hooksConfig = JSON.parse(readFileSync(CODEX_HOOKS_PATH, "utf-8"));
+        const hooksConfig = JSON.parse(readFileSync(codexHooksPath, "utf-8"));
         const stopHooks = hooksConfig.hooks?.Stop ?? [];
         return stopHooks.some((group) => group.hooks?.some((h) => h.command === RELIC_HOOK_COMMAND));
     }

package/dist/adapters/shells/codex-paths.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Codex の state root を解決する。
+ *
+ * CODEX_HOME が未設定または空文字の場合は ~/.codex を使う。
+ * 相対パスは、実際に Codex を起動する作業ディレクトリを基準に解決する。
+ */
+export declare function resolveCodexHome(cwd?: string): string;
+/**
+ * Codex の user-level hooks.json の絶対パスを返す。
+ */
+export declare function resolveCodexHooksPath(cwd?: string): string;

package/dist/adapters/shells/codex-paths.js

@@ -0,0 +1,23 @@
+import { homedir } from "node:os";
+import { isAbsolute, join, resolve } from "node:path";
+const DEFAULT_CODEX_HOME = join(homedir(), ".codex");
+/**
+ * Codex の state root を解決する。
+ *
+ * CODEX_HOME が未設定または空文字の場合は ~/.codex を使う。
+ * 相対パスは、実際に Codex を起動する作業ディレクトリを基準に解決する。
+ */
+export function resolveCodexHome(cwd = process.cwd()) {
+    const configuredHome = process.env.CODEX_HOME;
+    if (!configuredHome)
+        return DEFAULT_CODEX_HOME;
+    return isAbsolute(configuredHome)
+        ? resolve(configuredHome)
+        : resolve(cwd, configuredHome);
+}
+/**
+ * Codex の user-level hooks.json の絶対パスを返す。
+ */
+export function resolveCodexHooksPath(cwd = process.cwd()) {
+    return join(resolveCodexHome(cwd), "hooks.json");
+}

package/dist/adapters/shells/codex-shell.js

@@ -3,6 +3,7 @@ import { promisify } from "node:util";
 import { spawnShell } from "./spawn-shell.js";
 import { wrapWithOverride } from "./override-preamble.js";
 import { setupCodexHook, isCodexHookSetup, writeCodexHookScript } from "./codex-hook.js";
+import { resolveCodexHooksPath } from "./codex-paths.js";
 const execAsync = promisify(exec);
 /**
  * Codex CLI アダプター
@@ -29,13 +30,14 @@ export class CodexShell {
         }
     }
     async launch(prompt, options) {
+        const cwd = options?.cwd ?? process.cwd();
         // フックスクリプトを毎回最新に更新
         writeCodexHookScript();
         // hooks.json への登録は初回のみ
-        if (!isCodexHookSetup()) {
+        if (!isCodexHookSetup(cwd)) {
             console.log("Setting up Codex CLI Stop hook (first run only)...");
-            setupCodexHook();
-            console.log("Hook registered to ~/.codex/hooks.json");
+            setupCodexHook(cwd);
+            console.log(`Hook registered to ${resolveCodexHooksPath(cwd)}`);
             console.log();
         }
         const args = [];
@@ -43,10 +45,10 @@ export class CodexShell {
         if (!options?.skipInjection) {
             args.push("-c", `developer_instructions=${JSON.stringify(wrapWithOverride(prompt))}`);
         }
-        args.push("-c", "features.hooks=true", ...(options?.extraArgs ?? []));
+        args.push(...(options?.extraArgs ?? []));
         const env = {};
         if (options?.engramId)
             env.RELIC_ENGRAM_ID = options.engramId;
-        await spawnShell(this.command, args, options?.cwd, Object.keys(env).length > 0 ? env : undefined);
+        await spawnShell(this.command, args, cwd, Object.keys(env).length > 0 ? env : undefined);
     }
 }

package/dist/interfaces/cli/index.js

@@ -3,6 +3,7 @@ import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { resolve, dirname } from "node:path";
 import { Command } from "commander";
+import updateNotifier from "update-notifier";
 import { registerInitCommand } from "./commands/init.js";
 import { registerListCommand } from "./commands/list.js";
 import { registerShowCommand } from "./commands/show.js";
@@ -16,6 +17,14 @@ import { registerDeleteCommand } from "./commands/delete.js";
 import { registerMikoshiCommand } from "./commands/mikoshi.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(resolve(__dirname, "../../../package.json"), "utf-8"));
+if (process.stdout.isTTY) {
+    updateNotifier({
+        pkg: {
+            name: pkg.name,
+            version: pkg.version,
+        },
+    }).notify({ defer: false });
+}
 const program = new Command();
 program
     .name("relic")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ectplsm/relic",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "description": "PROJECT RELIC — Engram injection system for AI constructs",
   "license": "MIT",
   "repository": {
@@ -24,22 +24,25 @@
     "dev:cli": "tsx src/interfaces/cli/index.ts",
     "dev:mcp": "tsx src/interfaces/mcp/index.ts",
     "typecheck": "tsc --noEmit",
-    "build": "tsc"
+    "build": "tsc",
+    "release:prepare": "node scripts/prepare-release.mjs"
   },
   "files": [
     "dist",
     "templates"
   ],
   "engines": {
-    "node": ">=18"
+    "node": ">=18.14.1"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.12.0",
+    "@modelcontextprotocol/sdk": "1.29.0",
     "commander": "^13.0.0",
+    "update-notifier": "^7.3.1",
     "zod": "^3.23.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
+    "@types/update-notifier": "^6.0.8",
     "tsx": "^4.19.0",
     "typescript": "^5.7.0"
   }

package/dist/adapters/shells/copilot-shell.d.ts

@@ -1,14 +0,0 @@
-import type { ShellLauncher, InjectionMode, ShellLaunchOptions } from "../../core/ports/shell-launcher.js";
-/**
- * GitHub Copilot CLI アダプター (copilot コマンド)
- * --interactive フラグでEngramを初回プロンプトとして注入し、
- * インタラクティブモードを継続する。
- */
-export declare class CopilotShell implements ShellLauncher {
-    private readonly command;
-    readonly name = "GitHub Copilot CLI";
-    readonly injectionMode: InjectionMode;
-    constructor(command?: string);
-    isAvailable(): Promise<boolean>;
-    launch(prompt: string, options?: ShellLaunchOptions): Promise<void>;
-}

package/dist/adapters/shells/copilot-shell.js

@@ -1,43 +0,0 @@
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
-import { readFileSync } from "node:fs";
-import { spawnShell, writeTempPrompt } from "./spawn-shell.js";
-import { wrapWithOverride } from "./override-preamble.js";
-const execAsync = promisify(exec);
-/**
- * GitHub Copilot CLI アダプター (copilot コマンド)
- * --interactive フラグでEngramを初回プロンプトとして注入し、
- * インタラクティブモードを継続する。
- */
-export class CopilotShell {
-    command;
-    name = "GitHub Copilot CLI";
-    injectionMode = "user-message";
-    constructor(command = "copilot") {
-        this.command = command;
-    }
-    async isAvailable() {
-        try {
-            await execAsync(`which ${this.command}`);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    async launch(prompt, options) {
-        const tmp = writeTempPrompt(wrapWithOverride(prompt));
-        try {
-            const fileContent = readFileSync(tmp.path, "utf-8");
-            const args = [
-                "--interactive",
-                fileContent,
-                ...(options?.extraArgs ?? []),
-            ];
-            await spawnShell(this.command, args, options?.cwd);
-        }
-        finally {
-            tmp.cleanup();
-        }
-    }
-}

package/dist/adapters/shells/trust-registrar.d.ts

@@ -1,19 +0,0 @@
-/**
- * TrustRegistrar — 各Shell CLIに ~/.relic/ ディレクトリの信頼設定を登録する
- *
- * `relic init` 時に一度だけ呼ばれ、以降のセッションで
- * inbox.md 等への書き込みが確認なしで通るようになる。
- *
- * 対応Shell:
- *   - Claude Code:  ~/.claude/settings.json    (sandbox.filesystem.allowWrite)
- *   - Codex CLI:    ~/.codex/config.toml       ([sandbox] writable_roots)
- *   - Gemini CLI:   ~/.gemini/trustedFolders.json (TRUST_FOLDER)
- */
-interface TrustResult {
-    /** 設定を追加したShell名の一覧 */
-    registered: string[];
-    /** 既に設定済みでスキップしたShell名の一覧 */
-    skipped: string[];
-}
-export declare function registerTrustedFolders(relicEngramsPath: string): Promise<TrustResult>;
-export {};

package/dist/adapters/shells/trust-registrar.js

@@ -1,141 +0,0 @@
-import { readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { homedir } from "node:os";
-import { existsSync } from "node:fs";
-export async function registerTrustedFolders(relicEngramsPath) {
-    const result = { registered: [], skipped: [] };
-    await Promise.all([
-        registerClaude(relicEngramsPath, result),
-        registerCodex(relicEngramsPath, result),
-        registerGemini(relicEngramsPath, result),
-    ]);
-    return result;
-}
-// ---------------------------------------------------------------------------
-// Claude Code — ~/.claude/settings.json
-// { "sandbox": { "filesystem": { "allowWrite": ["~/.relic/engrams"] } } }
-// ---------------------------------------------------------------------------
-async function registerClaude(engramsPath, result) {
-    const claudeDir = join(homedir(), ".claude");
-    const configPath = join(claudeDir, "settings.json");
-    if (!existsSync(claudeDir)) {
-        return;
-    }
-    try {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let settings = {};
-        if (existsSync(configPath)) {
-            const raw = await readFile(configPath, "utf-8");
-            settings = JSON.parse(raw);
-        }
-        // sandbox.filesystem.allowWrite を確保
-        settings.sandbox ??= {};
-        settings.sandbox.filesystem ??= {};
-        settings.sandbox.filesystem.allowWrite ??= [];
-        const allowWrite = settings.sandbox.filesystem.allowWrite;
-        // permissions.allow — ツール承認の自動化
-        settings.permissions ??= {};
-        settings.permissions.allow ??= [];
-        const allow = settings.permissions.allow;
-        const tildeForm = engramsPath.replace(homedir(), "~");
-        // sandbox: allowWrite
-        const sandboxNeeded = !allowWrite.includes(engramsPath) && !allowWrite.includes(tildeForm);
-        if (sandboxNeeded) {
-            allowWrite.push(tildeForm);
-        }
-        // permissions: Edit allow
-        const editRule = `Edit(${tildeForm}/**)`;
-        const permNeeded = !allow.includes(editRule);
-        if (permNeeded) {
-            allow.push(editRule);
-        }
-        if (!sandboxNeeded && !permNeeded) {
-            result.skipped.push("Claude Code");
-            return;
-        }
-        await writeFile(configPath, JSON.stringify(settings, null, 2), "utf-8");
-        result.registered.push("Claude Code");
-    }
-    catch {
-        // best effort
-    }
-}
-// ---------------------------------------------------------------------------
-// Codex CLI — ~/.codex/config.toml
-// [sandbox]
-// writable_roots = ["~/.relic/engrams"]
-// ---------------------------------------------------------------------------
-async function registerCodex(engramsPath, result) {
-    const codexDir = join(homedir(), ".codex");
-    const configPath = join(codexDir, "config.toml");
-    if (!existsSync(codexDir)) {
-        return;
-    }
-    try {
-        let content = "";
-        if (existsSync(configPath)) {
-            content = await readFile(configPath, "utf-8");
-        }
-        const tildeForm = engramsPath.replace(homedir(), "~");
-        // 既に writable_roots に含まれているかチェック
-        if (content.includes(engramsPath) || content.includes(tildeForm)) {
-            result.skipped.push("Codex CLI");
-            return;
-        }
-        // [sandbox] セクションが存在するか
-        const sandboxMatch = content.match(/^\[sandbox\]\s*$/m);
-        if (sandboxMatch) {
-            // [sandbox] セクション内の writable_roots を探す
-            const writableMatch = content.match(/^(writable_roots\s*=\s*\[)(.*?)(\])/m);
-            if (writableMatch) {
-                // 既存の writable_roots に追加
-                const existing = writableMatch[2].trim();
-                const newValue = existing
-                    ? `${existing}, "${tildeForm}"`
-                    : `"${tildeForm}"`;
-                content = content.replace(/^(writable_roots\s*=\s*\[)(.*?)(\])/m, `$1${newValue}$3`);
-            }
-            else {
-                // [sandbox] セクションに writable_roots を追加
-                content = content.replace(/^\[sandbox\]\s*$/m, `[sandbox]\nwritable_roots = ["${tildeForm}"]`);
-            }
-        }
-        else {
-            // [sandbox] セクションごと追加
-            content =
-                content.trimEnd() + `\n\n[sandbox]\nwritable_roots = ["${tildeForm}"]\n`;
-        }
-        await writeFile(configPath, content, "utf-8");
-        result.registered.push("Codex CLI");
-    }
-    catch {
-        // best effort
-    }
-}
-// ---------------------------------------------------------------------------
-// Gemini CLI — ~/.gemini/trustedFolders.json
-// { "/path/to/engrams": "TRUST_FOLDER" }
-// ---------------------------------------------------------------------------
-async function registerGemini(engramsPath, result) {
-    const configPath = join(homedir(), ".gemini", "trustedFolders.json");
-    if (!existsSync(join(homedir(), ".gemini"))) {
-        return;
-    }
-    try {
-        let folders = {};
-        if (existsSync(configPath)) {
-            const raw = await readFile(configPath, "utf-8");
-            folders = JSON.parse(raw);
-        }
-        if (folders[engramsPath]) {
-            result.skipped.push("Gemini CLI");
-            return;
-        }
-        folders[engramsPath] = "TRUST_FOLDER";
-        await writeFile(configPath, JSON.stringify(folders, null, 2), "utf-8");
-        result.registered.push("Gemini CLI");
-    }
-    catch {
-        // best effort
-    }
-}

package/dist/core/usecases/inbox-search.d.ts

@@ -1,20 +0,0 @@
-export interface InboxSearchResult {
-    /** マッチしたエントリの内容 */
-    entry: string;
-    /** エントリのインデックス（新しい順: 0が最新） */
-    index: number;
-}
-/**
- * InboxSearch — inbox.md をキーワード検索する
- *
- * inbox.md は全セッションログ + [memory] エントリを含む生データ。
- * memory/*.md（蒸留済み）より情報量が多いため、検索先として優れている。
- */
-export declare class InboxSearch {
-    private readonly engramsPath;
-    constructor(engramsPath: string);
-    search(engramId: string, query: string, limit?: number): Promise<InboxSearchResult[]>;
-}
-export declare class InboxSearchEngramNotFoundError extends Error {
-    constructor(id: string);
-}

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

@@ -1,46 +0,0 @@
-import { join } from "node:path";
-import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-const ENTRY_SEPARATOR = /\n---\n/;
-/**
- * InboxSearch — inbox.md をキーワード検索する
- *
- * inbox.md は全セッションログ + [memory] エントリを含む生データ。
- * memory/*.md（蒸留済み）より情報量が多いため、検索先として優れている。
- */
-export class InboxSearch {
-    engramsPath;
-    constructor(engramsPath) {
-        this.engramsPath = engramsPath;
-    }
-    async search(engramId, query, limit = 5) {
-        const inboxPath = join(this.engramsPath, engramId, "inbox.md");
-        if (!existsSync(inboxPath)) {
-            throw new InboxSearchEngramNotFoundError(engramId);
-        }
-        const raw = await readFile(inboxPath, "utf-8");
-        if (!raw.trim())
-            return [];
-        const entries = raw
-            .split(ENTRY_SEPARATOR)
-            .map((e) => e.trim())
-            .filter((e) => e.length > 0)
-            .reverse(); // 新しい順
-        const queryLower = query.toLowerCase();
-        const results = [];
-        for (let i = 0; i < entries.length; i++) {
-            if (entries[i].toLowerCase().includes(queryLower)) {
-                results.push({ entry: entries[i], index: i });
-            }
-            if (results.length >= limit)
-                break;
-        }
-        return results;
-    }
-}
-export class InboxSearchEngramNotFoundError extends Error {
-    constructor(id) {
-        super(`Engram "${id}" inbox not found`);
-        this.name = "InboxSearchEngramNotFoundError";
-    }
-}

package/dist/core/usecases/inbox-write.d.ts

@@ -1,27 +0,0 @@
-export interface InboxWriteResult {
-    engramId: string;
-    /** inbox.md に追記されたエントリ数 */
-    totalEntries: number;
-    /** memory/*.md に永続化されたメモリ数 */
-    memoriesSaved: number;
-    /** ログとして記録されたエントリ数 */
-    logsRecorded: number;
-}
-/**
- * InboxWrite — MCP経由で inbox.md にエントリを追記する
- *
- * CLI の MemoryInbox (fs.watch) と同じフォーマットで inbox.md に書き込む。
- * `[memory]` タグ付きエントリは即座に memory/*.md にも永続化する。
- *
- * これにより CLI Shell と MCP Desktop で同一の inbox.md フォーマットを共有し、
- * セッションログ + メモリ永続化の二重の役割を果たす。
- */
-export declare class InboxWrite {
-    private readonly engramsPath;
-    constructor(engramsPath: string);
-    execute(engramId: string, content: string): Promise<InboxWriteResult>;
-    private appendToInbox;
-}
-export declare class InboxWriteEngramNotFoundError extends Error {
-    constructor(id: string);
-}

package/dist/core/usecases/inbox-write.js

@@ -1,72 +0,0 @@
-import { join } from "node:path";
-import { existsSync } from "node:fs";
-import { readFile, writeFile, mkdir } from "node:fs/promises";
-import { MemoryWrite } from "./memory-write.js";
-const ENTRY_SEPARATOR = /\n---\n/;
-const MEMORY_TAG = /^\[memory\]\s*/i;
-/**
- * InboxWrite — MCP経由で inbox.md にエントリを追記する
- *
- * CLI の MemoryInbox (fs.watch) と同じフォーマットで inbox.md に書き込む。
- * `[memory]` タグ付きエントリは即座に memory/*.md にも永続化する。
- *
- * これにより CLI Shell と MCP Desktop で同一の inbox.md フォーマットを共有し、
- * セッションログ + メモリ永続化の二重の役割を果たす。
- */
-export class InboxWrite {
-    engramsPath;
-    constructor(engramsPath) {
-        this.engramsPath = engramsPath;
-    }
-    async execute(engramId, content) {
-        const engramDir = join(this.engramsPath, engramId);
-        if (!existsSync(engramDir)) {
-            throw new InboxWriteEngramNotFoundError(engramId);
-        }
-        // inbox.md に追記
-        const inboxPath = join(engramDir, "inbox.md");
-        await this.appendToInbox(inboxPath, content);
-        // エントリをパースして [memory] タグ付きを永続化
-        const entries = content
-            .split(ENTRY_SEPARATOR)
-            .map((e) => e.trim())
-            .filter((e) => e.length > 0);
-        const writer = new MemoryWrite(this.engramsPath);
-        let memoriesSaved = 0;
-        let logsRecorded = 0;
-        for (const entry of entries) {
-            if (MEMORY_TAG.test(entry)) {
-                const memContent = entry.replace(MEMORY_TAG, "").trim();
-                await writer.execute(engramId, memContent);
-                memoriesSaved++;
-            }
-            else {
-                logsRecorded++;
-            }
-        }
-        return {
-            engramId,
-            totalEntries: entries.length,
-            memoriesSaved,
-            logsRecorded,
-        };
-    }
-    async appendToInbox(inboxPath, content) {
-        await mkdir(join(inboxPath, ".."), { recursive: true });
-        let existing = "";
-        if (existsSync(inboxPath)) {
-            existing = await readFile(inboxPath, "utf-8");
-        }
-        // 既存内容があれば --- で区切って追記
-        const separator = existing.length > 0 && !existing.endsWith("\n---\n")
-            ? "\n---\n"
-            : "";
-        await writeFile(inboxPath, existing + separator + content + "\n", "utf-8");
-    }
-}
-export class InboxWriteEngramNotFoundError extends Error {
-    constructor(id) {
-        super(`Engram "${id}" not found`);
-        this.name = "InboxWriteEngramNotFoundError";
-    }
-}