@ectplsm/relic 0.3.2 → 0.4.0

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

@@ -0,0 +1,39 @@
+import type { EngramRepository } from "../ports/engram-repository.js";
+import type { MikoshiClient } from "../ports/mikoshi.js";
+export type MikoshiPushOutcome = "create_required" | "push_required" | "already_synced";
+export interface MikoshiPushResult {
+    outcome: MikoshiPushOutcome;
+    engramId: string;
+    engramName: string;
+    /** クラウド側の canonical ID (existing remote only) */
+    cloudEngramId?: string;
+    remotePersonaHash?: string | null;
+}
+export interface MikoshiPushApplyResult {
+    action: "created" | "updated";
+    cloudEngramId: string;
+    newPersonaHash?: string;
+}
+export declare class MikoshiPushEngramNotFoundError extends Error {
+    readonly engramId: string;
+    constructor(engramId: string);
+}
+export declare class MikoshiPushPersonaHashError extends Error {
+    readonly engramId: string;
+    constructor(engramId: string);
+}
+export declare class MikoshiPushPersonaConflictError extends Error {
+    readonly engramId: string;
+    readonly conflictRemoteHash?: string | undefined;
+    constructor(engramId: string, conflictRemoteHash?: string | undefined);
+}
+export declare class MikoshiPush {
+    private readonly localRepo;
+    private readonly mikoshi;
+    constructor(localRepo: EngramRepository, mikoshi: MikoshiClient);
+    check(engramId: string): Promise<{
+        result: MikoshiPushResult;
+        apply?: () => Promise<MikoshiPushApplyResult>;
+    }>;
+    execute(engramId: string): Promise<MikoshiPushApplyResult | undefined>;
+}

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

@@ -0,0 +1,127 @@
+import { MikoshiApiError } from "../ports/mikoshi.js";
+import { computePersonaHash } from "../sync/persona-hash.js";
+// ---------------------------------------------------------------------------
+// Errors
+// ---------------------------------------------------------------------------
+export class MikoshiPushEngramNotFoundError extends Error {
+    engramId;
+    constructor(engramId) {
+        super(`Engram "${engramId}" not found locally`);
+        this.engramId = engramId;
+        this.name = "MikoshiPushEngramNotFoundError";
+    }
+}
+export class MikoshiPushPersonaHashError extends Error {
+    engramId;
+    constructor(engramId) {
+        super(`Cannot compute persona hash for "${engramId}" — SOUL.md or IDENTITY.md is missing`);
+        this.engramId = engramId;
+        this.name = "MikoshiPushPersonaHashError";
+    }
+}
+export class MikoshiPushPersonaConflictError extends Error {
+    engramId;
+    conflictRemoteHash;
+    constructor(engramId, conflictRemoteHash) {
+        super(`Persona conflict for "${engramId}"`);
+        this.engramId = engramId;
+        this.conflictRemoteHash = conflictRemoteHash;
+        this.name = "MikoshiPushPersonaConflictError";
+    }
+}
+// ---------------------------------------------------------------------------
+// Usecase
+// ---------------------------------------------------------------------------
+export class MikoshiPush {
+    localRepo;
+    mikoshi;
+    constructor(localRepo, mikoshi) {
+        this.localRepo = localRepo;
+        this.mikoshi = mikoshi;
+    }
+    async check(engramId) {
+        const local = await this.localRepo.get(engramId);
+        if (!local)
+            throw new MikoshiPushEngramNotFoundError(engramId);
+        const { soul, identity } = local.files;
+        const localHash = computePersonaHash(soul, identity);
+        if (!localHash)
+            throw new MikoshiPushPersonaHashError(engramId);
+        const cloudEngram = await this.mikoshi.getEngramBySourceId(engramId);
+        if (!cloudEngram) {
+            return {
+                result: {
+                    outcome: "create_required",
+                    engramId,
+                    engramName: local.meta.name,
+                    remotePersonaHash: null,
+                },
+                apply: async () => {
+                    const created = await this.mikoshi.createEngram({
+                        name: local.meta.name,
+                        sourceEngramId: engramId,
+                        description: local.meta.description,
+                        tags: local.meta.tags,
+                        soul,
+                        identity,
+                    });
+                    return {
+                        action: "created",
+                        cloudEngramId: created.id,
+                    };
+                },
+            };
+        }
+        const syncStatus = await this.mikoshi.getSyncStatus(cloudEngram.id);
+        const remoteHash = syncStatus.persona.token?.hash ?? null;
+        if (remoteHash && localHash === remoteHash) {
+            return {
+                result: {
+                    outcome: "already_synced",
+                    engramId,
+                    engramName: local.meta.name,
+                    cloudEngramId: cloudEngram.id,
+                    remotePersonaHash: remoteHash,
+                },
+            };
+        }
+        return {
+            result: {
+                outcome: "push_required",
+                engramId,
+                engramName: local.meta.name,
+                cloudEngramId: cloudEngram.id,
+                remotePersonaHash: remoteHash,
+            },
+            apply: async () => {
+                const expectedHash = remoteHash ?? "";
+                try {
+                    const updated = await this.mikoshi.updatePersona(cloudEngram.id, {
+                        soul,
+                        identity,
+                        expectedRemotePersonaHash: expectedHash,
+                    });
+                    return {
+                        action: "updated",
+                        cloudEngramId: cloudEngram.id,
+                        newPersonaHash: updated.persona.hash,
+                    };
+                }
+                catch (err) {
+                    if (err instanceof MikoshiApiError && err.isConflict && err.code === "PERSONA_CONFLICT") {
+                        const body = err.body;
+                        throw new MikoshiPushPersonaConflictError(engramId, body?.currentPersona?.hash);
+                    }
+                    throw err;
+                }
+            },
+        };
+    }
+    async execute(engramId) {
+        const { result, apply } = await this.check(engramId);
+        if (result.outcome === "already_synced" || !apply) {
+            return undefined;
+        }
+        return apply();
+    }
+}

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

