@amoree-code/ocean 0.0.0-stage → 1.1.0

package/dist/application/pull/history-index.js

@@ -0,0 +1,476 @@
+import { createReadStream } from "node:fs";
+import { copyFile, mkdir, mkdtemp, open, readdir, readFile, rm, stat, } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { fileURLToPath } from "node:url";
+import zlib from "node:zlib";
+import { redactSecrets } from "@ocean/core/domain/redaction/redaction.js";
+import { atomicWrite } from "@ocean/core/shared/fs-utils.js";
+import { oceanPath, SYSTEM_DIR } from "@ocean/core/shared/paths.js";
+import { loadProjectIndex, placeFolder } from "./project-match.js";
+const HEAD_BYTES = 64 * 1024;
+const TITLE_CHARS = 120;
+export const historyIndexFile = () => oceanPath(SYSTEM_DIR, "state", "history", "sessions.jsonl");
+function title(text) {
+    if (typeof text !== "string")
+        return "";
+    return redactSecrets(text.replace(/\s+/g, " ").trim()).slice(0, TITLE_CHARS);
+}
+// The texts of a chat message's content: a string, or the text parts of a list.
+function contentTexts(content) {
+    if (typeof content === "string")
+        return [content];
+    if (!Array.isArray(content))
+        return [];
+    return content.flatMap((part) => part && typeof part === "object" && typeof part.text === "string"
+        ? [part.text]
+        : []);
+}
+// What the owner asked: the first message text left once injected context (leading
+// `<tag>…</tag>` blocks: environment, opened file, reminders, command echoes) is taken off.
+const LEADING_BLOCK = /^\s*<([A-Za-z][\w-]*)[^>]*>[\s\S]*?<\/\1>/;
+function firstPrompt(contents) {
+    for (const content of contents)
+        for (let text of contentTexts(content)) {
+            while (LEADING_BLOCK.test(text))
+                text = text.replace(LEADING_BLOCK, "");
+            if (text.trim() && !/^\s*(<|# AGENTS\.md|Caveat:)/.test(text))
+                return text;
+        }
+    return undefined;
+}
+// Codex compresses older sessions (`.jsonl.zst`); zstd is in node:zlib from Node 22.15. Without
+// it such a file is still indexed, untitled.
+const zstd = zlib
+    .createZstdDecompress;
+async function zstdHead(file, bytes) {
+    if (!zstd)
+        return [];
+    const chunks = [];
+    let size = 0;
+    const source = createReadStream(file);
+    const stream = source.pipe(zstd());
+    try {
+        for await (const chunk of stream) {
+            chunks.push(chunk);
+            size += chunk.length;
+            if (size >= bytes)
+                break;
+        }
+    }
+    finally {
+        source.destroy();
+        stream.destroy();
+    }
+    const lines = Buffer.concat(chunks)
+        .subarray(0, bytes)
+        .toString("utf8")
+        .split("\n");
+    return size >= bytes ? lines.slice(0, -1) : lines;
+}
+async function head(file, bytes = HEAD_BYTES) {
+    if (file.endsWith(".zst"))
+        return zstdHead(file, bytes);
+    const handle = await open(file, "r");
+    try {
+        const buffer = Buffer.alloc(bytes);
+        const { bytesRead } = await handle.read(buffer, 0, bytes, 0);
+        const lines = buffer.subarray(0, bytesRead).toString("utf8").split("\n");
+        // The last line may be cut off mid-record.
+        return bytesRead === bytes ? lines.slice(0, -1) : lines;
+    }
+    finally {
+        await handle.close();
+    }
+}
+// The end of a long transcript, where titles set later in the session are appended.
+async function tail(file) {
+    const handle = await open(file, "r");
+    try {
+        const { size } = await handle.stat();
+        if (size <= HEAD_BYTES)
+            return [];
+        const buffer = Buffer.alloc(HEAD_BYTES);
+        const { bytesRead } = await handle.read(buffer, 0, HEAD_BYTES, size - HEAD_BYTES);
+        // The first line may start mid-record.
+        return buffer.subarray(0, bytesRead).toString("utf8").split("\n").slice(1);
+    }
+    finally {
+        await handle.close();
+    }
+}
+function records(lines) {
+    const out = [];
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        try {
+            const value = JSON.parse(line);
+            if (value && typeof value === "object")
+                out.push(value);
+        }
+        catch {
+            // a partial or foreign line
+        }
+    }
+    return out;
+}
+async function filesUnder(directory, match, depth) {
+    const entries = await readdir(directory, { withFileTypes: true }).catch(() => []);
+    const found = [];
+    for (const entry of entries) {
+        const target = path.join(directory, entry.name);
+        if (entry.isFile() && match(entry.name))
+            found.push(target);
+        else if (depth > 0 && entry.isDirectory() && !entry.name.startsWith("."))
+            found.push(...(await filesUnder(target, match, depth - 1)));
+    }
+    return found;
+}
+const at = (value) => {
+    const time = typeof value === "number" ? value : Date.parse(String(value ?? ""));
+    return Number.isFinite(time) ? new Date(time).toISOString() : undefined;
+};
+const object = (value) => value && typeof value === "object" ? value : {};
+const readers = [
+    {
+        client: "claude-code",
+        files: (home) => filesUnder(path.join(home, ".claude", "projects"), (name) => name.endsWith(".jsonl"), 1),
+        async parse(file) {
+            const lines = records(await head(file));
+            const end = records(await tail(file));
+            // The title the owner set, then Claude Code's own, then the first prompt.
+            const named = (type, key) => [...lines, ...end].reverse().find((line) => line.type === type)?.[key];
+            const prompt = firstPrompt(lines
+                .filter((line) => line.type === "user" && !line.isMeta)
+                .map((line) => object(line.message).content));
+            return {
+                cwd: lines.find((line) => typeof line.cwd === "string")?.cwd,
+                title: title(named("custom-title", "customTitle") ??
+                    named("ai-title", "aiTitle") ??
+                    named("summary", "summary") ??
+                    prompt),
+            };
+        },
+    },
+    {
+        client: "codex",
+        files: (home) => filesUnder(path.join(home, ".codex", "sessions"), (name) => name.startsWith("rollout-") && /\.jsonl(\.zst)?$/.test(name), 4),
+        async parse(file) {
+            // The first prompt follows tens of kilobytes of instructions and injected context.
+            const lines = records(await head(file, 4 * HEAD_BYTES));
+            const meta = object(lines.find((line) => line.type === "session_meta")?.payload);
+            const prompt = firstPrompt(lines
+                .map((line) => object(line.payload))
+                .filter((item) => item.type === "message" && item.role === "user")
+                .map((item) => item.content));
+            return {
+                id: typeof meta.id === "string" ? meta.id : undefined,
+                cwd: typeof meta.cwd === "string" ? meta.cwd : undefined,
+                title: title(prompt),
+            };
+        },
+    },
+    {
+        // Codex's own one-page summary of each past session.
+        client: "codex-summary",
+        files: (home) => filesUnder(path.join(home, ".codex", "memories", "rollout_summaries"), (name) => name.endsWith(".md"), 0),
+        async parse(file) {
+            const slug = path
+                .basename(file, ".md")
+                .replace(/^\d{4}-\d\d-\d\dT[\d-]+-[^-]+-/, "");
+            return { title: title(slug.replace(/_/g, " ")) };
+        },
+    },
+    {
+        client: "gemini",
+        files: (home) => filesUnder(path.join(home, ".gemini", "tmp"), (name) => name.startsWith("session") && name.endsWith(".jsonl"), 2),
+        async parse(file) {
+            // One `$set` line can hold every message so far: read the whole file, within a bound.
+            const lines = records(await head(file, 32 * HEAD_BYTES));
+            const first = lines[0] ?? {};
+            const root = await readFile(path.join(path.dirname(path.dirname(file)), ".project_root"), "utf8").catch(() => "");
+            // Messages are lines of their own, or batched under `$set.messages`.
+            const messages = lines.flatMap((line) => {
+                const batch = object(line.$set).messages;
+                return Array.isArray(batch) ? batch.map(object) : [line];
+            });
+            const prompt = firstPrompt(messages
+                .filter((message) => message.type === "user")
+                .map((message) => message.content));
+            return {
+                id: typeof first.sessionId === "string" ? first.sessionId : undefined,
+                cwd: root.trim() || undefined,
+                updated: at(first.lastUpdated),
+                title: title(prompt),
+            };
+        },
+    },
+    {
+        client: "cursor",
+        files: (home) => filesUnder(path.join(home, ".cursor", "chats"), (name) => name === "meta.json", 2),
+        async parse(file) {
+            const meta = object(JSON.parse(await readFile(file, "utf8")));
+            return {
+                id: path.basename(path.dirname(file)),
+                cwd: typeof meta.cwd === "string" ? meta.cwd : undefined,
+                updated: at(meta.updatedAtMs),
+                title: title(meta.title),
+            };
+        },
+    },
+    {
+        // Claude Desktop's Code sessions; their transcripts are Claude Code's, under ~/.claude.
+        client: "claude-desktop",
+        files: (home) => filesUnder(path.join(home, "Library", "Application Support", "Claude", "claude-code-sessions"), (name) => name.startsWith("local_") && name.endsWith(".json"), 2),
+        async parse(file) {
+            const session = object(JSON.parse(await readFile(file, "utf8")));
+            return {
+                id: typeof session.sessionId === "string" ? session.sessionId : undefined,
+                cwd: typeof session.cwd === "string" ? session.cwd : undefined,
+                updated: at(session.lastActivityAt),
+                title: title(session.title),
+                cliSession: typeof session.cliSessionId === "string"
+                    ? session.cliSessionId
+                    : undefined,
+            };
+        },
+    },
+];
+// Antigravity lists its conversations in one SQLite file (the transcripts are protobuf). It is
+// read from a private copy: the app keeps it open, and reading in place may need to write its
+// lock files.
+async function antigravityEntries(home) {
+    const folder = path.join(home, ".gemini", "antigravity");
+    const file = path.join(folder, "conversation_summaries.db");
+    if (!(await stat(file).catch(() => null)))
+        return [];
+    const scratch = await mkdtemp(path.join(os.tmpdir(), "ocean-agy-"));
+    let db;
+    try {
+        for (const suffix of ["", "-wal", "-shm"])
+            await copyFile(`${file}${suffix}`, path.join(scratch, `summaries.db${suffix}`)).catch(() => undefined);
+        db = new DatabaseSync(path.join(scratch, "summaries.db"), {
+            readOnly: true,
+        });
+        const rows = db
+            .prepare("select conversation_id, title, preview, last_modified_time, workspace_uris from conversation_summaries")
+            .all();
+        const transcripts = new Set(await readdir(path.join(folder, "conversations")).catch(() => []));
+        return rows.map((row) => {
+            const id = String(row.conversation_id);
+            let cwd;
+            try {
+                const uri = JSON.parse(String(row.workspace_uris || "[]"))[0];
+                cwd = uri?.startsWith("file:") ? fileURLToPath(uri) : undefined;
+            }
+            catch {
+                // no workspace recorded
+            }
+            const transcript = [`${id}.pb`, `${id}.db`].find((name) => transcripts.has(name));
+            return {
+                id,
+                file: transcript
+                    ? path.join(folder, "conversations", transcript)
+                    : `${file}#${id}`,
+                cwd,
+                updated: at(String(row.last_modified_time ?? "").replace(" ", "T")),
+                title: title(String(row.title || row.preview || "")),
+                version: String(row.last_modified_time),
+            };
+        });
+    }
+    catch {
+        // another schema: nothing indexed this time
+        return [];
+    }
+    finally {
+        db?.close();
+        await rm(scratch, { recursive: true, force: true });
+    }
+}
+// OpenCode keeps its sessions in one SQLite file; each row is a conversation.
+async function openCodeEntries(home) {
+    const file = path.join(home, ".local", "share", "opencode", "opencode.db");
+    if (!(await stat(file).catch(() => null)))
+        return [];
+    let db;
+    try {
+        db = new DatabaseSync(file, { readOnly: true });
+        const rows = db
+            .prepare("select id, title, directory, time_updated from session")
+            .all();
+        return rows.map((row) => ({
+            id: String(row.id),
+            file: `${file}#${String(row.id)}`,
+            cwd: typeof row.directory === "string" ? row.directory : undefined,
+            updated: at(row.time_updated),
+            title: title(row.title),
+            version: String(row.time_updated),
+        }));
+    }
+    catch {
+        // another schema or a locked file: nothing indexed this time
+        return [];
+    }
+    finally {
+        db?.close();
+    }
+}
+// Conversations that live only on a provider's servers (claude.ai, ChatGPT) have no local file.
+// A capture writes one snapshot per client, `<system>/state/history/server/<client>.jsonl`, one
+// line per conversation: {id, title, url, updated, project?, tags?}. The index keeps the link.
+export const serverHistoryDir = () => oceanPath(SYSTEM_DIR, "state", "history", "server");
+async function serverEntries() {
+    const directory = serverHistoryDir();
+    const names = await readdir(directory).catch(() => []);
+    const rows = [];
+    for (const name of names.filter((name) => name.endsWith(".jsonl"))) {
+        const text = await readFile(path.join(directory, name), "utf8").catch(() => "");
+        for (const row of records(text.split("\n"))) {
+            if (typeof row.id !== "string" || typeof row.url !== "string")
+                continue;
+            const updated = at(row.updated);
+            rows.push({
+                client: name.slice(0, -".jsonl".length),
+                id: row.id,
+                file: row.url,
+                updated,
+                title: title(row.title),
+                project: typeof row.project === "string" ? row.project : undefined,
+                tags: Array.isArray(row.tags)
+                    ? row.tags.filter((tag) => typeof tag === "string")
+                    : undefined,
+                version: updated ?? "",
+            });
+        }
+    }
+    return rows;
+}
+async function readIndex() {
+    const text = await readFile(historyIndexFile(), "utf8").catch(() => "");
+    return records(text.split("\n"));
+}
+// Rebuilds the index; a transcript whose size and time are unchanged is not read again, so a
+// daily run reads only what is new. Projects are matched afresh every time: a folder bound since
+// the last run moves its conversations.
+export async function buildHistoryIndex(options = {}) {
+    const home = options.home ?? os.homedir();
+    const shown = (file) => file.startsWith(home) ? `~${file.slice(home.length)}` : file;
+    const previous = new Map((await readIndex()).map((entry) => [entry.file, entry]));
+    const projects = await loadProjectIndex(home);
+    const pulledAt = new Date().toISOString();
+    const entries = [];
+    const add = (client, file, parsed, fallback) => {
+        const place = placeFolder(projects, parsed.cwd);
+        const known = previous.get(file);
+        const updated = parsed.updated ?? fallback.updated;
+        const tags = parsed.tags ?? place.tags;
+        entries.push({
+            client,
+            project: parsed.project ?? place.project ?? "unassigned",
+            ...(tags?.length ? { tags } : {}),
+            pull: true,
+            date: updated.slice(0, 10),
+            title: parsed.title ?? "",
+            file,
+            ...(place.cwd ? { cwd: place.cwd } : {}),
+            id: parsed.id ??
+                path.basename(file).replace(/\.jsonl(\.zst)?$|\.[^.]+$/, ""),
+            updated,
+            // First seen, kept across runs.
+            pulled_at: known?.pulled_at ?? pulledAt,
+            bytes: fallback.bytes,
+            ...(parsed.cliSession ? { cliSession: parsed.cliSession } : {}),
+            version: fallback.version,
+        });
+    };
+    for (const reader of readers)
+        for (const file of await reader.files(home)) {
+            const info = await stat(file).catch(() => null);
+            if (!info)
+                continue;
+            const version = `${info.size}:${info.mtimeMs}`;
+            const known = previous.get(shown(file));
+            const parsed = known?.client === reader.client && known.version === version
+                ? {
+                    id: known.id,
+                    cwd: known.cwd,
+                    updated: known.updated,
+                    title: known.title,
+                    cliSession: known.cliSession,
+                }
+                : await reader.parse(file).catch(() => ({}));
+            add(reader.client, shown(file), parsed, {
+                updated: info.mtime.toISOString(),
+                bytes: info.size,
+                version,
+            });
+        }
+    for (const row of await openCodeEntries(home))
+        add("opencode", shown(row.file), row, {
+            updated: new Date(0).toISOString(),
+            bytes: 0,
+            version: row.version,
+        });
+    for (const row of await antigravityEntries(home))
+        add("antigravity", shown(row.file), row, {
+            updated: new Date(0).toISOString(),
+            bytes: 0,
+            version: row.version,
+        });
+    for (const row of await serverEntries())
+        add(row.client, row.file, row, {
+            updated: new Date(0).toISOString(),
+            bytes: 0,
+            version: row.version,
+        });
+    // Claude Desktop's Code sessions are Claude Code sessions: one line, marked.
+    const claudeCode = new Map(entries
+        .filter((entry) => entry.client === "claude-code")
+        .map((entry) => [entry.id, entry]));
+    const merged = entries.filter((entry) => {
+        const same = entry.client === "claude-desktop" && entry.cliSession
+            ? claudeCode.get(entry.cliSession)
+            : undefined;
+        if (!same)
+            return true;
+        same.alsoIn = ["claude-desktop"];
+        if (!same.title)
+            same.title = entry.title;
+        return false;
+    });
+    merged.sort((a, b) => b.updated.localeCompare(a.updated));
+    if (options.write) {
+        await mkdir(path.dirname(historyIndexFile()), {
+            recursive: true,
+            mode: 0o700,
+        });
+        await atomicWrite(historyIndexFile(), merged.map((entry) => JSON.stringify(entry)).join("\n") +
+            (merged.length ? "\n" : ""), 0o600);
+    }
+    return merged;
+}
+// Every word must appear in the title, project, tags, folder, client or file; newest first.
+export async function searchHistory(query, options = {}) {
+    const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+    return (await readIndex())
+        .filter((entry) => !options.client || entry.client === options.client)
+        .filter((entry) => !options.project || entry.project === options.project)
+        .filter((entry) => {
+        const text = [
+            entry.title,
+            entry.project,
+            ...(entry.tags ?? []),
+            entry.cwd ?? "",
+            entry.client,
+            entry.file,
+        ]
+            .join(" ")
+            .toLowerCase();
+        return words.every((word) => text.includes(word));
+    })
+        .slice(0, options.limit ?? 20);
+}
+//# sourceMappingURL=history-index.js.map

package/dist/application/pull/project-match.js

@@ -0,0 +1,132 @@
+import os from "node:os";
+import path from "node:path";
+import { expandHome, listProjectManifests, projectFormerPaths, projectTags, } from "@ocean/core/shared/project-resolution.js";
+export const UNASSIGNED = "unassigned";
+export const SCRATCH = "scratch";
+const lower = (value) => value.toLowerCase();
+export async function loadProjectIndex(home = os.homedir()) {
+    const projects = [];
+    for (const manifest of await listProjectManifests()) {
+        // A malformed optional list must not drop the project from sorting.
+        const safe = (read) => {
+            try {
+                return read();
+            }
+            catch {
+                return [];
+            }
+        };
+        const former = safe(() => projectFormerPaths(manifest));
+        const folders = [...manifest.paths, ...former].map((entry) => path.resolve(expandHome(entry)));
+        projects.push({
+            id: manifest.id,
+            // A project is also known by its old folders' names (atlas for ocean) — not by its
+            // current folders' names, which can be as generic as `dashboard`.
+            names: [
+                ...new Set([
+                    manifest.id,
+                    manifest.name,
+                    ...former.map((entry) => path.basename(expandHome(entry))),
+                ]
+                    .filter(Boolean)
+                    .map(lower)),
+            ],
+            tags: safe(() => projectTags(manifest)),
+            folders,
+        });
+    }
+    return { projects, home };
+}
+// `folder` is `root` or below it, in the platform's own separator (Windows resolves to `\`).
+const under = (folder, root) => folder === root ||
+    folder.startsWith(root.endsWith(path.sep) ? root : `${root}${path.sep}`);
+// macOS folder names ignore case: ~/Documents/ameer/Ocean-UIUX-MCP is the bound ocean-UIUX-MCP.
+const within = (folder, root) => under(lower(folder), lower(root));
+function isScratch(folder, home) {
+    const roots = [
+        os.tmpdir(),
+        ...["/tmp", "/private/tmp", "/var/folders", "/private/var/folders"].map((root) => path.resolve(root)),
+        path.join(home, "Library", "Application Support", "Claude", "scratch-workspaces"),
+    ];
+    return (folder === path.parse(folder).root ||
+        folder === home ||
+        roots.some((root) => under(folder, root)) ||
+        /(^|[-_/])scratch([-_/]|$)/i.test(path.basename(folder)));
+}
+// A conversation's working folder → its project.
+export function placeFolder(index, cwd) {
+    if (!cwd)
+        return { project: UNASSIGNED };
+    const folder = path.resolve(expandHome(cwd.trim()));
+    const shown = folder.startsWith(index.home)
+        ? `~${folder.slice(index.home.length)}`
+        : folder;
+    let best;
+    for (const project of index.projects)
+        for (const root of project.folders)
+            if (within(folder, root) && root.length > (best?.length ?? -1))
+                best = { id: project.id, tags: project.tags, length: root.length };
+    if (best)
+        return { project: best.id, tags: best.tags, cwd: shown, target: true };
+    if (isScratch(folder, index.home))
+        return { project: SCRATCH, cwd: shown };
+    // The deepest folder on the path named like a project (moved folders keep their names).
+    for (const part of folder.split(path.sep).filter(Boolean).reverse()) {
+        const project = index.projects.find((item) => item.names.includes(lower(part.trim())));
+        if (project)
+            return {
+                project: project.id,
+                tags: project.tags,
+                cwd: shown,
+                target: true,
+            };
+    }
+    return { project: UNASSIGNED, cwd: shown };
+}
+// The project whose name appears in a phrase as whole words; the longest name wins, so
+// "Ocean IELTS plan" is ocean-ielts, not ocean.
+const words = (value) => `-${value
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")}-`;
+function projectNamedIn(index, phrase) {
+    const text = words(phrase);
+    return index.projects
+        .flatMap((project) => project.names.map((name) => ({ project, name: words(name) })))
+        .filter(({ name }) => name !== "--" && text.includes(name))
+        .sort((a, b) => b.name.length - a.name.length)[0]?.project;
+}
+// Claude Code names a project's folder by its path with every non-alphanumeric as `-`.
+const claudeDir = (folder) => folder.replace(/[^A-Za-z0-9]/g, "-");
+// A memory text → its project: Claude Code's per-project memory by its folder, a claude.ai
+// project by its name, anything else by a project named in its first heading.
+export function placeMemory(index, origin) {
+    if (origin.client === "claude-code") {
+        const dir = /\.claude[\\/]projects[\\/]([^\\/]+)[\\/]memory[\\/]/.exec(origin.file)?.[1];
+        if (dir) {
+            let best;
+            for (const project of index.projects)
+                for (const root of project.folders) {
+                    const encoded = claudeDir(root);
+                    if ((lower(dir) === lower(encoded) ||
+                        lower(dir).startsWith(`${lower(encoded)}-`)) &&
+                        encoded.length > (best?.length ?? -1))
+                        best = {
+                            id: project.id,
+                            tags: project.tags,
+                            length: encoded.length,
+                        };
+                }
+            if (best)
+                return { project: best.id, tags: best.tags, target: true };
+            return { project: UNASSIGNED };
+        }
+    }
+    const named = origin.name ?? /^#{1,6}\s+(.+)$/m.exec(origin.text)?.[1];
+    const project = named ? projectNamedIn(index, named) : undefined;
+    if (project)
+        return { project: project.id, tags: project.tags, target: true };
+    // Global memory and instructions are about the owner, not one project.
+    return { project: "personal" };
+}
+//# sourceMappingURL=project-match.js.map