@ectplsm/relic 0.3.2 → 0.5.0

package/dist/core/sync/persona-hash.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Persona hash canonicalization — mikoshi-sync.md 準拠
+ *
+ * 正規化ルール:
+ *  - UTF-8 BOM 除去
+ *  - 改行を \n に統一
+ *  - 末尾 \n を strip
+ *
+ * Canonical payload:
+ *  header \n SOUL.md \n byteLen \n content \n IDENTITY.md \n byteLen \n content
+ *
+ * 出力: "sha256:<64 lowercase hex>"
+ * soul / identity どちらかが欠落なら null
+ */
+export declare function computePersonaHash(soul: string | undefined, identity: string | undefined): string | null;

package/dist/core/sync/persona-hash.js

@@ -0,0 +1,36 @@
+import { createHash } from "node:crypto";
+import { normalizeText } from "./normalize.js";
+const HEADER = "mikoshi.persona.v1";
+/**
+ * Persona hash canonicalization — mikoshi-sync.md 準拠
+ *
+ * 正規化ルール:
+ *  - UTF-8 BOM 除去
+ *  - 改行を \n に統一
+ *  - 末尾 \n を strip
+ *
+ * Canonical payload:
+ *  header \n SOUL.md \n byteLen \n content \n IDENTITY.md \n byteLen \n content
+ *
+ * 出力: "sha256:<64 lowercase hex>"
+ * soul / identity どちらかが欠落なら null
+ */
+export function computePersonaHash(soul, identity) {
+    if (!soul || !identity)
+        return null;
+    const normSoul = normalizeText(soul, { stripTrailingNewlines: true });
+    const normIdentity = normalizeText(identity, { stripTrailingNewlines: true });
+    const soulBytes = Buffer.byteLength(normSoul, "utf-8");
+    const identityBytes = Buffer.byteLength(normIdentity, "utf-8");
+    const payload = [
+        HEADER,
+        "SOUL.md",
+        String(soulBytes),
+        normSoul,
+        "IDENTITY.md",
+        String(identityBytes),
+        normIdentity,
+    ].join("\n");
+    const hex = createHash("sha256").update(payload, "utf-8").digest("hex");
+    return `sha256:${hex}`;
+}

package/dist/core/usecases/archive-cursor-update.d.ts

@@ -16,6 +16,12 @@ export declare class ArchiveCursorUpdate {
     execute(engramId: string, count: number): Promise<ArchiveCursorUpdateResult>;
     private readCursor;
 }
+export declare class ArchiveCursorAdvanceOverflowError extends Error {
+    readonly id: string;
+    readonly requestedCount: number;
+    readonly availablePending: number;
+    constructor(id: string, requestedCount: number, availablePending: number);
+}
 export declare class ArchiveCursorUpdateEngramNotFoundError extends Error {
     constructor(id: string);
 }

package/dist/core/usecases/archive-cursor-update.js

@@ -1,6 +1,7 @@
 import { join } from "node:path";
 import { existsSync } from "node:fs";
 import { readFile, writeFile } from "node:fs/promises";