@@ -0,0 +1,37 @@
+import type { EngramRepository } from "../ports/engram-repository.js";
+import type { MikoshiClient, SyncStatusResponse } from "../ports/mikoshi.js";
+export type PersonaDriftStatus = "synced" | "local_differs" | "remote_only" | "unavailable";
+export type MemoryDriftStatus = "synced" | "local_differs" | "not_uploaded" | "local_empty";
+export interface MikoshiStatusResult {
+    engramId: string;
+    engramName: string;
+    /** Mikoshi 側の canonical ID */
+    cloudEngramId: string;
+    sourceEngramId: string;
+    persona: {
+        status: PersonaDriftStatus;
+        localHash: string | null;
+        remoteHash: string | null;
+    };
+    memory: {
+        status: MemoryDriftStatus;
+        localHash: string | null;
+        remoteHash: string | null;
+        remoteExists: boolean;
+        remoteSummary: SyncStatusResponse["memory"]["summary"] | null;
+    };
+}
+export declare class MikoshiStatusEngramNotFoundError extends Error {
+    readonly engramId: string;
+    constructor(engramId: string);
+}
+export declare class MikoshiStatusCloudNotFoundError extends Error {
+    readonly sourceEngramId: string;
+    constructor(sourceEngramId: string);
+}
+export declare class MikoshiStatus {
+    private readonly localRepo;
+    private readonly mikoshi;
+    constructor(localRepo: EngramRepository, mikoshi: MikoshiClient);
+    execute(engramId: string): Promise<MikoshiStatusResult>;
+}

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

