@ectplsm/relic 0.3.2 → 0.5.0

package/dist/core/usecases/mikoshi-memory-sync.js

@@ -0,0 +1,175 @@
+import { MikoshiApiError } from "../ports/mikoshi.js";
+import { decryptMemoryBundle, encryptMemoryBundle } from "../sync/crypto.js";
+import { collectMemoryFiles, computeMemoryContentHash, memoryFilesToRecord } from "../sync/memory-hash.js";
+import { applyMemoryRecordToFiles, computeMemoryRecordDiff, mergeMemoryRecords, } from "../sync/memory-merge.js";
+export class MikoshiMemorySyncEngramNotFoundError extends Error {
+    engramId;
+    constructor(engramId) {
+        super(`Engram "${engramId}" not found locally`);
+        this.engramId = engramId;
+        this.name = "MikoshiMemorySyncEngramNotFoundError";
+    }
+}
+export class MikoshiMemorySyncCloudNotFoundError extends Error {
+    sourceEngramId;
+    constructor(sourceEngramId) {
+        super(`Engram "${sourceEngramId}" not found on Mikoshi. Push persona first with: relic mikoshi push`);
+        this.sourceEngramId = sourceEngramId;
+        this.name = "MikoshiMemorySyncCloudNotFoundError";
+    }
+}
+export class MikoshiMemorySyncDecryptError extends Error {
+    constructor(cause) {
+        super("Failed to decrypt memory bundle — wrong passphrase or corrupted data");
+        this.name = "MikoshiMemorySyncDecryptError";
+        this.cause = cause;
+    }
+}
+export class MikoshiMemorySync {
+    localRepo;
+    mikoshi;
+    constructor(localRepo, mikoshi) {
+        this.localRepo = localRepo;
+        this.mikoshi = mikoshi;
+    }
+    async execute(engramId, passphrase) {
+        const local = await this.localRepo.get(engramId);
+        if (!local)
+            throw new MikoshiMemorySyncEngramNotFoundError(engramId);
+        const cloudEngram = await this.mikoshi.getEngramBySourceId(engramId);
+        if (!cloudEngram)
+            throw new MikoshiMemorySyncCloudNotFoundError(engramId);
+        const localRecord = memoryFilesToRecord(collectMemoryFiles(local.files));
+        const memoryRes = await this.mikoshi.downloadMemory(cloudEngram.id);
+        let remoteRecord = {};
+        let expectedRemoteHash = null;
+        if (memoryRes.hasMemory) {
+            try {
+                remoteRecord = decryptMemoryBundle(memoryRes, passphrase);
+            }
+            catch (err) {
+                throw new MikoshiMemorySyncDecryptError(err);
+            }
+            expectedRemoteHash = memoryRes.memoryContentHash;
+        }
+        if (Object.keys(localRecord).length === 0 && Object.keys(remoteRecord).length === 0) {
+            return {
+                outcome: "already_synced",
+                engramId,
+                engramName: local.meta.name,
+                cloudEngramId: cloudEngram.id,
+                localUpdated: false,
+                remoteUpdated: false,
+            };
+        }
+        const diff = computeMemoryRecordDiff(localRecord, remoteRecord);
+        const { merged, changedPaths } = mergeMemoryRecords(localRecord, remoteRecord);
+        const localUpdated = !recordsEqual(localRecord, merged);
+        const remoteUpdated = !recordsEqual(remoteRecord, merged);
+        if (!localUpdated && !remoteUpdated) {
+            return {
+                outcome: "already_synced",
+                engramId,
+                engramName: local.meta.name,
+                cloudEngramId: cloudEngram.id,
+                localUpdated: false,
+                remoteUpdated: false,
+                diff,
+                mergedPaths: [],
+            };
+        }
+        if (localUpdated) {
+            await this.localRepo.save({
+                meta: { ...local.meta, updatedAt: new Date().toISOString() },
+                files: applyMemoryRecordToFiles(local.files, merged),
+            });
+        }
+        if (!remoteUpdated) {
+            return {
+                outcome: "synced",
+                engramId,
+                engramName: local.meta.name,
+                cloudEngramId: cloudEngram.id,
+                localUpdated,
+                remoteUpdated: false,
+                diff,
+                mergedPaths: changedPaths,
+            };
+        }
+        const mergedBundle = encryptMemoryBundle(merged, passphrase);
+        const mergedEntries = Object.entries(merged).map(([path, content]) => ({ path, content }));
+        const memoryContentHash = computeMemoryContentHash(mergedEntries);
+        if (!memoryContentHash) {
+            return {
+                outcome: "already_synced",
+                engramId,
+                engramName: local.meta.name,
+                cloudEngramId: cloudEngram.id,
+                localUpdated,
+                remoteUpdated: false,
+                diff,
+                mergedPaths: changedPaths,
+            };
+        }
+        try {
+            const uploaded = await this.mikoshi.uploadMemory(cloudEngram.id, {
+                ciphertext: mergedBundle.ciphertext,
+                cipherAlgorithm: mergedBundle.cipherAlgorithm,
+                cipherNonce: mergedBundle.cipherNonce,
+                wrappedBundleKey: mergedBundle.wrappedBundleKey,
+                wrapAlgorithm: mergedBundle.wrapAlgorithm,
+                kdfAlgorithm: mergedBundle.kdfAlgorithm,
+                kdfSalt: mergedBundle.kdfSalt,
+                kdfParams: mergedBundle.kdfParams,
+                manifest: mergedBundle.manifest,
+                expectedRemoteMemoryContentHash: expectedRemoteHash,
+                memoryContentHash,
+                bundleHash: mergedBundle.bundleHash,
+            });
+            return {
+                outcome: "synced",
+                engramId,
+                engramName: local.meta.name,
+                cloudEngramId: cloudEngram.id,
+                localUpdated,
+                remoteUpdated: true,
+                diff,
+                mergedPaths: changedPaths,
+                version: uploaded.version,
+                memoryContentHash: uploaded.memoryContentHash,
+                bundleHash: uploaded.bundleHash,
+            };
+        }
+        catch (err) {
+            if (err instanceof MikoshiApiError && err.isConflict && err.code === "MEMORY_CONFLICT") {
+                const body = err.body;
+                return {
+                    outcome: "conflict",
+                    engramId,
+                    engramName: local.meta.name,
+                    cloudEngramId: cloudEngram.id,
+                    localUpdated,
+                    remoteUpdated: true,
+                    diff,
+                    mergedPaths: changedPaths,
+                    conflictRemoteHash: body?.currentMemory?.memoryContentHash,
+                    conflictRemoteVersion: body?.currentMemory?.version,
+                };
+            }
+            throw err;
+        }
+    }
+}
+function recordsEqual(a, b) {
+    const aKeys = Object.keys(a).sort();
+    const bKeys = Object.keys(b).sort();
+    if (aKeys.length !== bKeys.length)
+        return false;
+    for (let i = 0; i < aKeys.length; i += 1) {
+        if (aKeys[i] !== bKeys[i])
+            return false;
+        if (a[aKeys[i]] !== b[bKeys[i]])
+            return false;
+    }
+    return true;
+}

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