+import { ArchivePending } from "./archive-pending.js";
 /**
  * ArchiveCursorUpdate — archive.cursor を指定件数分だけ進める
  *
@@ -19,6 +20,11 @@ export class ArchiveCursorUpdate {
         }
         const cursorPath = join(engramDir, "archive.cursor");
         const previousCursor = await this.readCursor(cursorPath);
+        const archivePending = new ArchivePending(this.engramsPath);
+        const pending = await archivePending.execute(engramId, Number.MAX_SAFE_INTEGER);
+        if (count > pending.entries.length) {
+            throw new ArchiveCursorAdvanceOverflowError(engramId, count, pending.entries.length);
+        }
         const newCursor = previousCursor + count;
         await writeFile(cursorPath, String(newCursor), "utf-8");
         return { previousCursor, newCursor };
@@ -36,6 +42,18 @@ export class ArchiveCursorUpdate {
         }
     }
 }
+export class ArchiveCursorAdvanceOverflowError extends Error {
+    id;
+    requestedCount;
+    availablePending;
+    constructor(id, requestedCount, availablePending) {
+        super(`Engram "${id}" cursor advance overflow (${requestedCount} > ${availablePending}). Refusing to move archive.cursor.`);
+        this.id = id;
+        this.requestedCount = requestedCount;
+        this.availablePending = availablePending;
+        this.name = "ArchiveCursorAdvanceOverflowError";
+    }
+}
 export class ArchiveCursorUpdateEngramNotFoundError extends Error {
     constructor(id) {
         super(`Engram "${id}" archive not found`);

package/dist/core/usecases/archive-pending.d.ts

@@ -1,6 +1,16 @@
+export interface ArchivePendingEntry {
+    /** archive.md 先頭行から抽出した日付 */
+    date: string | null;
+    /** archive.md 先頭行の summary 部分 */
+    summary: string | null;
+    /** エントリ全文 */
+    raw: string;
+    /** 先頭行を除いた本文 */
+    body: string;
+}
 export interface ArchivePendingResult {
     /** 未蒸留エントリ（cursor以降） */
-    entries: string[];
+    entries: ArchivePendingEntry[];
     /** 現在のcursor位置 */
     cursor: number;
     /** archive内の総エントリ数 */
@@ -8,6 +18,12 @@ export interface ArchivePendingResult {
     /** 今回返さなかった残りの未蒸留エントリ数 */
     remaining: number;
 }
+export declare class ArchiveCursorCorruptedError extends Error {
+    readonly id: string;
+    readonly cursor: number;
+    readonly total: number;
+    constructor(id: string, cursor: number, total: number);
+}
 /**
  * ArchivePending — archive.md の未蒸留エントリを取得する
  *
@@ -20,6 +36,7 @@ export declare class ArchivePending {
     execute(engramId: string, limit?: number): Promise<ArchivePendingResult>;
     private readCursor;
 }
+export declare function parseArchiveEntry(raw: string): ArchivePendingEntry;
 export declare class ArchivePendingEngramNotFoundError extends Error {
     constructor(id: string);
 }

package/dist/core/usecases/archive-pending.js

@@ -2,7 +2,20 @@ import { join } from "node:path";
 import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 const ENTRY_SEPARATOR = /\n---\n/;
-const DEFAULT_LIMIT = 30;
+const DEFAULT_LIMIT = 100;
+const ENTRY_HEADER_PATTERN = /^(\d{4}-\d{2}-\d{2}) \| ?(.*)$/;
+export class ArchiveCursorCorruptedError extends Error {
+    id;
+    cursor;
+    total;
+    constructor(id, cursor, total) {
+        super(`Engram "${id}" archive cursor is invalid (${cursor} > ${total}). Repair archive.cursor before distilling.`);
+        this.id = id;
+        this.cursor = cursor;
+        this.total = total;
+        this.name = "ArchiveCursorCorruptedError";
+    }
+}
 /**
  * ArchivePending — archive.md の未蒸留エントリを取得する
  *
@@ -29,11 +42,14 @@ export class ArchivePending {
             .map((e) => e.trim())
             .filter((e) => e.length > 0);
         const cursor = await this.readCursor(engramDir);
+        if (cursor > allEntries.length) {
+            throw new ArchiveCursorCorruptedError(engramId, cursor, allEntries.length);
+        }
         const pendingEntries = allEntries.slice(cursor);
         const effectiveLimit = limit ?? DEFAULT_LIMIT;
         const returned = pendingEntries.slice(0, effectiveLimit);
         return {
-            entries: returned,
+            entries: returned.map(parseArchiveEntry),
             cursor,
             total: allEntries.length,
             remaining: pendingEntries.length - returned.length,
@@ -53,6 +69,25 @@ export class ArchivePending {
         }
     }
 }
+export function parseArchiveEntry(raw) {
+    const trimmed = raw.trim();
+    const [header = "", ...rest] = trimmed.split("\n");
+    const match = header.match(ENTRY_HEADER_PATTERN);
+    if (!match) {
+        return {
+            date: null,
+            summary: null,
+            raw: trimmed,
+            body: trimmed,
+        };
+    }
+    return {
+        date: match[1],
+        summary: match[2] || null,
+        raw: trimmed,
+        body: rest.join("\n").trim(),
+    };
+}
 export class ArchivePendingEngramNotFoundError extends Error {
     constructor(id) {
         super(`Engram "${id}" archive not found`);

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

@@ -0,0 +1,44 @@
+import type { EngramRepository } from "../ports/engram-repository.js";
+export type ClawPullPersonaFileDiff = "missing" | "same" | "different";
+export interface ClawPullDiff {
+    soulDiff: ClawPullPersonaFileDiff;
+    identityDiff: ClawPullPersonaFileDiff;
+    sourcePath: string;
+    remoteSoul?: string;
+    remoteIdentity?: string;
+}
+export type ClawPullOutcome = "pulled" | "already_synced";
+export interface ClawPullResult {
+    outcome: ClawPullOutcome;
+    engramId: string;
+    engramName: string;
+    sourcePath: string;
+    diff?: ClawPullDiff;
+}
+export declare class ClawPullEngramNotFoundError extends Error {
+    readonly engramId: string;
+    constructor(engramId: string);
+}
+export declare class ClawPullWorkspaceNotFoundError extends Error {
+    readonly path: string;
+    constructor(path: string);
+}
+export declare class ClawPullPersonaMissingError extends Error {
+    readonly path: string;
+    constructor(path: string);
+}
+export declare class ClawPull {
+    private readonly localRepo;
+    constructor(localRepo: EngramRepository);
+    /**
+     * Phase 1: read workspace + diff. Does not write anything yet.
+     *
+     * Returns an `apply` closure when there are changes to write.
+     */
+    check(agentName: string, options?: {
+        openclawDir?: string;
+    }): Promise<{
+        result: ClawPullResult;
+        apply?: () => Promise<void>;
+    }>;
+}

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

