@ectplsm/relic 0.3.2 → 0.5.0

package/dist/interfaces/cli/spinner.js

@@ -0,0 +1,47 @@
+const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const INTERVAL_MS = 80;
+/**
+ * Start a CLI spinner that overwrites the current line.
+ *
+ * Falls back to a single static line when stdout is not a TTY
+ * (e.g. CI, piped output).
+ */
+export function startSpinner(message) {
+    const isTTY = process.stdout.isTTY ?? false;
+    let currentMessage = message;
+    if (!isTTY) {
+        process.stdout.write(`${message}\n`);
+        return {
+            update(msg) {
+                currentMessage = msg;
+                process.stdout.write(`${msg}\n`);
+            },
+            stop(finalMessage) {
+                if (finalMessage) {
+                    process.stdout.write(`${finalMessage}\n`);
+                }
+            },
+        };
+    }
+    let frameIndex = 0;
+    const render = () => {
+        const frame = FRAMES[frameIndex % FRAMES.length];
+        process.stdout.write(`\r${frame} ${currentMessage}`);
+        frameIndex++;
+    };
+    render();
+    const timer = setInterval(render, INTERVAL_MS);
+    return {
+        update(msg) {
+            currentMessage = msg;
+        },
+        stop(finalMessage) {
+            clearInterval(timer);
+            // Clear the spinner line
+            process.stdout.write("\r\x1b[2K");
+            if (finalMessage) {
+                process.stdout.write(`${finalMessage}\n`);
+            }
+        },
+    };
+}

package/dist/interfaces/mcp/index.js

@@ -3,8 +3,8 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 import { ArchiveSearch, ArchiveSearchEngramNotFoundError, } from "../../core/usecases/archive-search.js";
-import { ArchivePending, ArchivePendingEngramNotFoundError, } from "../../core/usecases/archive-pending.js";
-import { ArchiveCursorUpdate, } from "../../core/usecases/archive-cursor-update.js";
+import { ArchivePending, ArchiveCursorCorruptedError, ArchivePendingEngramNotFoundError, } from "../../core/usecases/archive-pending.js";
+import { ArchiveCursorUpdate, ArchiveCursorAdvanceOverflowError, } from "../../core/usecases/archive-cursor-update.js";
 import { MemoryWrite, MemoryWriteEngramNotFoundError, } from "../../core/usecases/memory-write.js";
 import { CreateEngram, EngramAlreadyExistsError, InvalidEngramIdError, } from "../../core/usecases/create-engram.js";
 import { DEFAULT_SOUL, DEFAULT_IDENTITY } from "../../shared/templates.js";
@@ -13,6 +13,63 @@ import { join } from "node:path";
 import { existsSync } from "node:fs";
 import { readFile, writeFile } from "node:fs/promises";
 import { resolveDistillationBatchSize, resolveEngramsPath, } from "../../shared/config.js";