@@ -0,0 +1,44 @@
+import type { EngramRepository } from "../ports/engram-repository.js";
+import type { MikoshiClient } from "../ports/mikoshi.js";
+export type MikoshiPullOutcome = "pulled" | "already_synced";
+export interface MikoshiPullDiff {
+    soulDiffers: boolean;
+    identityDiffers: boolean;
+    remoteSoul: string;
+    remoteIdentity: string;
+}
+export interface MikoshiPullResult {
+    outcome: MikoshiPullOutcome;
+    engramId: string;
+    engramName: string;
+    cloudEngramId: string;
+    diff?: MikoshiPullDiff;
+}
+export declare class MikoshiPullEngramNotFoundError extends Error {
+    readonly engramId: string;
+    constructor(engramId: string);
+}
+export declare class MikoshiPullCloudNotFoundError extends Error {
+    readonly sourceEngramId: string;
+    constructor(sourceEngramId: string);
+}
+export declare class MikoshiPullPersonaMissingError extends Error {
+    readonly cloudEngramId: string;
+    constructor(cloudEngramId: string);
+}
+export declare class MikoshiPull {
+    private readonly localRepo;
+    private readonly mikoshi;
+    constructor(localRepo: EngramRepository, mikoshi: MikoshiClient);
+    /**
+     * Phase 1: fetch + diff。上書きはまだしない。
+     *
+     * - ローカル未作成 → EngramNotFoundError
+     * - ローカル既存 + 差分なし → already_synced
+     * - ローカル既存 + 差分あり → apply で上書き
+     */
+    check(engramId: string): Promise<{
+        result: MikoshiPullResult;
+        apply?: () => Promise<void>;
+    }>;
+}

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