@@ -0,0 +1,117 @@
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { RELIC_FILE_MAP, resolveWorkspacePath } from "../../shared/openclaw.js";
+// ---------------------------------------------------------------------------
+// Errors
+// ---------------------------------------------------------------------------
+export class ClawPullEngramNotFoundError extends Error {
+    engramId;
+    constructor(engramId) {
+        super(`Engram "${engramId}" not found locally. Use "relic claw pull" to create or update it.`);
+        this.engramId = engramId;
+        this.name = "ClawPullEngramNotFoundError";
+    }
+}
+export class ClawPullWorkspaceNotFoundError extends Error {
+    path;
+    constructor(path) {
+        super(`Claw workspace not found at ${path}`);
+        this.path = path;
+        this.name = "ClawPullWorkspaceNotFoundError";
+    }
+}
+export class ClawPullPersonaMissingError extends Error {
+    path;
+    constructor(path) {
+        super(`No persona files (SOUL.md, IDENTITY.md) found in ${path}`);
+        this.path = path;
+        this.name = "ClawPullPersonaMissingError";
+    }
+}
+// ---------------------------------------------------------------------------
+// Usecase
+// ---------------------------------------------------------------------------
+export class ClawPull {
+    localRepo;
+    constructor(localRepo) {
+        this.localRepo = localRepo;
+    }
+    /**
+     * Phase 1: read workspace + diff. Does not write anything yet.
+     *
+     * Returns an `apply` closure when there are changes to write.
+     */
+    async check(agentName, options) {
+        const sourcePath = resolveWorkspacePath(agentName, options?.openclawDir);
+        if (!existsSync(sourcePath)) {
+            throw new ClawPullWorkspaceNotFoundError(sourcePath);
+        }
+        // 1. Local Engram must exist
+        const local = await this.localRepo.get(agentName);
+        if (!local) {
+            throw new ClawPullEngramNotFoundError(agentName);
+        }
+        // 2. Read persona files from workspace
+        const remoteSoul = await readOptionalFile(join(sourcePath, RELIC_FILE_MAP.soul));
+        const remoteIdentity = await readOptionalFile(join(sourcePath, RELIC_FILE_MAP.identity));
+        if (!remoteSoul && !remoteIdentity) {
+            throw new ClawPullPersonaMissingError(sourcePath);
+        }
+        // 3. Diff
+        const soulDiff = diffFile(local.files.soul, remoteSoul);
+        const identityDiff = diffFile(local.files.identity, remoteIdentity);
+        if (soulDiff !== "different" && identityDiff !== "different") {
+            return {
+                result: {
+                    outcome: "already_synced",
+                    engramId: agentName,
+                    engramName: local.meta.name,
+                    sourcePath,
+                },
+            };
+        }
+        const diff = {
+            soulDiff,
+            identityDiff,
+            sourcePath,
+            remoteSoul,
+            remoteIdentity,
+        };
+        // 4. Apply closure
+        const apply = async () => {
+            const fresh = await this.localRepo.get(agentName);
+            if (!fresh)
+                throw new ClawPullEngramNotFoundError(agentName);
+            const updatedFiles = { ...fresh.files };
+            if (soulDiff === "different" && remoteSoul)
+                updatedFiles.soul = remoteSoul;
+            if (identityDiff === "different" && remoteIdentity)
+                updatedFiles.identity = remoteIdentity;
+            await this.localRepo.save({
+                meta: { ...fresh.meta, updatedAt: new Date().toISOString() },
+                files: updatedFiles,
+            });
+        };
+        return { result: { outcome: "pulled", engramId: agentName, engramName: local.meta.name, sourcePath, diff }, apply };
+    }
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+async function readOptionalFile(filePath) {
+    if (!existsSync(filePath))
+        return undefined;
+    return readFile(filePath, "utf-8");
+}
+function diffFile(localContent, remoteContent) {
+    if (!remoteContent)
+        return "missing";
+    if (!localContent)
+        return "different";
+    return normalizeContent(localContent) === normalizeContent(remoteContent) ? "same" : "different";
+}
+/** Trim trailing whitespace so minor formatting differences don't cause false diffs. */
+function normalizeContent(content) {
+    return content.trimEnd();
+}

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

@@ -32,7 +32,6 @@ export declare class Extract {
     execute(agentName: string, options?: {
         name?: string;
         openclawDir?: string;
-        force?: boolean;
     }): Promise<ExtractResult>;
     private comparePersonaFile;
     private readFiles;

package/dist/core/usecases/extract.js

@@ -55,7 +55,7 @@ export class Extract {
             throw new WorkspaceNotFoundError(sourcePath);
         }
         const existing = await this.repository.get(agentName);
-        if (existing && !options?.force) {
+        if (existing) {
             throw new AlreadyExtractedError(agentName);
         }
         const { files, filesRead } = await this.readFiles(sourcePath);
@@ -63,31 +63,17 @@ export class Extract {
             throw new WorkspaceEmptyError(sourcePath);
         }
         const now = new Date().toISOString();
-        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,
-            };
+        const engram = {
+            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: agentName,
@@ -142,7 +128,7 @@ export class WorkspaceEmptyError extends Error {
 }
 export class AlreadyExtractedError extends Error {
     constructor(id) {
-        super(`Engram "${id}" already exists. Re-run with "--force" option to overwrite local persona files from the Claw workspace.`);
+        super(`Engram "${id}" already exists. Use "relic claw pull" to update it.`);
         this.name = "AlreadyExtractedError";
     }
 }

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

@@ -5,7 +5,15 @@ export { MigrateEngrams, type MigrateEngramsResult, } from "./migrate-engrams.js
 export { RefreshSamples, type RefreshSamplesResult, } from "./refresh-samples.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 { MemoryWrite, MemoryWriteEngramNotFoundError, type MemoryWriteBatchItem, type MemoryWriteResult, } from "./memory-write.js";
+export { ClawPull, ClawPullEngramNotFoundError, ClawPullWorkspaceNotFoundError, ClawPullPersonaMissingError, type ClawPullResult, type ClawPullDiff, } from "./claw-pull.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";
+export { ArchivePending, ArchiveCursorCorruptedError, ArchivePendingEngramNotFoundError, type ArchivePendingEntry, type ArchivePendingResult, } from "./archive-pending.js";
+export { ArchiveCursorUpdate, ArchiveCursorAdvanceOverflowError, ArchiveCursorUpdateEngramNotFoundError, type ArchiveCursorUpdateResult, } from "./archive-cursor-update.js";
+export { MikoshiStatus, MikoshiStatusEngramNotFoundError, MikoshiStatusCloudNotFoundError, type MikoshiStatusResult, } from "./mikoshi-status.js";
+export { MikoshiPush, MikoshiPushEngramNotFoundError, MikoshiPushPersonaHashError, MikoshiPushPersonaConflictError, type MikoshiPushResult, type MikoshiPushApplyResult, } from "./mikoshi-push.js";
+export { MikoshiDownload, MikoshiDownloadAlreadyExistsError, MikoshiDownloadCloudNotFoundError, MikoshiDownloadPersonaMissingError, type MikoshiDownloadResult, } from "./mikoshi-download.js";
+export { MikoshiPull, MikoshiPullEngramNotFoundError, MikoshiPullCloudNotFoundError, MikoshiPullPersonaMissingError, type MikoshiPullResult, type MikoshiPullDiff, } from "./mikoshi-pull.js";
+export { MikoshiMemoryPush, MikoshiMemoryPushEngramNotFoundError, MikoshiMemoryPushNoFilesError, MikoshiMemoryPushCloudNotFoundError, type MikoshiMemoryPushResult, } from "./mikoshi-memory-push.js";
+export { MikoshiMemoryPull, MikoshiMemoryPullEngramNotFoundError, MikoshiMemoryPullCloudNotFoundError, MikoshiMemoryPullDecryptError, type MikoshiMemoryPullResult, type MikoshiMemoryPullDiff, } from "./mikoshi-memory-pull.js";
+export { MikoshiMemorySync, MikoshiMemorySyncEngramNotFoundError, MikoshiMemorySyncCloudNotFoundError, MikoshiMemorySyncDecryptError, type MikoshiMemorySyncResult, } from "./mikoshi-memory-sync.js";

package/dist/core/usecases/index.js

@@ -6,6 +6,14 @@ export { RefreshSamples, } from "./refresh-samples.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 { ClawPull, ClawPullEngramNotFoundError, ClawPullWorkspaceNotFoundError, ClawPullPersonaMissingError, } from "./claw-pull.js";
 export { Sync, SyncOpenclawDirNotFoundError, } from "./sync.js";
-export { ArchivePending, ArchivePendingEngramNotFoundError, } from "./archive-pending.js";
-export { ArchiveCursorUpdate, ArchiveCursorUpdateEngramNotFoundError, } from "./archive-cursor-update.js";
+export { ArchivePending, ArchiveCursorCorruptedError, ArchivePendingEngramNotFoundError, } from "./archive-pending.js";
+export { ArchiveCursorUpdate, ArchiveCursorAdvanceOverflowError, ArchiveCursorUpdateEngramNotFoundError, } from "./archive-cursor-update.js";
+export { MikoshiStatus, MikoshiStatusEngramNotFoundError, MikoshiStatusCloudNotFoundError, } from "./mikoshi-status.js";
+export { MikoshiPush, MikoshiPushEngramNotFoundError, MikoshiPushPersonaHashError, MikoshiPushPersonaConflictError, } from "./mikoshi-push.js";
+export { MikoshiDownload, MikoshiDownloadAlreadyExistsError, MikoshiDownloadCloudNotFoundError, MikoshiDownloadPersonaMissingError, } from "./mikoshi-download.js";
+export { MikoshiPull, MikoshiPullEngramNotFoundError, MikoshiPullCloudNotFoundError, MikoshiPullPersonaMissingError, } from "./mikoshi-pull.js";
+export { MikoshiMemoryPush, MikoshiMemoryPushEngramNotFoundError, MikoshiMemoryPushNoFilesError, MikoshiMemoryPushCloudNotFoundError, } from "./mikoshi-memory-push.js";
+export { MikoshiMemoryPull, MikoshiMemoryPullEngramNotFoundError, MikoshiMemoryPullCloudNotFoundError, MikoshiMemoryPullDecryptError, } from "./mikoshi-memory-pull.js";
+export { MikoshiMemorySync, MikoshiMemorySyncEngramNotFoundError, MikoshiMemorySyncCloudNotFoundError, MikoshiMemorySyncDecryptError, } from "./mikoshi-memory-sync.js";

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

@@ -4,6 +4,7 @@ export interface InjectPersonaDiffResult {
     engramId: string;
     engramName: string;
     targetPath: string;
+    targetExists: boolean;
     soul: InjectPersonaFileDiff;
     identity: InjectPersonaFileDiff;
     overwriteRequired: boolean;

package/dist/core/usecases/inject.js

@@ -17,6 +17,7 @@ export class Inject {
     async inspectPersona(engramId, options) {
         const { engram, targetPath } = await this.loadInjectTarget(engramId, options);
         const mergeIdentity = options?.mergeIdentity ?? false;
+        const targetExists = existsSync(targetPath);
         const soul = await this.compareTargetFile(join(targetPath, INJECT_FILE_MAP.soul), this.resolveInjectedContent("soul", engram.files, mergeIdentity));
         const identity = mergeIdentity
             ? "skipped"
@@ -25,6 +26,7 @@ export class Inject {
             engramId: engram.meta.id,
             engramName: engram.meta.name,
             targetPath,
+            targetExists,
             soul,
             identity,
             overwriteRequired: soul === "different" || identity === "different",

package/dist/core/usecases/memory-write.d.ts

@@ -4,6 +4,10 @@ export interface MemoryWriteResult {
     appended: boolean;
     path: string;
 }
+export interface MemoryWriteBatchItem {
+    date: string;
+    content: string;
+}
 /**
  * MemoryWrite — Engramのメモリエントリに追記する
  *
@@ -14,6 +18,7 @@ export declare class MemoryWrite {
     private readonly engramsPath;
     constructor(engramsPath: string);
     execute(engramId: string, content: string, date?: string): Promise<MemoryWriteResult>;
+    executeBatch(engramId: string, writes: MemoryWriteBatchItem[]): Promise<MemoryWriteResult[]>;
 }
 export declare class MemoryWriteEngramNotFoundError extends Error {
     constructor(id: string);

package/dist/core/usecases/memory-write.js

@@ -14,29 +14,39 @@ export class MemoryWrite {
     }
     async execute(engramId, content, date) {
         const resolvedDate = date ?? new Date().toISOString().split("T")[0];
+        const [result] = await this.executeBatch(engramId, [
+            { date: resolvedDate, content },
+        ]);
+        return result;
+    }
+    async executeBatch(engramId, writes) {
         const engramDir = join(this.engramsPath, engramId);
         if (!existsSync(engramDir)) {
             throw new MemoryWriteEngramNotFoundError(engramId);
         }
         const memoryDir = join(engramDir, "memory");
         await mkdir(memoryDir, { recursive: true });
-        const filePath = join(memoryDir, `${resolvedDate}.md`);
-        let appended = false;
-        if (existsSync(filePath)) {
-            const existing = await readFile(filePath, "utf-8");
-            const separator = existing.endsWith("\n") ? "\n" : "\n\n";
-            await writeFile(filePath, existing + separator + content + "\n", "utf-8");
-            appended = true;
-        }
-        else {
-            await writeFile(filePath, content + "\n", "utf-8");
+        const results = [];
+        for (const write of writes) {
+            const filePath = join(memoryDir, `${write.date}.md`);
+            let appended = false;
+            if (existsSync(filePath)) {
+                const existing = await readFile(filePath, "utf-8");
+                const separator = existing.endsWith("\n") ? "\n" : "\n\n";
+                await writeFile(filePath, existing + separator + write.content + "\n", "utf-8");
+                appended = true;
+            }
+            else {
+                await writeFile(filePath, write.content + "\n", "utf-8");
+            }
+            results.push({
+                engramId,
+                date: write.date,
+                appended,
+                path: filePath,
+            });
         }
-        return {
-            engramId,
-            date: resolvedDate,
-            appended,
-            path: filePath,
-        };
+        return results;
     }
 }
 export class MemoryWriteEngramNotFoundError extends Error {

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

@@ -0,0 +1,29 @@
+import type { EngramRepository } from "../ports/engram-repository.js";
+import type { MikoshiClient } from "../ports/mikoshi.js";
+export interface MikoshiCloneResult {
+    engramId: string;
+    engramName: string;
+    cloudEngramId: string;
+}
+export declare class MikoshiCloneAlreadyExistsError extends Error {
+    readonly engramId: string;
+    constructor(engramId: string);
+}
+export declare class MikoshiCloneCloudNotFoundError extends Error {
+    readonly sourceEngramId: string;
+    constructor(sourceEngramId: string);
+}
+export declare class MikoshiClonePersonaMissingError extends Error {
+    readonly cloudEngramId: string;
+    constructor(cloudEngramId: string);
+}
+export declare class MikoshiClone {
+    private readonly localRepo;
+    private readonly mikoshi;
+    constructor(localRepo: EngramRepository, mikoshi: MikoshiClient);
+    /**
+     * Clone a remote Engram from Mikoshi to local.
+     * Fails if the local Engram already exists.
+     */
+    execute(engramId: string): Promise<MikoshiCloneResult>;
+}