@oharness/engine 0.5.0 → 0.6.0

package/dist/runtime-plugins/builtin/memory-migrate.js

@@ -0,0 +1,141 @@
+import { constants } from "node:fs";
+import { copyFile, lstat, mkdir, readdir, stat, writeFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { readPluginFile, readUserFile, updateRuntimePluginConfig, writeUserFile } from "../../config-files.js";
+import { userPath } from "../../paths.js";
+import { projectId } from "../../storage/project.js";
+/**
+ * Where memory lives, and moving it there from where it used to.
+ *
+ * Notes used to sit in `<project>/.oharness/memory`, inside the repository
+ * tree: one copy per clone and per worktree, one `git add .` away from being
+ * committed for everyone, and gone with the folder. They now sit under the
+ * user directory, keyed by the same project id that sessions and cloud sync
+ * already use, so every clone of a repository shares one set.
+ */
+/** Written into a project's notes directory once its old notes have been considered. */
+export const LEGACY_MARKER = ".imported-legacy.json";
+export function legacyMemoryDirectory(cwd) {
+    return path.join(cwd, ".oharness", "memory");
+}
+export async function resolveMemoryDirectories(options) {
+    const legacy = legacyMemoryDirectory(options.cwd);
+    let user = userPath("memory", "user");
+    try {
+        await mkdir(user, { recursive: true });
+    }
+    catch (error) {
+        options.logger?.warn("User-level memory unavailable: the user directory is not writable", { error: String(error) });
+        user = undefined;
+    }
+    if (options.configured) {
+        return { project: path.resolve(options.cwd, options.configured), ...(user ? { user } : {}), migrated: 0 };
+    }
+    const target = userPath("memory", "projects", await projectId(options.cwd));
+    try {
+        await mkdir(target, { recursive: true });
+    }
+    catch (error) {
+        // A container whose home is a read-only layer still has a project volume.
+        options.logger?.warn("Memory stays in the project folder: the user directory is not writable", { error: String(error) });
+        return { project: legacy, ...(user ? { user } : {}), migrated: 0 };
+    }
+    let migrated = 0;
+    try {
+        migrated = await importLegacyMemory(legacy, target);
+        if (migrated)
+            options.logger?.info("Moved memory notes into the user directory", { count: migrated, from: legacy, to: target });
+    }
+    catch (error) {
+        options.logger?.warn("Could not import memory notes from the project folder", { error: String(error) });
+    }
+    return { project: target, ...(user ? { user } : {}), migrated };
+}
+/**
+ * Copy notes from the old directory into the new one, once.
+ *
+ * Only into an empty directory: merging two sets of notes is sync's job, with
+ * its conflict handling, not a startup step's. The marker makes it once — a
+ * note someone later deletes in the new place must not return from the old
+ * one on the next launch. The old directory is left untouched.
+ */
+export async function importLegacyMemory(legacy, target) {
+    const marker = path.join(target, LEGACY_MARKER);
+    if (await exists(marker))
+        return 0;
+    let names;
+    try {
+        if ((await lstat(legacy)).isSymbolicLink())
+            return 0;
+        names = (await readdir(legacy)).filter((name) => name.endsWith(".md"));
+    }
+    catch {
+        return 0;
+    }
+    if (!names.length)
+        return 0;
+    const existing = (await readdir(target)).filter((name) => name.endsWith(".md"));
+    if (existing.length) {
+        await writeFile(marker, JSON.stringify({ from: legacy, skipped: "target already had notes", at: Date.now() }) + "\n");
+        return 0;
+    }
+    let copied = 0;
+    for (const name of names) {
+        const from = path.join(legacy, name);
+        const info = await lstat(from);
+        if (info.isSymbolicLink() || !info.isFile())
+            continue;
+        try {
+            await copyFile(from, path.join(target, name), constants.COPYFILE_EXCL);
+            copied++;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+        }
+    }
+    await carrySyncSettings(legacy, target);
+    await writeFile(marker, JSON.stringify({ from: legacy, copied, at: Date.now() }) + "\n");
+    return copied;
+}
+const digest = (value) => createHash("sha256").update(value).digest("hex");
+const object = (x) => !!x && typeof x === "object" && !Array.isArray(x);
+/**
+ * Sync consent is keyed by directory. Without carrying it, a person who had
+ * switched cloud sync off for the old directory would find it silently on for
+ * the new one — the one outcome of a migration that cannot be undone, since
+ * an upload cannot be recalled. The baseline goes with it, so the first sync
+ * afterwards reconciles rather than treating every note as new.
+ */
+async function carrySyncSettings(legacy, target) {
+    const from = digest(path.resolve(legacy));
+    const to = digest(path.resolve(target));
+    const config = readPluginFile()?.runtimePlugins?.find((plugin) => plugin.id === "memory")?.config;
+    const consent = object(config) && object(config.syncTargets) ? config.syncTargets[from] : undefined;
+    if (!object(consent))
+        return;
+    await updateRuntimePluginConfig("memory", (current) => {
+        const targets = object(current.syncTargets) ? current.syncTargets : {};
+        if (targets[to])
+            return current;
+        return { ...current, syncTargets: { ...targets, [to]: consent } };
+    });
+    if (typeof consent.userId === "string" && consent.userId && typeof consent.origin === "string") {
+        const oldState = `memory-sync/${digest(`${consent.origin}:${consent.userId}:${from}`)}.json`;
+        const newState = `memory-sync/${digest(`${consent.origin}:${consent.userId}:${to}`)}.json`;
+        const state = readUserFile(oldState);
+        if (state && !readUserFile(newState))
+            await writeUserFile(newState, state);
+    }
+}
+async function exists(file) {
+    try {
+        await stat(file);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=memory-migrate.js.map

package/dist/runtime-plugins/builtin/memory-migrate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-migrate.js","sourceRoot":"","sources":["../../../src/runtime-plugins/builtin/memory-migrate.ts"],"names":[],"mappings":"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"}

package/dist/runtime-plugins/builtin/memory.d.ts

@@ -1,19 +1,64 @@
 import { MemoryStore } from "../../agent/memory.ts";
-import type { MemoryNote } from "../../agent/memory.ts";
+import type { MemoryNote, MemoryStores } from "../../agent/memory.ts";
+import type { MemoryPolicy, MemoryScope } from "../../agent/memory-limits.ts";
+import type { BackupReason } from "../../agent/memory-backup.ts";
+import type { MemoryFailureInfo } from "../../agent/memory-errors.ts";
+import type { MergeField } from "../../agent/memory-merge.ts";
+import type { ExtractedNote, ExtractionResult } from "../../agent/memory-provider.ts";
 import type { RuntimePlugin } from "../types.ts";
+import { MemorySyncCoordinator } from "./memory-coordinator.ts";
 type Identity = {
     userId: string;
     origin: string;
 };
+/** What the sync server says it will accept, for this account. Announced by the server; never assumed here. */
+export interface SyncQuota {
+    maxNotes?: number;
+    maxChanges?: number;
+    maxNoteBytes?: number;
+    tombstoneDays?: number;
+    tier?: "free" | "paid";
+}
+type NoteRef = {
+    id: string;
+    summary: string;
+};
+/** What the last pass that brought anything down brought down, and which notes it merged on its own. */
+export interface PullSummary {
+    at: number;
+    created: NoteRef[];
+    updated: NoteRef[];
+    deleted: NoteRef[];
+    merged?: NoteRef[];
+}
 interface Options {
     cwd: string;
     directory: string;
+    /** Which notes this service holds. User-level notes belong to no project. */
+    scope?: MemoryScope;
+    policy?: MemoryPolicy;
+    onWarning?(message: string): void;
     identity(): Promise<Identity | undefined>;
     token(): Promise<string | undefined>;
     /** Same destination as session sync. The Cloud identity origin remains the consent pin. */
     syncUrl?(): string;
     fetch?: typeof fetch;
+    /** Background check interval while the directory is busy. Defaults to a minute. */
     pollMs?: number;
+    /** Longest a quiet directory waits between checks. Defaults to five times `pollMs`. */
+    maxPollMs?: number;
+    /** Delay between a local write and the pass that uploads it. */
+    debounceMs?: number;
+    /** A project directory unused for this long is not checked in the background. */
+    activeWindowMs?: number;
+    /** Defaults to the process's shared coordinator. */
+    coordinator?: MemorySyncCoordinator;
+}
+export interface MemoryPluginOptions extends Omit<Options, "scope"> {
+    /** User-level notes directory. Omitted when it could not be created. */
+    userDirectory?: string;
+    /** One reply from the small model, for merge proposals. Without it merges are drafted by hand. */
+    generate?(system: string, prompt: string, signal?: AbortSignal): Promise<string>;
 }
 type Conflict = {
     id: string;
@@ -21,50 +66,144 @@ type Conflict = {
     cloud: MemoryNote | null;
     localHash: string | null;
     cloudHash: string | null;
+    /** The version both sides started from, when this machine kept a copy of it. */
+    base: MemoryNote | null;
+    /** What both sides changed in ways that could not be combined. */
+    fields: MergeField[];
 };
-/** One project's local notes and explicit per-device/account sync consent. */
+/** One scope's local notes and explicit per-device/account sync consent. */
 export declare class MemoryService {
     readonly store: MemoryStore;
+    readonly scope: MemoryScope;
     private readonly options;
     private readonly target;
+    private readonly coordinator;
+    private readonly syncTarget;
+    private detach?;
     private controller?;
-    private timer?;
     private running?;
     private closed;
     private disabling;
     private conflicts;
     private error?;
     private lastSync?;
+    private lastPull?;
+    private lastChanged;
     private binding?;
     private settingsRevision;
     private retryAt;
     private snapshotCache?;
+    private quota?;
+    /** The server predates `have`, so every snapshot carries every note. */
+    private legacyServer;
     constructor(options: Options);
+    get isClosed(): boolean;
     private consent;
     private stateFile;
     private allowed;
+    private eligible;
+    /**
+     * Hand this directory to the coordinator. It is checked straight away, then
+     * as the coordinator decides; a local write brings the next check forward.
+     * Calling it again does nothing.
+     */
     start(): void;
+    /** These notes are in use: check the cloud soon, if it has been a while. */
+    activity(): void;
     status(): Promise<{
+        lastPull?: PullSummary | undefined;
+        quota?: SyncQuota | undefined;
+        scope: "user" | "project";
         signedIn: boolean;
         enabled: boolean;
         ready: boolean;
         syncing: boolean;
         lastSync: number | undefined;
         error: string | undefined;
+        failure: MemoryFailureInfo | undefined;
         accountChanged: boolean;
         conflicts: Conflict[];
         location: string;
         entries: (MemoryNote & {
             hash: string | null;
         })[];
+        omitted: number;
     }>;
     enable(enabled: boolean): Promise<void>;
     sync(): Promise<void>;
+    /**
+     * One reconciliation. Resolves with whether anything went up or came down.
+     *
+     * A note both sides changed since the last sync is merged field by field
+     * when the changes do not touch (memory-merge.ts), and held back as a
+     * conflict only when they do. A held note stops nothing else: every other
+     * note still goes up and comes down, and the held one keeps its baseline
+     * until someone chooses.
+     */
     private perform;
-    resolve(id: string, choice: string): Promise<void>;
+    /** Where copies of notes at their baseline are kept, beside the baseline file. */
+    private baseDir;
+    /** The last synced version of a note, only when it is exactly the one the baseline records. */
+    private readBase;
+    private writeBaseNote;
+    /** Keep the baseline copies in step with the baseline hashes, writing only what moved. */
+    private writeBases;
+    /**
+     * Write a batch cloud first, for changes made without anyone reviewing each
+     * note (consolidation).
+     *
+     * Every note in the batch must be fully in sync, the same here, in the cloud
+     * and in the baseline, or the batch is refused before anything is written.
+     * The commit carries the manifest version those checks read, so a change
+     * from another device in between is refused by the server rather than
+     * becoming a conflict. Only once the cloud has accepted the batch is it
+     * written here. It needs the network; there is no offline fallback.
+     */
+    commitFirst(edits: ReadonlyArray<{
+        id: string;
+        note?: MemoryNote;
+        expectedHash: string | null;
+    }>, reason: BackupReason): Promise<void>;
+    /**
+     * Whether changes here should go through the cloud first: sync is on and
+     * bound to the account signed in now. Otherwise they are ordinary local
+     * edits that a later sync uploads.
+     */
+    syncReady(): Promise<boolean>;
+    /** The plan the sync service last announced for this account, if any. */
+    get tier(): SyncQuota["tier"];
+    /** Largest note body this machine and the sync service will both accept. */
+    noteBytesLimit(): number;
+    /** Changes grouped to fit the server's announced change quota and a request size its body limit accepts. */
+    private batches;
+    private snapshot;
+    private commit;
+    /** A request carrying `have`, retried without it once against a server that predates the field. */
+    private call;
+    /**
+     * Settle a conflict. Whatever is set aside is backed up first, whichever side
+     * it came from, and the baseline moves to the cloud's version so the next
+     * sync uploads the outcome.
+     *
+     * `local` keeps this machine's version. `cloud` takes the cloud's. `both`
+     * keeps this machine's version under the note's id and the cloud's as a new
+     * note beside it. `manual` saves `merged`, written by a person from all three.
+     */
+    resolve(id: string, choice: string, merged?: Record<string, unknown>): Promise<void>;
+    private readQuota;
     private validateSnapshot;
     private request;
     close(): Promise<void>;
 }
-export declare function createMemoryPlugin(options: Options, onReady: (service: MemoryService) => void): RuntimePlugin;
+export declare function acquireMemoryService(options: Options): {
+    service: MemoryService;
+    release(): Promise<void>;
+};
+/**
+ * Write what an extraction pass proposed. New notes first, so every
+ * `[[new:N]]` placeholder has an id to become; then the notes that used a
+ * placeholder are rewritten with it.
+ */
+export declare function commitExtracted(stores: MemoryStores, notes: readonly ExtractedNote[]): Promise<ExtractionResult>;
+export declare function createMemoryPlugin(options: MemoryPluginOptions, onReady: (service: MemoryService, user?: MemoryService) => void): RuntimePlugin;
 export {};