@ectplsm/relic 0.1.4 → 0.2.1

package/dist/core/usecases/extract.js

@@ -1,147 +1,111 @@
 import { join } from "node:path";
 import { existsSync } from "node:fs";
 import { readFile, readdir } from "node:fs/promises";
-import { FILE_MAP, MEMORY_DIR, resolveAgentPath } from "../../shared/openclaw.js";
+import { RELIC_FILE_MAP, MEMORY_DIR, resolveWorkspacePath } from "../../shared/openclaw.js";
 /**
- * Extract — OpenClawワークスペースからEngramを作成する
+ * Extract — OpenClawワークスペースからEngramを新規作成する
  *
- * agent名 = Engram ID の規約に基づき、agents/<engramId>/agent/ から読み取る。
- *
- * 既存Engramがある場合:
- *   - --force なし → memoryエントリのみマージ（persona部分は変更しない）
- *   - --force あり → persona部分を上書き + memoryをマージ
- * 既存Engramがない場合:
- *   - 新規作成（全ファイル含む）
+ * 初回取り込み専用。Engramが既に存在する場合はエラーを返す。
+ * Relicが真のデータソースであり、extractは初期インポートのみを担う。
  */
 export class Extract {
     repository;
     constructor(repository) {
         this.repository = repository;
     }
-    async execute(engramId, options) {
-        const sourcePath = resolveAgentPath(engramId, options?.openclawDir);
+    async inspectPersona(agentName, options) {
+        const sourcePath = resolveWorkspacePath(agentName, options?.openclawDir);
         if (!existsSync(sourcePath)) {
             throw new WorkspaceNotFoundError(sourcePath);
         }
-        const { files, filesRead } = await this.readFiles(sourcePath);
-        if (filesRead.length === 0) {
-            throw new WorkspaceEmptyError(sourcePath);
-        }
-        const existing = await this.repository.get(engramId);
-        if (existing) {
-            if (options?.force) {
-                // --force: persona上書き + memoryマージ
-                const merged = await this.mergeAndSave(existing, files, options.name ?? existing.meta.name);
-                return {
-                    engramId,
-                    engramName: options.name ?? existing.meta.name,
-                    sourcePath,
-                    filesRead,
-                    memoryMerged: merged,
-                };
-            }
-            // --forceなし: memoryのみマージ
-            if (!files.memoryEntries || Object.keys(files.memoryEntries).length === 0) {
-                throw new EngramAlreadyExistsError(engramId);
-            }
-            const merged = await this.mergeMemoryOnly(engramId, files.memoryEntries);
+        const { files } = await this.readFiles(sourcePath);
+        const existing = await this.repository.get(agentName);
+        if (!existing) {
             return {
-                engramId,
-                engramName: existing.meta.name,
+                engramId: agentName,
+                engramName: options?.name ?? agentName,
                 sourcePath,
-                filesRead,
-                memoryMerged: merged,
+                existing: false,
+                name: "missing",
+                soul: "missing",
+                identity: "missing",
+                overwriteRequired: false,
             };
         }
-        // 新規作成 — nameは必須
-        const engramName = options?.name;
-        if (!engramName) {
-            throw new ExtractNameRequiredError(engramId);
+        const requestedName = options?.name ?? existing.meta.name;
+        const name = requestedName === existing.meta.name ? "same" : "different";
+        const soul = this.comparePersonaFile(existing.files.soul, files.soul);
+        const identity = this.comparePersonaFile(existing.files.identity, files.identity);
+        return {
+            engramId: agentName,
+            engramName: existing.meta.name,
+            sourcePath,
+            existing: true,
+            name,
+            soul,
+            identity,
+            overwriteRequired: name === "different" ||
+                soul === "different" ||
+                identity === "different",
+        };
+    }
+    async execute(agentName, options) {
+        const sourcePath = resolveWorkspacePath(agentName, options?.openclawDir);
+        if (!existsSync(sourcePath)) {
+            throw new WorkspaceNotFoundError(sourcePath);
+        }
+        const existing = await this.repository.get(agentName);
+        if (existing && !options?.force) {
+            throw new AlreadyExtractedError(agentName);
+        }
+        const { files, filesRead } = await this.readFiles(sourcePath);
+        if (filesRead.length === 0) {
+            throw new WorkspaceEmptyError(sourcePath);
         }
         const now = new Date().toISOString();
-        const engram = {
-            meta: {
-                id: engramId,
-                name: engramName,
-                description: `Extracted from OpenClaw agent (${engramId})`,
-                createdAt: now,
-                updatedAt: now,
-                tags: ["extracted", "openclaw"],
-            },
-            files,
-        };
+        const engram = existing && options?.force
+            ? {
+                meta: {
+                    ...existing.meta,
+                    name: options?.name ?? existing.meta.name,
+                    updatedAt: now,
+                },
+                // Force extract only replaces persona files from Claw.
+                files: {
+                    ...existing.files,
+                    soul: files.soul ?? existing.files.soul,
+                    identity: files.identity ?? existing.files.identity,
+                },
+            }
+            : {
+                meta: {
+                    id: agentName,
+                    name: options?.name ?? agentName,
+                    description: `Extracted from OpenClaw workspace (${agentName})`,
+                    createdAt: now,
+                    updatedAt: now,
+                    tags: ["extracted", "openclaw"],
+                },
+                files,
+            };
         await this.repository.save(engram);
         return {
-            engramId,
-            engramName,
+            engramId: agentName,
+            engramName: engram.meta.name,
             sourcePath,
             filesRead,
-            memoryMerged: false,
-        };
-    }
-    /**
-     * --force時: persona上書き + memoryマージ
-     */
-    async mergeAndSave(existing, newFiles, engramName) {
-        const mergedFiles = { ...newFiles };
-        // memoryEntriesをマージ
-        let memoryMerged = false;
-        if (newFiles.memoryEntries) {
-            mergedFiles.memoryEntries = { ...existing.files.memoryEntries };
-            for (const [date, content] of Object.entries(newFiles.memoryEntries)) {
-                const existingContent = mergedFiles.memoryEntries?.[date];
-                if (existingContent) {
-                    const separator = existingContent.endsWith("\n") ? "\n" : "\n\n";
-                    mergedFiles.memoryEntries[date] = existingContent + separator + content;
-                }
-                else {
-                    mergedFiles.memoryEntries = mergedFiles.memoryEntries ?? {};
-                    mergedFiles.memoryEntries[date] = content;
-                }
-                memoryMerged = true;
-            }
-        }
-        const updatedEngram = {
-            meta: {
-                ...existing.meta,
-                name: engramName,
-                updatedAt: new Date().toISOString(),
-            },
-            files: mergedFiles,
         };
-        await this.repository.save(updatedEngram);
-        return memoryMerged;
     }
-    /**
-     * --forceなし時: memoryエントリのみ追記（repositoryのAPIを使用）
-     */
-    async mergeMemoryOnly(engramId, newEntries) {
-        const existing = await this.repository.get(engramId);
-        if (!existing)
-            return false;
-        const mergedEntries = { ...existing.files.memoryEntries };
-        for (const [date, content] of Object.entries(newEntries)) {
-            const existingContent = mergedEntries[date];
-            if (existingContent) {
-                const separator = existingContent.endsWith("\n") ? "\n" : "\n\n";
-                mergedEntries[date] = existingContent + separator + content;
-            }
-            else {
-                mergedEntries[date] = content;
-            }
+    comparePersonaFile(currentContent, incomingContent) {
+        if (currentContent === undefined || incomingContent === undefined) {
+            return "missing";
         }
-        const updatedEngram = {
-            ...existing,
-            meta: { ...existing.meta, updatedAt: new Date().toISOString() },
-            files: { ...existing.files, memoryEntries: mergedEntries },
-        };
-        await this.repository.save(updatedEngram);
-        return true;
+        return currentContent === incomingContent ? "same" : "different";
     }
     async readFiles(sourcePath) {
         const files = {};
         const filesRead = [];
-        for (const [key, filename] of Object.entries(FILE_MAP)) {
+        for (const [key, filename] of Object.entries(RELIC_FILE_MAP)) {
             const filePath = join(sourcePath, filename);
             if (existsSync(filePath)) {
                 files[key] = await readFile(filePath, "utf-8");
@@ -176,15 +140,9 @@ export class WorkspaceEmptyError extends Error {
         this.name = "WorkspaceEmptyError";
     }
 }
-export class EngramAlreadyExistsError extends Error {
-    constructor(id) {
-        super(`Engram "${id}" already exists. Use --force to overwrite.`);
-        this.name = "EngramAlreadyExistsError";
-    }
-}
-export class ExtractNameRequiredError extends Error {
+export class AlreadyExtractedError extends Error {
     constructor(id) {
-        super(`No existing Engram "${id}" found. --name is required for new Engrams.`);
-        this.name = "ExtractNameRequiredError";
+        super(`Engram "${id}" already exists. Re-run with "--force" option to overwrite local persona files from the Claw workspace.`);
+        this.name = "AlreadyExtractedError";
     }
 }

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

@@ -1,9 +1,9 @@
 export { Summon, EngramNotFoundError, type SummonResult } from "./summon.js";
 export { ListEngrams } from "./list-engrams.js";
 export { Init, type InitResult } from "./init.js";
-export { Inject, InjectEngramNotFoundError, InjectAgentNotFoundError, type InjectResult, } from "./inject.js";
-export { Extract, WorkspaceNotFoundError, WorkspaceEmptyError, EngramAlreadyExistsError, ExtractNameRequiredError, type ExtractResult, } from "./extract.js";
+export { Inject, InjectEngramNotFoundError, InjectClawDirNotFoundError, InjectWorkspaceNotFoundError, type InjectPersonaFileDiff, type InjectPersonaDiffResult, type InjectResult, } from "./inject.js";
+export { Extract, WorkspaceNotFoundError, WorkspaceEmptyError, AlreadyExtractedError, type ExtractPersonaFileDiff, type ExtractPersonaDiffResult, type ExtractResult, } from "./extract.js";
 export { MemoryWrite, MemoryWriteEngramNotFoundError, type MemoryWriteResult, } from "./memory-write.js";
-export { Sync, SyncAgentsDirNotFoundError, type SyncTarget, type SyncInitialResult, } from "./sync.js";
+export { Sync, SyncOpenclawDirNotFoundError, type SyncTarget, type SyncResult, type SyncInitialResult, } from "./sync.js";
 export { ArchivePending, ArchivePendingEngramNotFoundError, type ArchivePendingResult, } from "./archive-pending.js";
 export { ArchiveCursorUpdate, ArchiveCursorUpdateEngramNotFoundError, type ArchiveCursorUpdateResult, } from "./archive-cursor-update.js";

package/dist/core/usecases/index.js

@@ -1,9 +1,9 @@
 export { Summon, EngramNotFoundError } from "./summon.js";
 export { ListEngrams } from "./list-engrams.js";
 export { Init } from "./init.js";
-export { Inject, InjectEngramNotFoundError, InjectAgentNotFoundError, } from "./inject.js";
-export { Extract, WorkspaceNotFoundError, WorkspaceEmptyError, EngramAlreadyExistsError, ExtractNameRequiredError, } from "./extract.js";
+export { Inject, InjectEngramNotFoundError, InjectClawDirNotFoundError, InjectWorkspaceNotFoundError, } from "./inject.js";
+export { Extract, WorkspaceNotFoundError, WorkspaceEmptyError, AlreadyExtractedError, } from "./extract.js";
 export { MemoryWrite, MemoryWriteEngramNotFoundError, } from "./memory-write.js";
-export { Sync, SyncAgentsDirNotFoundError, } from "./sync.js";
+export { Sync, SyncOpenclawDirNotFoundError, } from "./sync.js";
 export { ArchivePending, ArchivePendingEngramNotFoundError, } from "./archive-pending.js";
 export { ArchiveCursorUpdate, ArchiveCursorUpdateEngramNotFoundError, } from "./archive-cursor-update.js";

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

@@ -1,4 +1,13 @@
 import type { EngramRepository } from "../ports/engram-repository.js";
+export type InjectPersonaFileDiff = "missing" | "same" | "different" | "skipped";
+export interface InjectPersonaDiffResult {
+    engramId: string;
+    engramName: string;
+    targetPath: string;
+    soul: InjectPersonaFileDiff;
+    identity: InjectPersonaFileDiff;
+    overwriteRequired: boolean;
+}
 export interface InjectResult {
     engramId: string;
     engramName: string;
@@ -8,21 +17,32 @@ export interface InjectResult {
 /**
  * Inject — EngramのファイルをOpenClawワークスペースに注入する
  *
- * agent名 = Engram ID の規約に基づき、agents/<engramId>/agent/ に書き込む。
+ * OpenClawではエージェントごとに workspace-<name>/ を使い、
+ * デフォルト(main)エージェントのみ workspace/ を使う。
  * memoryEntries はOpenClaw側の管理に委ねるため注入しない。
  */
 export declare class Inject {
     private readonly repository;
     constructor(repository: EngramRepository);
+    inspectPersona(engramId: string, options?: {
+        openclawDir?: string;
+        mergeIdentity?: boolean;
+    }): Promise<InjectPersonaDiffResult>;
     execute(engramId: string, options?: {
-        to?: string;
         openclawDir?: string;
+        mergeIdentity?: boolean;
     }): Promise<InjectResult>;
+    private loadInjectTarget;
+    private resolveInjectedContent;
+    private compareTargetFile;
     private writeFiles;
 }
 export declare class InjectEngramNotFoundError extends Error {
     constructor(id: string);
 }
-export declare class InjectAgentNotFoundError extends Error {
-    constructor(engramId: string, path: string);
+export declare class InjectClawDirNotFoundError extends Error {
+    constructor(path: string);
+}
+export declare class InjectWorkspaceNotFoundError extends Error {
+    constructor(engramId: string);
 }

package/dist/core/usecases/inject.js

@@ -1,11 +1,12 @@
 import { join } from "node:path";
 import { existsSync } from "node:fs";
-import { writeFile } from "node:fs/promises";
-import { FILE_MAP, resolveAgentPath } from "../../shared/openclaw.js";
+import { readFile, writeFile } from "node:fs/promises";
+import { INJECT_FILE_MAP, resolveWorkspacePath } from "../../shared/openclaw.js";
 /**
  * Inject — EngramのファイルをOpenClawワークスペースに注入する
  *
- * agent名 = Engram ID の規約に基づき、agents/<engramId>/agent/ に書き込む。
+ * OpenClawではエージェントごとに workspace-<name>/ を使い、
+ * デフォルト(main)エージェントのみ workspace/ を使う。
  * memoryEntries はOpenClaw側の管理に委ねるため注入しない。
  */
 export class Inject {
@@ -13,17 +14,25 @@ export class Inject {
     constructor(repository) {
         this.repository = repository;
     }
+    async inspectPersona(engramId, options) {
+        const { engram, targetPath } = await this.loadInjectTarget(engramId, options);
+        const mergeIdentity = options?.mergeIdentity ?? false;
+        const soul = await this.compareTargetFile(join(targetPath, INJECT_FILE_MAP.soul), this.resolveInjectedContent("soul", engram.files, mergeIdentity));
+        const identity = mergeIdentity
+            ? "skipped"
+            : await this.compareTargetFile(join(targetPath, INJECT_FILE_MAP.identity), this.resolveInjectedContent("identity", engram.files, mergeIdentity));
+        return {
+            engramId: engram.meta.id,
+            engramName: engram.meta.name,
+            targetPath,
+            soul,
+            identity,
+            overwriteRequired: soul === "different" || identity === "different",
+        };
+    }
     async execute(engramId, options) {
-        const engram = await this.repository.get(engramId);
-        if (!engram) {
-            throw new InjectEngramNotFoundError(engramId);
-        }
-        const agentName = options?.to ?? engramId;
-        const targetPath = resolveAgentPath(agentName, options?.openclawDir);
-        if (!existsSync(targetPath)) {
-            throw new InjectAgentNotFoundError(agentName, targetPath);
-        }
-        const filesWritten = await this.writeFiles(targetPath, engram.files);
+        const { engram, targetPath } = await this.loadInjectTarget(engramId, options);
+        const filesWritten = await this.writeFiles(targetPath, engram.files, options?.mergeIdentity ?? false);
         return {
             engramId: engram.meta.id,
             engramName: engram.meta.name,
@@ -31,10 +40,48 @@ export class Inject {
             filesWritten,
         };
     }
-    async writeFiles(targetPath, files) {
+    async loadInjectTarget(engramId, options) {
+        const engram = await this.repository.get(engramId);
+        if (!engram) {
+            throw new InjectEngramNotFoundError(engramId);
+        }
+        if (options?.openclawDir && !existsSync(options.openclawDir)) {
+            throw new InjectClawDirNotFoundError(options.openclawDir);
+        }
+        const targetPath = resolveWorkspacePath(engramId, options?.openclawDir);
+        if (!existsSync(targetPath)) {
+            throw new InjectWorkspaceNotFoundError(engramId);
+        }
+        return { engram, targetPath };
+    }
+    resolveInjectedContent(key, files, mergeIdentity) {
+        if (mergeIdentity && key === "identity") {
+            return undefined;
+        }
+        let content = files[key];
+        if (mergeIdentity && key === "soul" && files.identity) {
+            content = content + "\n" + files.identity;
+        }
+        return content;
+    }
+    async compareTargetFile(filePath, expectedContent) {
+        if (expectedContent === undefined) {
+            return "skipped";
+        }
+        if (!existsSync(filePath)) {
+            return "missing";
+        }
+        const currentContent = await readFile(filePath, "utf-8");
+        return currentContent === expectedContent ? "same" : "different";
+    }
+    async writeFiles(targetPath, files, mergeIdentity) {
         const written = [];
-        for (const [key, filename] of Object.entries(FILE_MAP)) {
-            const content = files[key];
+        for (const [key, filename] of Object.entries(INJECT_FILE_MAP)) {
+            // --merge-identity: skip IDENTITY.md (merged into SOUL.md below)
+            if (mergeIdentity && key === "identity") {
+                continue;
+            }
+            const content = this.resolveInjectedContent(key, files, mergeIdentity);
             if (content !== undefined) {
                 await writeFile(join(targetPath, filename), content, "utf-8");
                 written.push(filename);
@@ -49,9 +96,15 @@ export class InjectEngramNotFoundError extends Error {
         this.name = "InjectEngramNotFoundError";
     }
 }
-export class InjectAgentNotFoundError extends Error {
-    constructor(engramId, path) {
-        super(`OpenClaw agent "${engramId}" not found at ${path}. The agent must exist before injecting.`);
-        this.name = "InjectAgentNotFoundError";
+export class InjectClawDirNotFoundError extends Error {
+    constructor(path) {
+        super(`Claw directory not found at ${path}`);
+        this.name = "InjectClawDirNotFoundError";
+    }
+}
+export class InjectWorkspaceNotFoundError extends Error {
+    constructor(engramId) {
+        super(`OpenClaw agent "${engramId}" has not been created yet. Run "openclaw agents add ${engramId}" first, then try again.`);
+        this.name = "InjectWorkspaceNotFoundError";
     }
 }

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

@@ -1,40 +1,64 @@
 import type { EngramRepository } from "../ports/engram-repository.js";
 export interface SyncTarget {
     engramId: string;
-    agentPath: string;
-    hasEngram: boolean;
+    workspacePath: string;
+}
+export interface SyncResult {
+    engramId: string;
+    memoryFilesMerged: number;
+    memoryIndexMerged: boolean;
+    userMerged: boolean;
 }
 export interface SyncInitialResult {
-    injected: string[];
-    extracted: string[];
-    targets: SyncTarget[];
+    synced: SyncResult[];
+    skipped: string[];
 }
 /**
- * Sync — OpenClawのagentsディレクトリをスキャンし、
- * 一致するEngramをinject / memoryをextractする。
+ * Sync — Relic Engram と OpenClaw workspace 間で memory を双方向マージする。
  *
- * 初回スキャン後は、呼び出し側がファイル監視を行い、
- * 変更検知時に syncMemory() を呼ぶ。
+ * 対象: 同名の engram/agent が両方に存在するペアのみ。
+ * マージ対象: memory/*.md と MEMORY.md
+ * マージ結果は両方に書き戻される。
  */
 export declare class Sync {
     private readonly repository;
-    private readonly inject;
-    private readonly extract;
-    constructor(repository: EngramRepository);
+    private readonly engramsPath;
+    constructor(repository: EngramRepository, engramsPath: string);
+    execute(openclawDir?: string): Promise<SyncInitialResult>;
+    /**
+     * 1ペア分の memory マージ（inject 後の自動 sync 等でも使用）
+     */
+    syncPair(target: SyncTarget): Promise<SyncResult>;
+    /**
+     * memory/*.md を双方向マージ
+     */
+    private mergeMemoryEntries;
+    /**
+     * MEMORY.md を双方向マージ
+     */
+    private mergeMemoryIndex;
+    /**
+     * 単一ファイルの双方向マージ（MEMORY.md, USER.md 等）
+     */
+    private mergeSingleFile;
+    /**
+     * 2つのテキスト内容をマージする。
+     * 重複行を除外しつつ、両方の内容を結合する。
+     */
+    private mergeContents;
     /**
-     * OpenClawのagentsディレクトリをスキャンし、
-     * Engramが存在するagentにはinject、全agentからmemoryをextractする。
+     * memory/ ディレクトリから日付 → 内容のマップを読む
      */
-    initialSync(openclawDir?: string): Promise<SyncInitialResult>;
+    private readMemoryDir;
     /**
-     * 特定agentのmemoryを同期（ファイル変更検知時に呼ばれる）
+     * 同名の engram/agent が両方に存在するペアを返す
      */
-    syncMemory(engramId: string, openclawDir?: string): Promise<void>;
+    private scanMatchingPairs;
     /**
-     * agentsディレクトリをスキャンしてターゲット一覧を返す
+     * 全 workspace のエージェント名一覧
      */
-    private scanAgents;
+    private scanAllWorkspaces;
 }
-export declare class SyncAgentsDirNotFoundError extends Error {
+export declare class SyncOpenclawDirNotFoundError extends Error {
     constructor(path: string);
 }