+async function appendLongTermAndUserProfile(engramsPath, id, long_term, user_profile) {
+    let longTermWritten = false;
+    if (long_term) {
+        const memoryMdPath = join(engramsPath, id, "MEMORY.md");
+        if (existsSync(memoryMdPath)) {
+            const existing = await readFile(memoryMdPath, "utf-8");
+            const separator = existing.endsWith("\n") ? "\n" : "\n\n";
+            await writeFile(memoryMdPath, existing + separator + long_term + "\n", "utf-8");
+        }
+        else {
+            await writeFile(memoryMdPath, long_term + "\n", "utf-8");
+        }
+        longTermWritten = true;
+    }
+    let userProfileWritten = false;
+    if (user_profile) {
+        const userMdPath = join(engramsPath, id, "USER.md");
+        await writeFile(userMdPath, user_profile + "\n", "utf-8");
+        userProfileWritten = true;
+    }
+    return { longTermWritten, userProfileWritten };
+}
+function assertDateCoverage(writes, expectedDates, skippedDates) {
+    const writeDates = writes.map((write) => write.date);
+    const duplicateWriteDates = findDuplicates(writeDates);
+    if (duplicateWriteDates.length > 0) {
+        throw new Error(`Duplicate write dates are not allowed: ${duplicateWriteDates.join(", ")}`);
+    }
+    const duplicateSkippedDates = findDuplicates(skippedDates);
+    if (duplicateSkippedDates.length > 0) {
+        throw new Error(`Duplicate skipped_dates are not allowed: ${duplicateSkippedDates.join(", ")}`);
+    }
+    const overlappedDates = writeDates.filter((date) => skippedDates.includes(date));
+    if (overlappedDates.length > 0) {
+        throw new Error(`Dates cannot appear in both writes and skipped_dates: ${[...new Set(overlappedDates)].join(", ")}`);
+    }
+    const expectedSet = new Set(expectedDates);
+    const coveredDates = [...writeDates, ...skippedDates];
+    const unexpectedDates = coveredDates.filter((date) => !expectedSet.has(date));
+    if (unexpectedDates.length > 0) {
+        throw new Error(`Unexpected dates: ${[...new Set(unexpectedDates)].join(", ")}`);
+    }
+    const coveredSet = new Set(coveredDates);
+    const missingDates = expectedDates.filter((date) => !coveredSet.has(date));
+    if (missingDates.length > 0) {
+        throw new Error(`Missing dates: ${missingDates.join(", ")}`);
+    }
+}
+function findDuplicates(values) {
+    const counts = new Map();
+    for (const value of values) {
+        counts.set(value, (counts.get(value) ?? 0) + 1);
+    }
+    return [...counts.entries()]
+        .filter(([, count]) => count > 1)
+        .map(([value]) => value);
+}
 const server = new McpServer({
     name: "relic",
     version: "0.1.0",
@@ -153,16 +210,34 @@ server.tool("relic_archive_pending", "Get un-distilled archive entries since the
                 ],
             };
         }
-        const header = `cursor: ${result.cursor} | total: ${result.total} | returned: ${result.entries.length} | remaining: ${result.remaining}`;
+        const dates = [...new Set(result.entries.map((entry) => entry.date).filter(Boolean))];
+        const header = [
+            `cursor: ${result.cursor}`,
+            `total: ${result.total}`,
+            `returned: ${result.entries.length}`,
+            `remaining: ${result.remaining}`,
+            `dates: ${dates.length > 0 ? dates.join(", ") : "unknown"}`,
+        ].join(" | ");
         const body = result.entries
