@amoree-code/ocean 0.0.0-stage → 1.2.0

package/dist/application/clients/native.js

@@ -0,0 +1,410 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { isDeepStrictEqual } from "node:util";
+import { stagingDir } from "@ocean/brain/memory/memory-paths.js";
+import { defaultClientEnv, edit, newBatch, planClients, readJournal, } from "./clients.js";
+import { canonicalJson, ManualEdit } from "./editors.js";
+export const NATIVE_ADAPTERS = [
+    {
+        client: "claude-code",
+        kind: "json-set",
+        file: ".claude/settings.json",
+        key: ["autoMemoryDirectory"],
+        value: () => stagingDir("claude-code"),
+    },
+    {
+        client: "codex",
+        kind: "toml",
+        file: ".codex/config.toml",
+        section: "memories",
+        values: { generate_memories: false, use_memories: false },
+    },
+    {
+        client: "gemini",
+        kind: "json-add",
+        file: ".gemini/settings.json",
+        key: ["tools", "exclude"],
+        value: () => "save_memory",
+    },
+    {
+        client: "qwen",
+        kind: "json-add",
+        file: ".qwen/settings.json",
+        key: ["tools", "exclude"],
+        value: () => "save_memory",
+    },
+    {
+        client: "hermes",
+        kind: "yaml",
+        file: ".hermes/config.yaml",
+        section: "memory",
+        values: { memory_enabled: false, user_profile_enabled: false },
+    },
+    {
+        client: "claude-desktop",
+        kind: "capture",
+        text: "left on: the daily `ocean pull` proposes its memory and project instructions (also claude.ai) from Claude Desktop's and the browsers' caches for review",
+    },
+    {
+        client: "cursor",
+        kind: "uncaptured",
+        text: "left on: Cursor keeps its Memories in the app, where Ocean cannot read them; its chats are indexed by `ocean pull`",
+    },
+    {
+        client: "chatgpt",
+        kind: "capture",
+        text: "left on: the daily `ocean pull` proposes its memory and custom instructions from the browsers' chatgpt.com caches for review",
+    },
+    {
+        client: "antigravity",
+        kind: "harvest",
+        text: "no switch: `ocean memory harvest --source antigravity` turns its brain notes into candidates",
+    },
+];
+const hasSetting = (adapter) => "file" in adapter && adapter.kind !== "yaml";
+async function readText(file) {
+    try {
+        return await readFile(file, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return "";
+        throw error;
+    }
+}
+const settingLabel = (adapter, env) => adapter.kind === "toml"
+    ? `[${adapter.section}] ${Object.entries(adapter.values)
+        .map(([key, value]) => `${key} = ${value}`)
+        .join(", ")}`
+    : `${adapter.key.join(".")} ${adapter.kind === "json-add" ? "+=" : "="} ${JSON.stringify(adapter.value(env))}`;
+function nodeAt(root, key) {
+    let node = root;
+    for (const part of key)
+        node =
+            node && typeof node === "object" && !Array.isArray(node)
+                ? node[part]
+                : undefined;
+    return node;
+}
+function desiredJson(adapter, current, env) {
+    const value = adapter.value(env);
+    if (adapter.kind === "json-set")
+        return value;
+    const list = Array.isArray(current) ? current : [];
+    return list.includes(value) ? list : [...list, value];
+}
+// TOML: the managed keys inside one `[section]`, read and set line by line.
+const tomlLine = (key) => new RegExp(`^\\s*${key}\\s*=\\s*(\\S+)`);
+function tomlSection(lines, section) {
+    const start = lines.findIndex((line) => line.trim() === `[${section}]`);
+    if (start < 0)
+        return null;
+    let end = lines.length;
+    for (let index = start + 1; index < lines.length; index++)
+        if (/^\s*\[/.test(lines[index])) {
+            end = index;
+            break;
+        }
+    // The section ends at its last non-blank line: new keys go there, before any blank
+    // separator (or the file's final newline).
+    while (end - 1 > start && !lines[end - 1].trim())
+        end -= 1;
+    return { start, end };
+}
+function tomlValues(text, adapter) {
+    const lines = text.split("\n");
+    const range = tomlSection(lines, adapter.section);
+    const values = {};
+    for (const key of Object.keys(adapter.values)) {
+        const line = range
+            ? lines
+                .slice(range.start + 1, range.end)
+                .find((item) => tomlLine(key).test(item))
+            : undefined;
+        values[key] = line ? (tomlLine(key).exec(line)?.[1] ?? null) : null;
+    }
+    return { values, hasSection: Boolean(range) };
+}
+function setToml(text, section, values, dropEmptySection) {
+    const lines = text.split("\n");
+    let range = tomlSection(lines, section);
+    if (!range) {
+        const tail = lines.at(-1) === "" ? lines.length - 1 : lines.length;
+        const block = [
+            ...(tail && lines[tail - 1].trim() ? [""] : []),
+            `[${section}]`,
+        ];
+        lines.splice(tail, 0, ...block);
+        range = tomlSection(lines, section);
+    }
+    for (const [key, value] of Object.entries(values)) {
+        const at = lines.findIndex((line, index) => index > range.start && index < range.end && tomlLine(key).test(line));
+        if (value === null) {
+            if (at >= 0) {
+                lines.splice(at, 1);
+                range.end -= 1;
+            }
+        }
+        else if (at >= 0)
+            lines[at] = `${key} = ${value}`;
+        else {
+            lines.splice(range.end, 0, `${key} = ${value}`);
+            range.end += 1;
+        }
+    }
+    if (dropEmptySection) {
+        const body = lines.slice(range.start + 1, range.end);
+        if (body.every((line) => !line.trim())) {
+            const before = range.start > 0 && !lines[range.start - 1].trim() ? 1 : 0;
+            lines.splice(range.start - before, range.end - range.start + before);
+        }
+    }
+    return lines.join("\n");
+}
+function planOne(text, adapter, env) {
+    const plan = {
+        client: adapter.client,
+        status: "change",
+        file: `~/${adapter.file}`,
+        setting: settingLabel(adapter, env),
+    };
+    if (adapter.kind === "toml") {
+        const { values } = tomlValues(text, adapter);
+        const done = Object.entries(adapter.values).every(([key, value]) => values[key] === String(value));
+        return done ? { ...plan, status: "current" } : plan;
+    }
+    let root;
+    try {
+        root = JSON.parse(text.trim() ? text : "{}");
+    }
+    catch {
+        return { ...plan, status: "manual", reason: "the file is not valid JSON" };
+    }
+    const current = nodeAt(root, adapter.key);
+    if (isDeepStrictEqual(current, desiredJson(adapter, current, env)))
+        return { ...plan, status: "current" };
+    try {
+        canonicalJson(text);
+    }
+    catch (error) {
+        if (!(error instanceof ManualEdit))
+            throw error;
+        return { ...plan, status: "manual", reason: error.message };
+    }
+    return plan;
+}
+function yamlValues(text, section) {
+    const lines = text.split("\n");
+    const start = lines.findIndex((line) => line.trimEnd() === `${section}:`);
+    const values = {};
+    if (start < 0)
+        return values;
+    for (const line of lines.slice(start + 1)) {
+        if (!line.trim() || line.trimStart().startsWith("#"))
+            continue;
+        if (!/^\s/.test(line))
+            break;
+        const match = /^\s+([A-Za-z0-9_-]+):\s*([^\s#]+)/.exec(line);
+        if (match && !(match[1] in values))
+            values[match[1]] = match[2];
+    }
+    return values;
+}
+function planYaml(text, adapter) {
+    const values = yamlValues(text, adapter.section);
+    const done = Object.entries(adapter.values).every(([key, value]) => values[key] === String(value));
+    return {
+        client: adapter.client,
+        status: done ? "current" : "manual",
+        file: `~/${adapter.file}`,
+        setting: Object.entries(adapter.values)
+            .map(([key, value]) => `${adapter.section}.${key}: ${value}`)
+            .join(", "),
+        ...(done ? {} : { reason: "Ocean does not rewrite YAML; set it by hand" }),
+    };
+}
+export async function planNative(env = defaultClientEnv()) {
+    const installed = new Set((await planClients(env))
+        .filter((plan) => plan.installed)
+        .map((plan) => plan.client));
+    const plans = [];
+    for (const adapter of NATIVE_ADAPTERS) {
+        if (!installed.has(adapter.client))
+            continue;
+        if (adapter.kind === "yaml")
+            plans.push(planYaml(await readText(path.join(env.home, adapter.file)), adapter));
+        else if (!hasSetting(adapter))
+            plans.push({
+                client: adapter.client,
+                status: adapter.kind,
+                reason: adapter.text,
+            });
+        else
+            plans.push(planOne(await readText(path.join(env.home, adapter.file)), adapter, env));
+    }
+    return plans;
+}
+export async function applyNative(options = {}) {
+    const env = options.env ?? defaultClientEnv();
+    const batch = options.batch ?? newBatch();
+    const results = [];
+    for (const plan of await planNative(env)) {
+        if (plan.status !== "change")
+            continue;
+        if (options.clients && !options.clients.includes(plan.client))
+            continue;
+        const adapter = NATIVE_ADAPTERS.find((item) => item.client === plan.client);
+        if (!adapter || !hasSetting(adapter))
+            continue;
+        const result = await edit(path.join(env.home, adapter.file), (text) => {
+            if (planOne(text, adapter, env).status !== "change")
+                return null;
+            const entry = {
+                client: adapter.client,
+                file: adapter.file,
+                op: "native-set",
+                key: adapter.kind === "toml" ? adapter.section : adapter.key.join("."),
+            };
+            if (adapter.kind === "toml") {
+                const { values, hasSection } = tomlValues(text, adapter);
+                const after = Object.fromEntries(Object.entries(adapter.values).map(([key, value]) => [
+                    key,
+                    String(value),
+                ]));
+                return {
+                    next: setToml(text, adapter.section, after, false),
+                    entries: [
+                        {
+                            ...entry,
+                            before: values,
+                            after,
+                            created: hasSection ? [] : [adapter.section],
+                        },
+                    ],
+                };
+            }
+            const { parsed, render } = canonicalJson(text);
+            const before = nodeAt(parsed, adapter.key);
+            const after = desiredJson(adapter, before, env);
+            const created = [];
+            let node = parsed;
+            for (const part of adapter.key.slice(0, -1)) {
+                if (node[part] === undefined) {
+                    node[part] = {};
+                    created.push(part);
+                }
+                node = node[part];
+            }
+            node[adapter.key.at(-1)] = after;
+            return {
+                next: render(parsed),
+                entries: [
+                    {
+                        ...entry,
+                        before: before === undefined ? null : { value: before },
+                        after: { value: after },
+                        created,
+                    },
+                ],
+            };
+        }, batch);
+        results.push({ client: plan.client, result });
+    }
+    return { batch, results };
+}
+// Puts each setting one apply batch changed back to its value before, when it still holds what
+// Ocean wrote; otherwise it is a conflict and left alone.
+export async function restoreNative(options) {
+    const env = options.env ?? defaultClientEnv();
+    const entries = (await readJournal())
+        .filter((entry) => entry.batch === options.batch &&
+        entry.op === "native-set" &&
+        !entry.restoreOf)
+        .reverse();
+    const restored = [];
+    const conflicts = [];
+    const undo = newBatch();
+    for (const entry of entries) {
+        const adapter = NATIVE_ADAPTERS.find((item) => item.client === entry.client);
+        if (!adapter || !hasSetting(adapter))
+            continue;
+        const outcome = { restored: false };
+        await edit(path.join(env.home, entry.file), (text) => {
+            outcome.restored = false;
+            let next;
+            if (adapter.kind === "toml") {
+                const { values } = tomlValues(text, adapter);
+                if (!isDeepStrictEqual(values, entry.after))
+                    return null;
+                next = setToml(text, adapter.section, entry.before, Boolean(entry.created?.length));
+            }
+            else {
+                let document;
+                try {
+                    document = canonicalJson(text);
+                }
+                catch {
+                    return null;
+                }
+                const { parsed, render } = document;
+                if (!isDeepStrictEqual(nodeAt(parsed, adapter.key), entry.after?.value))
+                    return null;
+                const parents = [parsed];
+                for (const part of adapter.key.slice(0, -1))
+                    parents.push(parents.at(-1)?.[part]);
+                const leaf = parents.at(-1);
+                if (entry.before)
+                    leaf[adapter.key.at(-1)] = entry.before.value;
+                else
+                    delete leaf[adapter.key.at(-1)];
+                for (let depth = adapter.key.length - 2; depth >= 0; depth--) {
+                    const part = adapter.key[depth];
+                    if (entry.created?.includes(part) &&
+                        !Object.keys(parents[depth + 1]).length)
+                        delete parents[depth][part];
+                }
+                next = render(parsed);
+            }
+            outcome.restored = true;
+            return { next, entries: [{ ...entry, restoreOf: options.batch }] };
+        }, undo);
+        (outcome.restored ? restored : conflicts).push(`${entry.client}:native`);
+    }
+    return { restored, conflicts };
+}
+// Doctor view (§3.8): a switch Ocean can set but has not is a competing source (FAIL); a server
+// store `ocean pull` captures is governed (OK); one it cannot read, or a store with no switch
+// that is harvested by hand, is a WARN.
+export async function nativeFindings(env = defaultClientEnv()) {
+    return (await planNative(env)).map((plan) => {
+        const name = `${plan.client} native memory`;
+        if (plan.status === "current")
+            return {
+                code: "NATIVE_POLICY_SET",
+                severity: "OK",
+                message: `${name}: ${plan.setting} (confirm in the app that nothing new lands in its own store)`,
+                fixable: false,
+            };
+        if (plan.status === "change" || plan.status === "manual")
+            return {
+                code: "NATIVE_COMPETING",
+                severity: "FAIL",
+                message: `${name}: competing source — ${plan.status === "change" ? `run \`ocean clients apply --yes\` (${plan.setting} in ${plan.file})` : `hand edit: ${plan.setting} in ${plan.file} (${plan.reason})`}`,
+                fixable: plan.status === "change",
+            };
+        if (plan.status === "capture")
+            return {
+                code: "NATIVE_CAPTURED",
+                severity: "OK",
+                message: `${name}: ${plan.reason}`,
+                fixable: false,
+            };
+        return {
+            code: plan.status === "uncaptured" ? "NATIVE_UNCAPTURED" : "NATIVE_HARVEST",
+            severity: "WARN",
+            message: `${name}: ${plan.reason}`,
+            fixable: false,
+        };
+    });
+}
+//# sourceMappingURL=native.js.map

package/dist/application/clients/opencode-plugin.js

@@ -0,0 +1,158 @@
+import { createHash } from "node:crypto";
+import { readFile, unlink } from "node:fs/promises";
+import path from "node:path";
+import { appendJournal, defaultClientEnv, edit, newBatch, planClients, readJournal, temporaryEntryProblem, } from "./clients.js";
+// OpenCode has no shell hooks; its plugins do (T-307). Ocean owns one plugin file that, once per
+// OpenCode session, runs `ocean hook session-start --client opencode` and adds the bounded start
+// line to that session's system prompt (`experimental.chat.system.transform`, OpenCode 1.18).
+// OpenCode fires no event when a session ends (`session.deleted` is a deletion), so there is no
+// session-end hook. The file is Ocean's alone: written whole, journaled, removed on restore.
+export const OPENCODE_PLUGIN_FILE = ".config/opencode/plugins/ocean.js";
+const MARKER = "// Ocean session context for OpenCode";
+const sha = (text) => createHash("sha256").update(text).digest("hex");
+// The engine invocation the plugin spawns (no shell: argv words only).
+function invocation(env) {
+    const program = Array.isArray(env.entry.args)
+        ? String(env.entry.args[0])
+        : "";
+    return program === "mcp"
+        ? [String(env.entry.command)]
+        : [String(env.entry.command), program];
+}
+export function opencodePluginSource(env) {
+    return `${MARKER} (written by \`ocean clients apply\`; \`ocean clients restore\` removes it).
+import { spawn } from "node:child_process";
+
+const OCEAN = ${JSON.stringify(invocation(env))};
+const contexts = new Map();
+
+function startLine(sessionID, directory) {
+  return new Promise((resolve) => {
+    let out = "";
+    const child = spawn(OCEAN[0], [...OCEAN.slice(1), "hook", "session-start", "--client", "opencode"], {
+      stdio: ["pipe", "pipe", "ignore"],
+    });
+    const timer = setTimeout(() => child.kill(), 10000);
+    child.stdout.on("data", (chunk) => (out += chunk));
+    child.on("error", () => resolve(""));
+    child.on("close", () => {
+      clearTimeout(timer);
+      try {
+        resolve(JSON.parse(out).hookSpecificOutput?.additionalContext ?? "");
+      } catch {
+        resolve("");
+      }
+    });
+    child.stdin.end(JSON.stringify({ session_id: sessionID, cwd: directory ?? "" }));
+  });
+}
+
+export const OceanContext = async ({ directory }) => ({
+  "experimental.chat.system.transform": async (input, output) => {
+    const id = input?.sessionID;
+    if (!id || !Array.isArray(output?.system)) return;
+    if (!contexts.has(id)) contexts.set(id, startLine(id, directory));
+    const line = await contexts.get(id);
+    if (line) output.system.push(line);
+  },
+});
+`;
+}
+async function readIfPresent(file) {
+    try {
+        return await readFile(file, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+function planText(text, want) {
+    const plan = {
+        client: "opencode",
+        file: `~/${OPENCODE_PLUGIN_FILE}`,
+    };
+    if (text === want)
+        return { ...plan, status: "current" };
+    if (text === null || text.startsWith(MARKER))
+        return { ...plan, status: "change" };
+    return {
+        ...plan,
+        status: "manual",
+        reason: "a plugin Ocean did not write already has this name",
+    };
+}
+export async function planOpencodePlugin(env = defaultClientEnv()) {
+    const installed = (await planClients(env)).some((plan) => plan.client === "opencode" && plan.installed);
+    if (!installed)
+        return [];
+    const text = await readIfPresent(path.join(env.home, OPENCODE_PLUGIN_FILE));
+    return [planText(text, opencodePluginSource(env))];
+}
+export async function applyOpencodePlugin(options = {}) {
+    const env = options.env ?? defaultClientEnv();
+    const batch = options.batch ?? newBatch();
+    if (options.clients && !options.clients.includes("opencode"))
+        return { batch, results: [] };
+    if (options.durable ?? !options.env) {
+        const problem = temporaryEntryProblem(env.entry);
+        if (problem)
+            throw new Error(`Refusing to add the OpenCode plugin: ${problem}`);
+    }
+    const plans = await planOpencodePlugin(env);
+    if (plans[0]?.status !== "change")
+        return { batch, results: [] };
+    const want = opencodePluginSource(env);
+    const result = await edit(path.join(env.home, OPENCODE_PLUGIN_FILE), (text) => {
+        const current = text === "" ? null : text;
+        if (planText(current, want).status !== "change")
+            return null;
+        return {
+            next: want,
+            entries: [
+                {
+                    client: "opencode",
+                    file: OPENCODE_PLUGIN_FILE,
+                    op: "hook-add",
+                    key: "plugin",
+                    before: current === null ? null : { sha256: sha(current) },
+                    after: { sha256: sha(want) },
+                },
+            ],
+        };
+    }, batch);
+    return { batch, results: [{ client: "opencode", result }] };
+}
+// Removes the plugin one apply batch wrote, unless it changed since (a conflict, left alone).
+// A plugin that replaced an older Ocean plugin is removed too; the next apply writes it again.
+export async function restoreOpencodePlugin(options) {
+    const env = options.env ?? defaultClientEnv();
+    const entries = (await readJournal()).filter((entry) => entry.batch === options.batch &&
+        entry.client === "opencode" &&
+        entry.key === "plugin" &&
+        !entry.restoreOf);
+    const restored = [];
+    const conflicts = [];
+    for (const entry of entries) {
+        const file = path.join(env.home, entry.file);
+        const text = await readIfPresent(file);
+        const after = entry.after?.sha256;
+        if (text === null || sha(text) !== after) {
+            conflicts.push("opencode:plugin");
+            continue;
+        }
+        await unlink(file);
+        await appendJournal([
+            {
+                ...entry,
+                batch: newBatch(),
+                ts: new Date().toISOString(),
+                restoreOf: options.batch,
+            },
+        ]);
+        restored.push("opencode:plugin");
+    }
+    return { restored, conflicts };
+}
+//# sourceMappingURL=opencode-plugin.js.map