@@ -0,0 +1,124 @@
+// ---------------------------------------------------------------------------
+// Errors
+// ---------------------------------------------------------------------------
+export class MikoshiPullEngramNotFoundError extends Error {
+    engramId;
+    constructor(engramId) {
+        super(`Engram "${engramId}" not found locally. Use "relic mikoshi pull" to create or update it.`);
+        this.engramId = engramId;
+        this.name = "MikoshiPullEngramNotFoundError";
+    }
+}
+export class MikoshiPullCloudNotFoundError extends Error {
+    sourceEngramId;
+    constructor(sourceEngramId) {
+        super(`Engram "${sourceEngramId}" not found on Mikoshi`);
+        this.sourceEngramId = sourceEngramId;
+        this.name = "MikoshiPullCloudNotFoundError";
+    }
+}
+export class MikoshiPullPersonaMissingError extends Error {
+    cloudEngramId;
+    constructor(cloudEngramId) {
+        super(`Remote Engram "${cloudEngramId}" is missing SOUL.md or IDENTITY.md`);
+        this.cloudEngramId = cloudEngramId;
+        this.name = "MikoshiPullPersonaMissingError";
+    }
+}
+// ---------------------------------------------------------------------------
+// Usecase
+// ---------------------------------------------------------------------------
+export class MikoshiPull {
+    localRepo;
+    mikoshi;
+    constructor(localRepo, mikoshi) {
+        this.localRepo = localRepo;
+        this.mikoshi = mikoshi;
+    }
+    /**
+     * Phase 1: fetch + diff。上書きはまだしない。
+     *
+     * - ローカル未作成 → EngramNotFoundError
+     * - ローカル既存 + 差分なし → already_synced
+     * - ローカル既存 + 差分あり → apply で上書き
+     */
+    async check(engramId) {
+        // 1. ローカル Engram 必須
+        const local = await this.localRepo.get(engramId);
+        if (!local) {
+            throw new MikoshiPullEngramNotFoundError(engramId);
+        }
+        // 2. クラウド検索
+        const cloudEngram = await this.mikoshi.getEngramBySourceId(engramId);
+        if (!cloudEngram)
+            throw new MikoshiPullCloudNotFoundError(engramId);
+        // 3. Detail 取得 (persona content 込み)
+        const detail = await this.mikoshi.getEngram(cloudEngram.id);
+        const { soul: remoteSoul, identity: remoteIdentity } = extractPersona(detail);
+        if (!remoteSoul || !remoteIdentity) {
+            throw new MikoshiPullPersonaMissingError(cloudEngram.id);
+        }
+        // 4. 差分計算 (末尾空白の差異は無視)
+        const soulDiffers = normalizeContent(local.files.soul) !== normalizeContent(remoteSoul);
+        const identityDiffers = normalizeContent(local.files.identity) !== normalizeContent(remoteIdentity);
+        if (!soulDiffers && !identityDiffers) {
+            return {
+                result: {
+                    outcome: "already_synced",
+                    engramId,
+                    engramName: local.meta.name,
+                    cloudEngramId: cloudEngram.id,
+                },
+            };
+        }
+        const diff = {
+            soulDiffers,
+            identityDiffers,
+            remoteSoul,
+            remoteIdentity,
+        };
+        // 5. apply クロージャ
+        const apply = async () => {
+            const fresh = await this.localRepo.get(engramId);
+            if (!fresh)
+                throw new MikoshiPullEngramNotFoundError(engramId);
+            const updatedFiles = { ...fresh.files };
+            if (soulDiffers)
+                updatedFiles.soul = remoteSoul;
+            if (identityDiffers)
+                updatedFiles.identity = remoteIdentity;
+            await this.localRepo.save({
+                meta: { ...fresh.meta, updatedAt: new Date().toISOString() },
+                files: updatedFiles,
+            });
+        };
+        return {
+            result: {
+                outcome: "pulled",
+                engramId,
+                engramName: local.meta.name,
+                cloudEngramId: cloudEngram.id,
+                diff,
+            },
+            apply,
+        };
+    }
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function extractPersona(detail) {
+    let soul;
+    let identity;
+    for (const f of detail.personaFiles) {
+        if (f.fileType === "SOUL")
+            soul = f.content;
+        if (f.fileType === "IDENTITY")
+            identity = f.content;
+    }
+    return { soul, identity };
+}
+/** Trim trailing whitespace so minor formatting differences don't cause false diffs. */
+function normalizeContent(content) {
+    return (content ?? "").trimEnd();
+}

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/ ディレクトリから日付 → 内容のマップを読む
      */