@ectplsm/relic 0.2.2 → 0.3.1

package/dist/adapters/local/local-engram-repository.js

@@ -1,4 +1,4 @@
-import { readdir, readFile, writeFile, mkdir, rm } from "node:fs/promises";
+import { readdir, readFile, writeFile, mkdir, rm, copyFile } from "node:fs/promises";
 import { join } from "node:path";
 import { existsSync } from "node:fs";
 import { EngramManifestSchema, EngramMetaSchema, EngramProfileSchema, } from "../../core/entities/engram.js";
@@ -91,6 +91,23 @@ export class LocalEngramRepository {
             await rm(engramDir, { recursive: true });
         }
     }
+    async copyArchiveFiles(fromId, toId) {
+        const ARCHIVE_FILES = ["archive.md", "archive.cursor"];
+        const fromDir = join(this.basePath, fromId);
+        const toDir = join(this.basePath, toId);
+        if (!existsSync(fromDir) || !existsSync(toDir)) {
+            return false;
+        }
+        let copied = false;
+        for (const filename of ARCHIVE_FILES) {
+            const src = join(fromDir, filename);
+            if (existsSync(src)) {
+                await copyFile(src, join(toDir, filename));
+                copied = true;
+            }
+        }
+        return copied;
+    }
     // --- private ---
     async readMeta(engramDir, options) {
         const profilePath = join(engramDir, PROFILE_FILE);

package/dist/core/entities/engram.d.ts

@@ -40,7 +40,7 @@ export type EngramFiles = z.infer<typeof EngramFileSchema>;
  * Engramプロフィール — ユーザーが編集可能な表示用メタデータ
  */
 export declare const EngramProfileSchema: z.ZodObject<{
-    /** 表示名 (例: "攻殻機動隊の少佐") */
+    /** 表示名 (例: "Commander") */
     name: z.ZodString;
     /** 説明 */
     description: z.ZodOptional<z.ZodString>;
@@ -60,7 +60,7 @@ export type EngramProfile = z.infer<typeof EngramProfileSchema>;
  * Engramマニフェスト — システム管理の不変識別子と監査情報
  */
 export declare const EngramManifestSchema: z.ZodObject<{
-    /** 一意識別子 (例: "ghost-in-the-shell") */
+    /** 一意識別子 (例: "commander") */
     id: z.ZodString;
     /** 作成日時 */
     createdAt: z.ZodString;
@@ -80,14 +80,14 @@ export type EngramManifest = z.infer<typeof EngramManifestSchema>;
  * Engramメタデータ — プロフィールとマニフェストを結合した利用時ビュー
  */
 export declare const EngramMetaSchema: z.ZodObject<{
-    /** 表示名 (例: "攻殻機動隊の少佐") */
+    /** 表示名 (例: "Commander") */
     name: z.ZodString;
     /** 説明 */
     description: z.ZodOptional<z.ZodString>;
     /** タグ */
     tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 } & {
-    /** 一意識別子 (例: "ghost-in-the-shell") */
+    /** 一意識別子 (例: "commander") */
     id: z.ZodString;
     /** 作成日時 */
     createdAt: z.ZodString;
@@ -115,14 +115,14 @@ export type EngramMeta = z.infer<typeof EngramMetaSchema>;
  */
 export declare const EngramSchema: z.ZodObject<{
     meta: z.ZodObject<{
-        /** 表示名 (例: "攻殻機動隊の少佐") */
+        /** 表示名 (例: "Commander") */
         name: z.ZodString;
         /** 説明 */
         description: z.ZodOptional<z.ZodString>;
         /** タグ */
         tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     } & {
-        /** 一意識別子 (例: "ghost-in-the-shell") */
+        /** 一意識別子 (例: "commander") */
         id: z.ZodString;
         /** 作成日時 */
         createdAt: z.ZodString;

package/dist/core/entities/engram.js

@@ -26,7 +26,7 @@ export const EngramFileSchema = z.object({
  * Engramプロフィール — ユーザーが編集可能な表示用メタデータ
  */
 export const EngramProfileSchema = z.object({
-    /** 表示名 (例: "攻殻機動隊の少佐") */
+    /** 表示名 (例: "Commander") */
     name: z.string(),
     /** 説明 */
     description: z.string().optional(),
@@ -37,7 +37,7 @@ export const EngramProfileSchema = z.object({
  * Engramマニフェスト — システム管理の不変識別子と監査情報
  */
 export const EngramManifestSchema = z.object({
-    /** 一意識別子 (例: "ghost-in-the-shell") */
+    /** 一意識別子 (例: "commander") */
     id: z.string(),
     /** 作成日時 */
     createdAt: z.string().datetime(),

package/dist/core/ports/engram-repository.d.ts

@@ -14,4 +14,6 @@ export interface EngramRepository {
     save(engram: Engram): Promise<void>;
     /** Engramを削除 */
     delete(id: string): Promise<void>;
+    /** アーカイブファイル (archive.md, archive.cursor) を別Engramへコピー */
+    copyArchiveFiles(fromId: string, toId: string): Promise<boolean>;
 }

package/dist/core/usecases/create-engram.d.ts

@@ -0,0 +1,26 @@
+import type { Engram } from "../entities/engram.js";
+import type { EngramRepository } from "../ports/engram-repository.js";
+export declare class EngramAlreadyExistsError extends Error {
+    constructor(id: string);
+}
+export declare class InvalidEngramIdError extends Error {
+    constructor(id: string);
+}
+export interface CreateEngramParams {
+    id: string;
+    name: string;
+    description?: string;
+    tags?: string[];
+    soul: string;
+    identity: string;
+}
+export interface CreateEngramResult {
+    engram: Engram;
+}
+/** ID format: lowercase alphanumeric + hyphens, no leading/trailing hyphen */
+export declare const ENGRAM_ID_PATTERN: RegExp;
+export declare class CreateEngram {
+    private readonly repository;
+    constructor(repository: EngramRepository);
+    execute(params: CreateEngramParams): Promise<CreateEngramResult>;
+}

package/dist/core/usecases/create-engram.js

@@ -0,0 +1,54 @@
+// ============================================================
+// Errors
+// ============================================================
+export class EngramAlreadyExistsError extends Error {
+    constructor(id) {
+        super(`Engram "${id}" already exists. Delete it first or choose a different ID.`);
+        this.name = "EngramAlreadyExistsError";
+    }
+}
+export class InvalidEngramIdError extends Error {
+    constructor(id) {
+        super(`Invalid Engram ID "${id}". Use lowercase letters, numbers, and hyphens only (e.g. "my-agent").`);
+        this.name = "InvalidEngramIdError";
+    }
+}
+// ============================================================
+// Usecase
+// ============================================================
+/** ID format: lowercase alphanumeric + hyphens, no leading/trailing hyphen */
+export const ENGRAM_ID_PATTERN = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+export class CreateEngram {
+    repository;
+    constructor(repository) {
+        this.repository = repository;
+    }
+    async execute(params) {
+        // Validate ID format
+        if (!ENGRAM_ID_PATTERN.test(params.id)) {
+            throw new InvalidEngramIdError(params.id);
+        }
+        // Check for duplicates
+        const existing = await this.repository.get(params.id);
+        if (existing) {
+            throw new EngramAlreadyExistsError(params.id);
+        }
+        const now = new Date().toISOString();
+        const engram = {
+            meta: {
+                id: params.id,
+                name: params.name,
+                description: params.description,
+                tags: params.tags,
+                createdAt: now,
+                updatedAt: now,
+            },
+            files: {
+                soul: params.soul,
+                identity: params.identity,
+            },
+        };
+        await this.repository.save(engram);
+        return { engram };
+    }
+}

package/dist/core/usecases/delete-engram.d.ts

@@ -0,0 +1,24 @@
+import type { Engram } from "../entities/engram.js";
+import type { EngramRepository } from "../ports/engram-repository.js";
+export declare class DeleteEngramNotFoundError extends Error {
+    constructor(id: string);
+}
+export interface DeleteEngramInfo {
+    engram: Engram;
+    hasMemory: boolean;
+    hasUser: boolean;
+    hasArchive: boolean;
+    memoryEntryCount: number;
+}
+export declare class DeleteEngram {
+    private readonly repository;
+    constructor(repository: EngramRepository);
+    /**
+     * Inspect an Engram before deletion — returns info for confirmation UI.
+     */
+    inspect(id: string): Promise<DeleteEngramInfo>;
+    /**
+     * Actually delete the Engram. Call inspect() first for confirmation.
+     */
+    execute(id: string): Promise<void>;
+}

package/dist/core/usecases/delete-engram.js

@@ -0,0 +1,46 @@
+// ============================================================
+// Errors
+// ============================================================
+export class DeleteEngramNotFoundError extends Error {
+    constructor(id) {
+        super(`Engram "${id}" not found.`);
+        this.name = "DeleteEngramNotFoundError";
+    }
+}
+// ============================================================
+// Usecase
+// ============================================================
+export class DeleteEngram {
+    repository;
+    constructor(repository) {
+        this.repository = repository;
+    }
+    /**
+     * Inspect an Engram before deletion — returns info for confirmation UI.
+     */
+    async inspect(id) {
+        const engram = await this.repository.get(id);
+        if (!engram) {
+            throw new DeleteEngramNotFoundError(id);
+        }
+        return {
+            engram,
+            hasMemory: !!engram.files.memory,
+            hasUser: !!engram.files.user,
+            hasArchive: false, // archive.md is not loaded via EngramFiles; CLI checks separately
+            memoryEntryCount: engram.files.memoryEntries
+                ? Object.keys(engram.files.memoryEntries).length
+                : 0,
+        };
+    }
+    /**
+     * Actually delete the Engram. Call inspect() first for confirmation.
+     */
+    async execute(id) {
+        const existing = await this.repository.get(id);
+        if (!existing) {
+            throw new DeleteEngramNotFoundError(id);
+        }
+        await this.repository.delete(id);
+    }
+}

package/dist/core/usecases/refresh-samples.d.ts

@@ -1,21 +1,36 @@
 import type { EngramRepository } from "../ports/engram-repository.js";
 export interface RefreshSamplesResult {
     refreshed: string[];
+    seeded: string[];
     skipped: Array<{
         id: string;
         reason: string;
     }>;
+    migratedMemory: Array<{
+        from: string;
+        to: string;
+    }>;
 }
 /**
  * RefreshSamples — サンプルEngramの人格ファイルを最新テンプレートで上書きする
  *
  * memory / USER / archive などの運用データは保持し、
  * SOUL.md / IDENTITY.md と updatedAt のみを更新する。
+ *
+ * ローカルに存在しないテンプレートは新規 seed する。
+ * seed 時、旧サンプルの記憶データがあれば対応する新サンプルにコピーする。
  */
 export declare class RefreshSamples {
     private readonly repository;
     private readonly templatesDir;
     constructor(repository: EngramRepository, templatesDir: string);
     execute(targetIds?: string[]): Promise<RefreshSamplesResult>;
+    private seedFromTemplate;
+    /**
+     * 旧サンプルEngramから記憶データをコピーする。
+     * LEGACY_MAPPING に定義されたマッピングに基づき、
+     * USER.md / MEMORY.md / memory/*.md を引き継ぐ。
+     */
+    private migrateMemoryFromLegacy;
     private listTemplateIds;
 }

package/dist/core/usecases/refresh-samples.js

@@ -1,11 +1,22 @@
 import { existsSync } from "node:fs";
 import { readFile, readdir } from "node:fs/promises";
 import { join } from "node:path";
+/**
+ * Legacy sample Engram ID → new sample Engram ID mapping.
+ * Used during seed to copy memory data from old samples.
+ */
+const LEGACY_MAPPING = {
+    johnny: "rebel",
+    motoko: "commander",
+};
 /**
  * RefreshSamples — サンプルEngramの人格ファイルを最新テンプレートで上書きする
  *
  * memory / USER / archive などの運用データは保持し、
  * SOUL.md / IDENTITY.md と updatedAt のみを更新する。
+ *
+ * ローカルに存在しないテンプレートは新規 seed する。
+ * seed 時、旧サンプルの記憶データがあれば対応する新サンプルにコピーする。
  */
 export class RefreshSamples {
     repository;
@@ -20,7 +31,9 @@ export class RefreshSamples {
             : await this.listTemplateIds();
         const result = {
             refreshed: [],
+            seeded: [],
             skipped: [],
+            migratedMemory: [],
         };
         for (const id of ids) {
             const templateDir = join(this.templatesDir, id);
@@ -28,25 +41,103 @@ export class RefreshSamples {
                 result.skipped.push({ id, reason: "sample template not found" });
                 continue;
             }
-            const engram = await this.repository.get(id);
-            if (!engram) {
-                result.skipped.push({ id, reason: "local Engram not found" });
-                continue;
-            }
             const soulPath = join(templateDir, "SOUL.md");
             const identityPath = join(templateDir, "IDENTITY.md");
             if (!existsSync(soulPath) || !existsSync(identityPath)) {
                 result.skipped.push({ id, reason: "template persona files are incomplete" });
                 continue;
             }
-            engram.files.soul = await readFile(soulPath, "utf-8");
-            engram.files.identity = await readFile(identityPath, "utf-8");
-            engram.meta.updatedAt = new Date().toISOString();
-            await this.repository.save(engram);
-            result.refreshed.push(id);
+            const engram = await this.repository.get(id);
+            if (engram) {
+                // Existing engram — refresh persona files only
+                engram.files.soul = await readFile(soulPath, "utf-8");
+                engram.files.identity = await readFile(identityPath, "utf-8");
+                engram.meta.updatedAt = new Date().toISOString();
+                await this.repository.save(engram);
+                result.refreshed.push(id);
+            }
+            else {
+                // New sample — seed it
+                const seeded = await this.seedFromTemplate(id, templateDir, soulPath, identityPath);
+                if (seeded) {
+                    result.seeded.push(id);
+                    // Migrate memory from legacy sample if available
+                    const migrated = await this.migrateMemoryFromLegacy(id);
+                    if (migrated) {
+                        result.migratedMemory.push(migrated);
+                    }
+                }
+                else {
+                    result.skipped.push({ id, reason: "template engram.json not found (cannot seed)" });
+                }
+            }
         }
         return result;
     }
+    async seedFromTemplate(id, templateDir, soulPath, identityPath) {
+        const engramJsonPath = join(templateDir, "engram.json");
+        if (!existsSync(engramJsonPath)) {
+            return false;
+        }
+        const profile = JSON.parse(await readFile(engramJsonPath, "utf-8"));
+        const soul = await readFile(soulPath, "utf-8");
+        const identity = await readFile(identityPath, "utf-8");
+        const now = new Date().toISOString();
+        const engram = {
+            meta: {
+                id,
+                name: profile.name ?? id,
+                description: profile.description,
+                tags: profile.tags,
+                createdAt: now,
+                updatedAt: now,
+            },
+            files: {
+                soul,
+                identity,
+            },
+        };
+        await this.repository.save(engram);
+        return true;
+    }
+    /**
+     * 旧サンプルEngramから記憶データをコピーする。
+     * LEGACY_MAPPING に定義されたマッピングに基づき、
+     * USER.md / MEMORY.md / memory/*.md を引き継ぐ。
+     */
+    async migrateMemoryFromLegacy(newId) {
+        // Find legacy ID that maps to this new ID
+        const legacyId = Object.entries(LEGACY_MAPPING)
+            .find(([, v]) => v === newId)?.[0];
+        if (!legacyId)
+            return null;
+        const legacy = await this.repository.get(legacyId);
+        if (!legacy)
+            return null;
+        // Check if legacy has any memory data worth copying
+        const hasMemory = legacy.files.user
+            || legacy.files.memory
+            || (legacy.files.memoryEntries && Object.keys(legacy.files.memoryEntries).length > 0);
+        if (!hasMemory)
+            return null;
+        // Load the newly seeded engram and merge memory data
+        const newEngram = await this.repository.get(newId);
+        if (!newEngram)
+            return null;
+        if (legacy.files.user)
+            newEngram.files.user = legacy.files.user;
+        if (legacy.files.memory)
+            newEngram.files.memory = legacy.files.memory;
+        if (legacy.files.memoryEntries) {
+            newEngram.files.memoryEntries = { ...legacy.files.memoryEntries };
+        }
+        newEngram.meta.updatedAt = new Date().toISOString();
+        await this.repository.save(newEngram);
+        // Archive files (archive.md, archive.cursor) are outside the Engram entity
+        // but still need to be carried over during legacy migration.
+        await this.repository.copyArchiveFiles(legacyId, newId);
+        return { from: legacyId, to: newId };
+    }
     async listTemplateIds() {
         if (!existsSync(this.templatesDir)) {
             return [];

package/dist/core/usecases/summon.d.ts

@@ -21,6 +21,7 @@ export declare class Summon {
     constructor(repository: EngramRepository);
     execute(engramId: string, options?: {
         memoryWindowSize?: number;
+        distillationBatchSize?: number;
     }): Promise<SummonResult>;
 }
 export declare class EngramNotFoundError extends Error {

package/dist/core/usecases/summon.js

@@ -21,6 +21,7 @@ export class Summon {
         const prompt = composeEngram(engram.files, {
             meta: engram.meta,
             memoryWindowSize: options?.memoryWindowSize,
+            distillationBatchSize: options?.distillationBatchSize,
         });
         return {
             engramId: engram.meta.id,

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

@@ -0,0 +1 @@
+export declare function printRelicBanner(): void;

package/dist/interfaces/cli/banner.js

@@ -0,0 +1,13 @@
+export function printRelicBanner() {
+    const lines = [
+        "    ____  ________    ____________",
+        "   / __ \\/ ____/ /   /  _/ ____/",
+        "  / /_/ / __/ / /    / // /",
+        " / _, _/ /___/ /____/ // /___",
+        "/_/ |_/_____/_____/___/\\____/",
+    ];
+    for (const line of lines) {
+        console.log(line);
+    }
+    console.log();
+}

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

@@ -80,4 +80,24 @@ export function registerConfigCommand(program) {
         await saveConfig(cfg);
         console.log(`Memory window set to: ${parsed}`);
     });
+    // relic config distillation-batch-size [n]
+    config
+        .command("distillation-batch-size [n]")
+        .description("Get or set the number of archive entries to distill at once (default: 30)")
+        .action(async (n) => {
+        await ensureInitialized();
+        const cfg = await loadConfig();
+        if (n === undefined) {
+            console.log(String(cfg.distillationBatchSize));
+            return;
+        }
+        const parsed = parseInt(n, 10);
+        if (isNaN(parsed) || parsed < 1) {
+            console.error("Error: distillation-batch-size must be a positive integer");
+            process.exit(1);
+        }
+        cfg.distillationBatchSize = parsed;
+        await saveConfig(cfg);
+        console.log(`Distillation batch size set to: ${parsed}`);
+    });
 }

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

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

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

@@ -0,0 +1,143 @@
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { loadConfig, ensureInitialized } from "../../../shared/config.js";
+import { LocalEngramRepository } from "../../../adapters/local/index.js";
+import { DEFAULT_SOUL, DEFAULT_IDENTITY } from "../../../shared/templates.js";
+import { CreateEngram, EngramAlreadyExistsError, InvalidEngramIdError, ENGRAM_ID_PATTERN, } from "../../../core/usecases/create-engram.js";
+// ============================================================
+// Interactive prompt helpers
+// ============================================================
+async function ask(rl, question) {
+    const answer = await rl.question(question);
+    return answer.trim();
+}
+async function askRequired(rl, question, errorMsg) {
+    while (true) {
+        const answer = await ask(rl, question);
+        if (answer)
+            return answer;
+        console.log(errorMsg);
+    }
+}
+/**
+ * Ask for a valid, non-duplicate Engram ID. Retries on bad format or collision.
+ */
+async function askValidId(rl, repo) {
+    while (true) {
+        const id = await askRequired(rl, "Engram ID (e.g. my-agent): ", "  ID is required. Use lowercase letters, numbers, and hyphens.");
+        if (!ENGRAM_ID_PATTERN.test(id)) {
+            console.log("  Invalid ID. Use lowercase letters, numbers, and hyphens (e.g. my-agent).");
+            continue;
+        }
+        const existing = await repo.get(id);
+        if (existing) {
+            console.log(`  Engram "${id}" already exists. Choose a different ID.`);
+            continue;
+        }
+        return id;
+    }
+}
+// ============================================================
+// Command
+// ============================================================
+export function registerCreateCommand(program) {
+    program
+        .command("create")
+        .description("Create a new Engram interactively")
+        .option("-i, --id <id>", "Engram ID (lowercase alphanumeric + hyphens)")
+        .option("-n, --name <name>", "Display name")
+        .option("-d, --description <desc>", "Description")
+        .option("-t, --tags <tags>", "Comma-separated tags")
+        .action(async (opts) => {
+        await ensureInitialized();
+        const config = await loadConfig();
+        const repo = new LocalEngramRepository(config.engramsPath);
+        const usecase = new CreateEngram(repo);
+        const isTTY = input.isTTY && output.isTTY;
+        // If non-interactive, require at least id and name
+        if (!isTTY) {
+            if (!opts.id || !opts.name) {
+                console.error("Error: --id and --name are required in non-interactive mode.");
+                process.exitCode = 1;
+                return;
+            }
+        }
+        let id = opts.id;
+        let name = opts.name;
+        let description = opts.description;
+        let tags;
+        if (opts.tags) {
+            tags = opts.tags.split(",").map((t) => t.trim()).filter(Boolean);
+        }
+        // Early validation for pre-supplied ID (before interactive flow)
+        if (id) {
+            if (!ENGRAM_ID_PATTERN.test(id)) {
+                console.error(`Error: Invalid Engram ID "${id}". Use lowercase letters, numbers, and hyphens only (e.g. "my-agent").`);
+                process.exitCode = 1;
+                return;
+            }
+            const existing = await repo.get(id);
+            if (existing) {
+                console.error(`Error: Engram "${id}" already exists. Delete it first or choose a different ID.`);
+                process.exitCode = 1;
+                return;
+            }
+        }
+        // Interactive flow for missing fields
+        if (isTTY && (!id || !name)) {
+            const rl = createInterface({ input, output });
+            try {
+                if (!id) {
+                    id = await askValidId(rl, repo);
+                }
+                if (!name) {
+                    name = await askRequired(rl, "Name: ", "  Name is required.");
+                }
+                if (description === undefined) {
+                    description = await ask(rl, "Description (optional): ") || undefined;
+                }
+                if (tags === undefined) {
+                    const tagsInput = await ask(rl, "Tags (comma-separated, optional): ");
+                    if (tagsInput) {
+                        tags = tagsInput.split(",").map((t) => t.trim()).filter(Boolean);
+                    }
+                }
+            }
+            finally {
+                rl.close();
+            }
+        }
+        // Execute
+        try {
+            const result = await usecase.execute({
+                id: id,
+                name: name,
+                description,
+                tags,
+                soul: DEFAULT_SOUL,
+                identity: DEFAULT_IDENTITY,
+            });
+            const green = (s) => `\x1b[32m${s}\x1b[0m`;
+            const engramDir = `${config.engramsPath}/${result.engram.meta.id}`;
+            console.log();
+            console.log(green(`Created Engram "${result.engram.meta.name}" (${result.engram.meta.id})`));
+            console.log(`  → ${engramDir}/`);
+            console.log();
+            console.log("Files:");
+            console.log("  engram.json    — metadata (name, description, tags)");
+            console.log("  manifest.json  — system metadata (id, timestamps)");
+            console.log("  SOUL.md        — core principles and behavior");
+            console.log("  IDENTITY.md    — persona identity (fill in during first conversation)");
+            console.log();
+            console.log(`Customize SOUL.md and IDENTITY.md, then run: relic claude ${result.engram.meta.id}`);
+        }
+        catch (err) {
+            if (err instanceof InvalidEngramIdError || err instanceof EngramAlreadyExistsError) {
+                console.error(`Error: ${err.message}`);
+                process.exitCode = 1;
+                return;
+            }
+            throw err;
+        }
+    });
+}

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

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