@@ -0,0 +1,92 @@
+import { computePersonaHash } from "../sync/persona-hash.js";
+import { computeMemoryContentHash, collectMemoryFiles } from "../sync/memory-hash.js";
+// ---------------------------------------------------------------------------
+// Errors
+// ---------------------------------------------------------------------------
+export class MikoshiStatusEngramNotFoundError extends Error {
+    engramId;
+    constructor(engramId) {
+        super(`Engram "${engramId}" not found locally`);
+        this.engramId = engramId;
+        this.name = "MikoshiStatusEngramNotFoundError";
+    }
+}
+export class MikoshiStatusCloudNotFoundError extends Error {
+    sourceEngramId;
+    constructor(sourceEngramId) {
+        super(`Engram "${sourceEngramId}" not found on Mikoshi`);
+        this.sourceEngramId = sourceEngramId;
+        this.name = "MikoshiStatusCloudNotFoundError";
+    }
+}
+// ---------------------------------------------------------------------------
+// Usecase
+// ---------------------------------------------------------------------------
+export class MikoshiStatus {
+    localRepo;
+    mikoshi;
+    constructor(localRepo, mikoshi) {
+        this.localRepo = localRepo;
+        this.mikoshi = mikoshi;
+    }
+    async execute(engramId) {
+        // 1. ローカル Engram 読み込み
+        const local = await this.localRepo.get(engramId);
+        if (!local)
+            throw new MikoshiStatusEngramNotFoundError(engramId);
+        // 2. クラウド側を sourceEngramId で検索
+        const cloudEngram = await this.mikoshi.getEngramBySourceId(engramId);
+        if (!cloudEngram)
+            throw new MikoshiStatusCloudNotFoundError(engramId);
+        // 3. sync-status 取得
+        const syncStatus = await this.mikoshi.getSyncStatus(cloudEngram.id);
+        // 4. ローカル persona hash 計算
+        const localPersonaHash = computePersonaHash(local.files.soul, local.files.identity);
+        // 5. Persona drift 判定
+        const remotePersonaHash = syncStatus.persona.token?.hash ?? null;
+        const personaStatus = classifyPersonaDrift(localPersonaHash, remotePersonaHash);
+        // 6. ローカル memory content hash 計算
+        const localMemoryFiles = collectMemoryFiles(local.files);
+        const localMemoryHash = computeMemoryContentHash(localMemoryFiles);
+        // 7. Memory drift 判定
+        const remoteMemoryHash = syncStatus.memory.token?.memoryContentHash ?? null;
+        const memoryStatus = classifyMemoryDrift(localMemoryHash, remoteMemoryHash, syncStatus.memory.exists);
+        return {
+            engramId,
+            engramName: local.meta.name,
+            cloudEngramId: cloudEngram.id,
+            sourceEngramId: cloudEngram.sourceEngramId,
+            persona: {
+                status: personaStatus,
+                localHash: localPersonaHash,
+                remoteHash: remotePersonaHash,
+            },
+            memory: {
+                status: memoryStatus,
+                localHash: localMemoryHash,
+                remoteHash: remoteMemoryHash,
+                remoteExists: syncStatus.memory.exists,
+                remoteSummary: syncStatus.memory.summary,
+            },
+        };
+    }
+}
+// ---------------------------------------------------------------------------
+// Drift classification helpers
+// ---------------------------------------------------------------------------
+function classifyPersonaDrift(localHash, remoteHash) {
+    if (!localHash)
+        return "unavailable";
+    if (!remoteHash)
+        return "remote_only";
+    return localHash === remoteHash ? "synced" : "local_differs";
+}
+function classifyMemoryDrift(localHash, remoteHash, remoteExists) {
+    if (!localHash)
+        return "local_empty";
+    if (!remoteExists)
+        return "not_uploaded";
+    if (!remoteHash)
+        return "not_uploaded";
+    return localHash === remoteHash ? "synced" : "local_differs";
+}

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