-            .map((e, i) => `[entry ${result.cursor + i + 1}]\n${e}`)
+            .map((entry, i) => {
+            const lines = [`[entry ${result.cursor + i + 1}]`];
+            if (entry.date) {
+                lines.push(`date: ${entry.date}`);
+            }
+            if (entry.summary) {
+                lines.push(`summary: ${entry.summary}`);
+            }
+            lines.push(entry.raw);
+            return lines.join("\n");
+        })
             .join("\n\n---\n\n");
         return {
             content: [{ type: "text", text: `${header}\n\n${body}` }],
         };
     }
     catch (err) {
-        if (err instanceof ArchivePendingEngramNotFoundError) {
+        if (err instanceof ArchivePendingEngramNotFoundError ||
+            err instanceof ArchiveCursorCorruptedError) {
             return {
                 content: [{ type: "text", text: err.message }],
                 isError: true,
@@ -174,7 +249,19 @@ server.tool("relic_archive_pending", "Get un-distilled archive entries since the
 // --- relic_memory_write ---
 server.tool("relic_memory_write", "Write distilled memory to an Engram's memory file and advance the archive cursor. Call this after reviewing pending archive entries and distilling them into key insights.", {
     id: z.string().describe("Engram ID"),
-    content: z.string().describe("Distilled memory content to write to memory/YYYY-MM-DD.md"),
+    writes: z
+        .array(z.object({
+        date: z.string().describe("Archive entry date for this memory file (YYYY-MM-DD)"),
+        content: z.string().describe("Distilled memory content for memory/YYYY-MM-DD.md"),
+    }))
+        .min(0)
+        .describe("Distilled memory writes grouped by actual archive dates"),
+    expected_dates: z
+        .array(z.string())
+        .describe("All archive dates that must be explicitly covered by writes or skipped_dates"),
+    skipped_dates: z
+        .array(z.string())
+        .describe("Archive dates intentionally skipped because they produced no durable memory"),
     count: z
         .number()
         .describe("Number of archive entries distilled (from relic_archive_pending returned count)"),
@@ -186,10 +273,6 @@ server.tool("relic_memory_write", "Write distilled memory to an Engram's memory
         .string()
         .optional()
         .describe("User profile updates to write to USER.md (preferences, tendencies, work style — about the human, not the project)"),
-    date: z
-        .string()
-        .optional()
-        .describe("Date for memory file (YYYY-MM-DD, default: today)"),
     path: z
         .string()
         .optional()
@@ -197,36 +280,21 @@ server.tool("relic_memory_write", "Write distilled memory to an Engram's memory
 }, async (args) => {
     const engramsPath = await resolveEngramsPath(args.path);
     try {
-        // Step 1: Write daily memory
         const memoryWrite = new MemoryWrite(engramsPath);
-        const writeResult = await memoryWrite.execute(args.id, args.content, args.date);
-        // Step 2: Append to MEMORY.md if long_term is provided
-        let longTermWritten = false;
-        if (args.long_term) {
-            const memoryMdPath = join(engramsPath, args.id, "MEMORY.md");
-            if (existsSync(memoryMdPath)) {
-                const existing = await readFile(memoryMdPath, "utf-8");
-                const separator = existing.endsWith("\n") ? "\n" : "\n\n";
-                await writeFile(memoryMdPath, existing + separator + args.long_term + "\n", "utf-8");
-            }
-            else {
-                await writeFile(memoryMdPath, args.long_term + "\n", "utf-8");
-            }
-            longTermWritten = true;
-        }
-        // Step 2.5: Write USER.md if user_profile is provided
-        let userProfileWritten = false;
-        if (args.user_profile) {
-            const userMdPath = join(engramsPath, args.id, "USER.md");
-            await writeFile(userMdPath, args.user_profile + "\n", "utf-8");
-            userProfileWritten = true;
-        }
-        // Step 3: Advance cursor by the number of distilled entries
+        assertDateCoverage(args.writes, args.expected_dates, args.skipped_dates);
+        const writeResults = await memoryWrite.executeBatch(args.id, args.writes);
+        const writeSummary = writeResults.length > 0
+            ? writeResults
+                .map((result) => `${result.date} (${result.appended ? "appended" : "created"})`)
+                .join(", ")
+            : "no files";
+        const { longTermWritten, userProfileWritten } = await appendLongTermAndUserProfile(engramsPath, args.id, args.long_term, args.user_profile);
         const cursorUpdate = new ArchiveCursorUpdate(engramsPath);
         const cursorResult = await cursorUpdate.execute(args.id, args.count);
-        const parts = [
-            `Memory written to ${writeResult.date} (${writeResult.appended ? "appended" : "created"}).`,
-        ];
+        const parts = [`Memory written to ${writeSummary}.`];
+        if (args.skipped_dates.length > 0) {
+            parts.push(`Skipped dates: ${args.skipped_dates.join(", ")}.`);
+        }
         if (longTermWritten) {
             parts.push("Long-term memory (MEMORY.md) updated.");
         }
@@ -244,7 +312,10 @@ server.tool("relic_memory_write", "Write distilled memory to an Engram's memory
         };
     }
     catch (err) {
-        if (err instanceof MemoryWriteEngramNotFoundError) {
+        if (err instanceof MemoryWriteEngramNotFoundError ||
+            err instanceof ArchiveCursorAdvanceOverflowError ||
+            err instanceof ArchiveCursorCorruptedError ||
+            err instanceof Error) {
             return {
                 content: [{ type: "text", text: err.message }],
                 isError: true,

package/dist/shared/config.d.ts

@@ -5,21 +5,27 @@ declare const CONFIG_PATH: string;
 export declare const RelicConfigSchema: z.ZodObject<{
     /** Engramデータの格納ディレクトリ */
     engramsPath: z.ZodDefault<z.ZodString>;
-    /** Mikoshi APIのベースURL（将来用） */
-    mikoshiUrl: z.ZodOptional<z.ZodString>;
+    /** Mikoshi APIのベースURL */
+    mikoshiUrl: z.ZodDefault<z.ZodString>;
+    /** Mikoshi APIキー */
+    mikoshiApiKey: z.ZodOptional<z.ZodString>;
+    /** Mikoshi memory 暗号化パスフレーズ */
+    mikoshiPassphrase: z.ZodOptional<z.ZodString>;
     /** --engram 未指定時に召喚するデフォルトEngram ID */
     defaultEngram: z.ZodOptional<z.ZodString>;
     /** claw inject/extract/sync で使うClawディレクトリ (default: ~/.openclaw) */
     clawPath: z.ZodOptional<z.ZodString>;
     /** システムプロンプトに含める直近メモリエントリ数 (default: 2) */
     memoryWindowSize: z.ZodDefault<z.ZodNumber>;
-    /** 一度の記憶蒸留で扱う archive エントリ数 (default: 30) */
+    /** 一度の記憶蒸留で扱う archive エントリ数 (default: 100) */
     distillationBatchSize: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     memoryWindowSize: number;
     distillationBatchSize: number;
     engramsPath: string;
-    mikoshiUrl?: string | undefined;
+    mikoshiUrl: string;
+    mikoshiApiKey?: string | undefined;
+    mikoshiPassphrase?: string | undefined;
     defaultEngram?: string | undefined;
     clawPath?: string | undefined;
 }, {
@@ -27,6 +33,8 @@ export declare const RelicConfigSchema: z.ZodObject<{
     distillationBatchSize?: number | undefined;
     engramsPath?: string | undefined;
     mikoshiUrl?: string | undefined;
+    mikoshiApiKey?: string | undefined;
+    mikoshiPassphrase?: string | undefined;
     defaultEngram?: string | undefined;
     clawPath?: string | undefined;
 }>;
@@ -72,7 +80,19 @@ export declare function resolveClawPath(cliOverride?: string): Promise<string |
 export declare function resolveMemoryWindowSize(): Promise<number>;
 /**
  * 記憶蒸留のバッチ件数を解決する。
- * 優先順位: config.distillationBatchSize > 30 (デフォルト)
+ * 優先順位: config.distillationBatchSize > 100 (デフォルト)
  */
 export declare function resolveDistillationBatchSize(): Promise<number>;
+/**
+ * Mikoshi URLを解決する。
+ */
+export declare function resolveMikoshiUrl(): Promise<string>;
+/**
+ * Mikoshi APIキーを解決する。未設定時はundefined。
+ */
+export declare function resolveMikoshiApiKey(): Promise<string | undefined>;
+/**
+ * Mikoshi パスフレーズを解決する。未設定時はundefined。
+ */
+export declare function resolveMikoshiPassphrase(): Promise<string | undefined>;
 export { CONFIG_PATH, RELIC_DIR, TEMPLATES_DIR };

package/dist/shared/config.js

@@ -12,16 +12,20 @@ const CONFIG_PATH = join(RELIC_DIR, "config.json");
 export const RelicConfigSchema = z.object({
     /** Engramデータの格納ディレクトリ */
     engramsPath: z.string().default(join(homedir(), ".relic", "engrams")),
-    /** Mikoshi APIのベースURL（将来用） */
-    mikoshiUrl: z.string().optional(),
+    /** Mikoshi APIのベースURL */
+    mikoshiUrl: z.string().default("https://mikoshi.ectplsm.com"),
+    /** Mikoshi APIキー */
+    mikoshiApiKey: z.string().optional(),
+    /** Mikoshi memory 暗号化パスフレーズ */
+    mikoshiPassphrase: z.string().optional(),
     /** --engram 未指定時に召喚するデフォルトEngram ID */
     defaultEngram: z.string().optional(),
     /** claw inject/extract/sync で使うClawディレクトリ (default: ~/.openclaw) */
     clawPath: z.string().optional(),
     /** システムプロンプトに含める直近メモリエントリ数 (default: 2) */
     memoryWindowSize: z.number().int().min(1).default(2),
-    /** 一度の記憶蒸留で扱う archive エントリ数 (default: 30) */
-    distillationBatchSize: z.number().int().min(1).default(30),
+    /** 一度の記憶蒸留で扱う archive エントリ数 (default: 100) */
+    distillationBatchSize: z.number().int().min(1).default(100),
 });
 /**
  * 設定ファイルを読み込む。存在しなければデフォルト値を返す。
@@ -159,11 +163,35 @@ export async function resolveMemoryWindowSize() {
 }
 /**
  * 記憶蒸留のバッチ件数を解決する。
- * 優先順位: config.distillationBatchSize > 30 (デフォルト)
+ * 優先順位: config.distillationBatchSize > 100 (デフォルト)
  */
 export async function resolveDistillationBatchSize() {
     await ensureInitialized();
     const config = await loadConfig();
     return config.distillationBatchSize;
 }
+/**
+ * Mikoshi URLを解決する。
+ */
+export async function resolveMikoshiUrl() {
+    await ensureInitialized();
+    const config = await loadConfig();
+    return config.mikoshiUrl;
+}
+/**
+ * Mikoshi APIキーを解決する。未設定時はundefined。
+ */
+export async function resolveMikoshiApiKey() {
+    await ensureInitialized();
+    const config = await loadConfig();
+    return config.mikoshiApiKey;
+}
+/**
+ * Mikoshi パスフレーズを解決する。未設定時はundefined。
+ */
+export async function resolveMikoshiPassphrase() {
+    await ensureInitialized();
+    const config = await loadConfig();
+    return config.mikoshiPassphrase;
+}
 export { CONFIG_PATH, RELIC_DIR, TEMPLATES_DIR };

package/dist/shared/engram-composer.d.ts

@@ -9,7 +9,7 @@ export interface ComposeOptions {
     currentDate?: string;
     /** システムプロンプトに含める直近メモリエントリ数（デフォルト: 2） */
     memoryWindowSize?: number;
-    /** 一度の記憶蒸留で扱う archive エントリ数（デフォルト: 30） */
+    /** 一度の記憶蒸留で扱う archive エントリ数（デフォルト: 100） */
     distillationBatchSize?: number;
 }
 /**

package/dist/shared/engram-composer.js

@@ -46,7 +46,7 @@ export function composeEngram(files, options) {
  */
 function composeRelicSection(meta, distillationBatchSize, currentDate) {
     const today = currentDate ?? new Date().toISOString().split("T")[0];
-    const batchSize = distillationBatchSize ?? 30;
+    const batchSize = distillationBatchSize ?? 100;
     return `# Relic System
 
 - engramId: ${meta.id}
@@ -68,16 +68,20 @@ To recall past context, use \`relic_archive_search\` to search your archive by k
 
 When the user asks you to organize or distill memories:
 1. Call \`relic_archive_pending\` **once** to get un-distilled session entries (up to ${batchSize})
-2. Review and distill them into:
-   - **content**: key facts, decisions, and insights for \`memory/YYYY-MM-DD.md\`
+2. Review the archive entry dates and group the distilled memory by the **actual archive entry date**, not the distillation date
+3. Distill them into:
+   - **writes**: one item per date, each with \`date\` and \`content\`, for \`memory/YYYY-MM-DD.md\`
+   - **expected_dates**: every archive date present in the pending batch
+   - **skipped_dates**: dates that had pending entries but produced no durable memory worth saving
    - **long_term** (optional): only the most important, enduring facts for \`MEMORY.md\` (e.g. project architecture decisions, key constraints, hard rules)
    - **user_profile** (optional): full updated user profile for \`USER.md\` (preferences, tendencies, work style — about the human, not the project)
-3. Call \`relic_memory_write\` with \`content\`, \`count\`, and optionally \`long_term\` and/or \`user_profile\`
-4. If \`remaining > 0\`, inform the user how many entries are still pending — do NOT fetch more automatically
+4. Call \`relic_memory_write\` with \`writes\`, \`expected_dates\`, \`skipped_dates\`, \`count\`, and optionally \`long_term\` and/or \`user_profile\`
+5. If \`remaining > 0\`, inform the user how many entries are still pending — do NOT fetch more automatically
 
 **Important:**
 - Write distilled memories in the **same language the user is using** in the current conversation
 - Do NOT loop or repeat the distillation process — one round per user request
+- Every archive date in the pending batch must appear in exactly one of \`writes.date\` or \`skipped_dates\`
 - \`long_term\` should be highly selective — only facts that matter across all future sessions (objective facts and rules)
 - \`user_profile\` is a complete replacement, not an append — write the full profile each time you update it (user tendencies, preferences, work style)
 - Distilled memories are loaded into your prompt on future sessions`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ectplsm/relic",
-  "version": "0.3.2",
+  "version": "0.5.0",
   "description": "PROJECT RELIC — Engram injection system for AI constructs",
   "license": "MIT",
   "repository": {