@@ -41,11 +41,6 @@ export declare class Sync {
      * 単一ファイルの双方向マージ（MEMORY.md, USER.md 等）
      */
     private mergeSingleFile;
-    /**
-     * 2つのテキスト内容をマージする。
-     * 重複行を除外しつつ、両方の内容を結合する。
-     */
-    private mergeContents;
     /**
      * memory/ ディレクトリから日付 → 内容のマップを読む
      */

package/dist/core/usecases/sync.js

@@ -2,6 +2,7 @@ import { existsSync } from "node:fs";
 import { readdir, readFile, writeFile, mkdir } from "node:fs/promises";
 import { join } from "node:path";
 import { homedir } from "node:os";
+import { mergeMemoryRecords } from "../sync/memory-merge.js";
 import { extractAgentName, MEMORY_DIR } from "../../shared/openclaw.js";
 const DEFAULT_OPENCLAW_DIR = join(homedir(), ".openclaw");
 const MEMORY_INDEX = "MEMORY.md";
@@ -73,37 +74,20 @@ export class Sync {
         const openclawMemDir = join(openclawDir, MEMORY_DIR);
         const relicEntries = await this.readMemoryDir(relicMemDir);
         const openclawEntries = await this.readMemoryDir(openclawMemDir);
-        // 全日付の union
-        const allDates = new Set([
-            ...Object.keys(relicEntries),
-            ...Object.keys(openclawEntries),
-        ]);
-        let mergedCount = 0;
-        for (const date of allDates) {
-            const relicContent = relicEntries[date];
-            const openclawContent = openclawEntries[date];
-            if (relicContent && !openclawContent) {
-                // RELIC にだけある → OpenClaw にコピー
-                await mkdir(openclawMemDir, { recursive: true });
-                await writeFile(join(openclawMemDir, `${date}.md`), relicContent, "utf-8");
-                mergedCount++;
-            }
-            else if (!relicContent && openclawContent) {
-                // OpenClaw にだけある → RELIC にコピー
-                await mkdir(relicMemDir, { recursive: true });
-                await writeFile(join(relicMemDir, `${date}.md`), openclawContent, "utf-8");
-                mergedCount++;
-            }
-            else if (relicContent && openclawContent && relicContent !== openclawContent) {
-                // 両方にあるが内容が違う → マージして両方に書き込み
-                const merged = this.mergeContents(relicContent, openclawContent);
-                await writeFile(join(relicMemDir, `${date}.md`), merged, "utf-8");
-                await writeFile(join(openclawMemDir, `${date}.md`), merged, "utf-8");
-                mergedCount++;
-            }
-            // 内容が同じ → 何もしない
+        const relicRecord = Object.fromEntries(Object.entries(relicEntries).map(([date, content]) => [`memory/${date}.md`, content]));
+        const openclawRecord = Object.fromEntries(Object.entries(openclawEntries).map(([date, content]) => [`memory/${date}.md`, content]));
+        const { merged, changedPaths } = mergeMemoryRecords(relicRecord, openclawRecord);
+        if (changedPaths.length === 0) {
+            return 0;
         }
-        return mergedCount;
+        await mkdir(relicMemDir, { recursive: true });
+        await mkdir(openclawMemDir, { recursive: true });
+        for (const [path, content] of Object.entries(merged)) {
+            const date = path.replace("memory/", "").replace(".md", "");
+            await writeFile(join(relicMemDir, `${date}.md`), content, "utf-8");
+            await writeFile(join(openclawMemDir, `${date}.md`), content, "utf-8");
+        }
+        return changedPaths.length;
     }
     /**
      * MEMORY.md を双方向マージ
@@ -123,41 +107,19 @@ export class Sync {
         const openclawContent = existsSync(openclawPath)
             ? await readFile(openclawPath, "utf-8")
             : null;
-        if (relicContent && !openclawContent) {
-            await writeFile(openclawPath, relicContent, "utf-8");
-            return true;
-        }
-        else if (!relicContent && openclawContent) {
-            await writeFile(relicPath, openclawContent, "utf-8");
-            return true;
-        }
-        else if (relicContent && openclawContent && relicContent !== openclawContent) {
-            const merged = this.mergeContents(relicContent, openclawContent);
-            await writeFile(relicPath, merged, "utf-8");
-            await writeFile(openclawPath, merged, "utf-8");
+        const relicRecord = relicContent ? { [filename]: relicContent } : {};
+        const openclawRecord = openclawContent ? { [filename]: openclawContent } : {};
+        const { merged, changedPaths } = mergeMemoryRecords(relicRecord, openclawRecord);
+        if (changedPaths.length > 0) {
+            const mergedContent = merged[filename];
+            if (mergedContent !== undefined) {
+                await writeFile(relicPath, mergedContent, "utf-8");
+                await writeFile(openclawPath, mergedContent, "utf-8");
+            }
             return true;
         }
         return false;
     }
-    /**
-     * 2つのテキスト内容をマージする。
-     * 重複行を除外しつつ、両方の内容を結合する。
-     */
-    mergeContents(a, b) {
-        const aLines = a.trimEnd();
-        const bLines = b.trimEnd();
-        // 完全一致チェック（ここには来ないはずだが安全策）
-        if (aLines === bLines)
-            return a;
-        // b の中で a に含まれない部分を抽出して追記
-        const aSet = new Set(aLines.split("\n"));
-        const uniqueB = bLines
-            .split("\n")
-            .filter((line) => !aSet.has(line));
-        if (uniqueB.length === 0)
-            return a;
-        return aLines + "\n\n" + uniqueB.join("\n") + "\n";
-    }
     /**
      * memory/ ディレクトリから日付 → 内容のマップを読む
      */