@amoree-code/ocean 0.0.0-stage → 1.2.0

package/node_modules/@ocean/core/dist/shared/task-reference.js

@@ -0,0 +1,133 @@
+import { access, readdir } from "node:fs/promises";
+import path from "node:path";
+import { parseTaskId, taskIdSpellings } from "../domain/tasks/task-id.js";
+import { FRONTMATTER_READ_BYTES, readFrontmatterFile } from "./fs-utils.js";
+import { isWorkspaceProject, oceanRoot, PROJECTS_DIR, projectSubdir, resolveWithin, } from "./paths.js";
+import { folderProject, projectForPrefix, projectsWithTasks, } from "./project-resolution.js";
+// Archive namespace per project; the workspace project archives under "Ocean".
+export const WORKSPACE_ARCHIVE_NAMESPACE = "Ocean";
+export const projectArchiveName = (project) => isWorkspaceProject(project) ? WORKSPACE_ARCHIVE_NAMESPACE : project;
+const exists = (file) => access(file).then(() => true, () => false);
+// One project's task by exact id: live first, then archive/<namespace>/<id>.
+async function findInProject(projectsDir, project, id) {
+    const tasks = resolveWithin(projectsDir, projectSubdir(projectsDir, project), "tasks");
+    for (const spelling of taskIdSpellings(id)) {
+        const live = resolveWithin(tasks, spelling, "task.md");
+        if (await exists(live))
+            return { projectId: project, id: spelling, file: live, archived: false };
+    }
+    for (const spelling of taskIdSpellings(id)) {
+        const file = resolveWithin(tasks, "archive", projectArchiveName(project), spelling, "task.md");
+        if (await exists(file))
+            return { projectId: project, id: spelling, file, archived: true };
+    }
+    return null;
+}
+async function directories(parent) {
+    try {
+        return (await readdir(parent, { withFileTypes: true })).filter((entry) => entry.isDirectory());
+    }
+    catch {
+        return [];
+    }
+}
+// Every task folder of a project, live and archived, as [folder name, task.md, archived].
+export async function taskFolders(projectsDir, project) {
+    const tasks = resolveWithin(projectsDir, projectSubdir(projectsDir, project), "tasks");
+    const found = [];
+    for (const entry of await directories(tasks)) {
+        if (entry.name !== "archive")
+            found.push([entry.name, path.join(tasks, entry.name, "task.md"), false]);
+    }
+    const archive = path.join(tasks, "archive");
+    for (const entry of await directories(archive)) {
+        // archive/<namespace>/<id>, or a flat archive/<id>.
+        if (await exists(path.join(archive, entry.name, "task.md")))
+            found.push([entry.name, path.join(archive, entry.name, "task.md"), true]);
+        else
+            for (const inner of await directories(path.join(archive, entry.name)))
+                found.push([
+                    inner.name,
+                    path.join(archive, entry.name, inner.name, "task.md"),
+                    true,
+                ]);
+    }
+    return found;
+}
+// Tasks renumbered by `ocean tasks renumber` keep their old id in `legacyId`, so a reference
+// written before the rename (a commit message, a handoff) still finds its task. Only the
+// frontmatter head of each record is read.
+async function findByLegacyId(projectsDir, projects, wanted) {
+    const hits = [];
+    for (const project of projects) {
+        for (const [id, file, archived] of await taskFolders(projectsDir, project)) {
+            const record = await readFrontmatterFile(file, FRONTMATTER_READ_BYTES);
+            const legacy = record?.fields.legacyId
+                ? parseTaskId(record.fields.legacyId)
+                : null;
+            if (legacy?.prefix === wanted.prefix && legacy.number === wanted.number)
+                hits.push({ projectId: project, id, file, archived });
+        }
+    }
+    return hits;
+}
+// Resolves a task reference to the task that holds it (T-256). A prefixed id goes to the
+// project that owns the prefix. A bare T id looks in the current project, then (unless told to
+// stay) in whichever project holds it, then in `legacyId` fields. Ambiguity is an error, never
+// a guess.
+export async function resolveTaskReference(ref, scope = {}) {
+    const parsed = parseTaskId(ref);
+    if (!parsed)
+        throw new Error(`'${ref}' is not a task id`);
+    // As typed, prefix upper-cased: the spelling tried first (T-0003 may be a real folder name).
+    const canonical = `${parsed.prefix}${ref.slice(ref.indexOf("-"))}`;
+    const projectsDir = path.join(scope.root ?? oceanRoot(), PROJECTS_DIR);
+    const acrossProjects = scope.acrossProjects !== false && !scope.explicit;
+    const current = scope.projectId ?? (scope.cwd ? await folderProject(scope.cwd) : null);
+    const owner = await projectForPrefix(parsed.prefix);
+    if (owner) {
+        if (current &&
+            owner !== current &&
+            (scope.explicit || scope.acrossProjects === false))
+            throw new Error(`${canonical} belongs to ${owner}, not ${current}`);
+        const hit = await findInProject(projectsDir, owner, canonical);
+        if (hit)
+            return hit;
+        throw new Error(`${canonical} is not a task in project ${owner}`);
+    }
+    if (parsed.prefix !== "T")
+        throw new Error(`no project uses prefix ${parsed.prefix}`);
+    if (current) {
+        const hit = await findInProject(projectsDir, current, canonical);
+        if (hit)
+            return hit;
+    }
+    if (scope.explicit && current) {
+        const legacy = await findByLegacyId(projectsDir, [current], parsed);
+        if (legacy.length === 1)
+            return legacy[0];
+        throw new Error(`${canonical} is not a task in project ${current}`);
+    }
+    if (acrossProjects) {
+        const projects = await projectsWithTasks();
+        for (const archived of [false, true]) {
+            const holders = [];
+            for (const project of projects) {
+                const hit = await findInProject(projectsDir, project, canonical);
+                if (hit && hit.archived === archived)
+                    holders.push(hit);
+            }
+            if (holders.length === 1)
+                return holders[0];
+            if (holders.length > 1)
+                throw new Error(`${canonical} exists in ${holders.map((holder) => holder.projectId).join(", ")}; pass --project <id>`);
+        }
+    }
+    const legacy = await findByLegacyId(projectsDir, acrossProjects ? await projectsWithTasks() : current ? [current] : [], parsed);
+    if (legacy.length === 1)
+        return legacy[0];
+    if (legacy.length > 1)
+        throw new Error(`${canonical} was the old id of tasks in ${legacy.map((hit) => hit.projectId).join(", ")}; pass --project <id>`);
+    throw new Error(`${canonical} is not a task in any project`);
+}
+//# sourceMappingURL=task-reference.js.map

package/node_modules/@ocean/core/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@ocean/core",
+  "version": "1.2.0",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    "./domain/*.js": {
+      "import": "./dist/domain/*.js"
+    },
+    "./shared/*.js": {
+      "import": "./dist/shared/*.js"
+    }
+  }
+}

package/node_modules/@ocean/loop/dist/handoff/handoff-service.js

@@ -0,0 +1,133 @@
+import { execFile as execFileCallback } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { promisify } from "node:util";
+import { compactHandoff, validateHandoff, } from "@ocean/core/domain/sessions/handoff.js";
+import { engineRoot } from "@ocean/core/shared/paths.js";
+import { resolveTaskReference } from "@ocean/core/shared/task-reference.js";
+const execFile = promisify(execFileCallback);
+const maxContentBytes = 16_000;
+export async function createHandoff(input, openStore) {
+    const store = await openStore();
+    try {
+        return await createHandoffWithStore(store, input);
+    }
+    finally {
+        store.close();
+    }
+}
+export async function createHandoffWithStore(store, input) {
+    const session = input.sessionId ? store.get(input.sessionId) : null;
+    if (input.sessionId && !session)
+        throw new Error(`Session not found: ${input.sessionId}`);
+    // The task is found from where the session worked: its folder decides the project.
+    const task = input.task === undefined && input.taskId
+        ? await getTask(input.taskId, {
+            cwd: session?.workingDirectory ?? process.cwd(),
+        })
+        : (input.task ?? null);
+    const commit = await currentCommit();
+    const now = new Date().toISOString();
+    const content = (input.content ?? task?.body ?? "").slice(0, maxContentBytes);
+    const handoff = validateHandoff({
+        handoffId: `handoff-${randomUUID()}`,
+        taskId: task?.id ?? session?.taskId ?? null,
+        title: input.title ?? task?.title ?? session?.title ?? "Ocean session handoff",
+        objective: task?.objective ??
+            "Continue the selected Ocean session with bounded context.",
+        state: task?.state ?? session?.status ?? "paused",
+        profileId: input.profileId ?? session?.profile ?? "",
+        profileIdentity: session?.profileIdentity ?? "",
+        sourceSessionId: session?.sessionId ?? null,
+        projectId: task?.project ?? input.projectId ?? session?.projectId ?? null,
+        provider: input.provider ?? session?.provider ?? "",
+        parentSessionId: session?.parentSessionId ?? null,
+        decisions: [],
+        changedFiles: input.changedFiles ?? [],
+        commit,
+        verification: input.verification ?? [],
+        notProven: input.notProven ?? [],
+        blocked: input.blocked ?? [],
+        permissions: { profile: input.profileId ?? session?.profile ?? null },
+        contextManifest: {
+            bytes: session?.contextBytes ?? 0,
+            hash: session?.contextHash ?? null,
+            mode: "bounded",
+        },
+        nextAction: input.nextAction ??
+            session?.nextAction ??
+            "Verify the current state before changing files.",
+        sourceSummaryPath: input.sourceSummaryPath ?? null,
+        content,
+        contentBytes: Buffer.byteLength(content),
+        createdAt: now,
+        updatedAt: now,
+    });
+    store.saveHandoff(handoff);
+    if (session)
+        store.updateHandoff(session.sessionId, handoff.handoffId, handoff.nextAction);
+    return handoff;
+}
+export async function getHandoff(handoffId, openStore, maxBytes = 8_000) {
+    const store = await openStore();
+    try {
+        const handoff = store.getHandoff(handoffId);
+        if (!handoff)
+            throw new Error(`Handoff not found: ${handoffId}`);
+        return {
+            ...handoff,
+            compactContext: compactHandoff(validateHandoff(handoff), maxBytes),
+        };
+    }
+    finally {
+        store.close();
+    }
+}
+export async function listHandoffs(openStore, taskId, projectId) {
+    const store = await openStore();
+    try {
+        return store
+            .listHandoffs(taskId, projectId)
+            .map(({ content: _content, ...handoff }) => handoff);
+    }
+    finally {
+        store.close();
+    }
+}
+export async function getTask(id, scope = {}) {
+    const location = await resolveTaskReference(id, scope);
+    const file = await readFile(location.file, "utf8");
+    const end = file.indexOf("\n---", 4);
+    const frontmatter = file
+        .slice(0, end < 0 ? 0 : end)
+        .split("\n")
+        .slice(1);
+    const fields = Object.fromEntries(frontmatter
+        .filter((line) => /^[\w-]+:/.test(line))
+        .map((line) => {
+        const index = line.indexOf(":");
+        return [line.slice(0, index), line.slice(index + 1).trim()];
+    }));
+    const body = file.slice(end < 0 ? 0 : end + 5);
+    const objective = body.match(/(?:^|\n)## Objective\n\n([\s\S]*?)(?=\n## |$)/)?.[1]?.trim() ??
+        "";
+    return {
+        id: fields.id ?? location.id,
+        project: location.projectId,
+        title: fields.title ?? location.id,
+        state: fields.state ?? "unknown",
+        goal: objective || fields.goal || "",
+        objective: objective || fields.requirement || fields.goal || "",
+        body,
+        updatedAt: fields.updated ?? fields.updated_at ?? "",
+    };
+}
+async function currentCommit() {
+    try {
+        return ((await execFile("git", ["-C", engineRoot(), "rev-parse", "HEAD"])).stdout.trim() || null);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=handoff-service.js.map

package/node_modules/@ocean/loop/dist/hooks/lifecycle-hooks.js

@@ -0,0 +1,15 @@
+const hooks = new Map();
+export function registerHook(event, hook) {
+    const registered = hooks.get(event) ?? new Set();
+    registered.add(hook);
+    hooks.set(event, registered);
+    return () => registered.delete(hook);
+}
+export async function emitHook(event, payload) {
+    for (const hook of hooks.get(event) ?? [])
+        await hook(event, payload);
+}
+export function clearHooks() {
+    hooks.clear();
+}
+//# sourceMappingURL=lifecycle-hooks.js.map

package/node_modules/@ocean/loop/dist/hooks/session-end-hook.js

@@ -0,0 +1,183 @@
+import { createReadStream } from "node:fs";
+import { stat } from "node:fs/promises";
+import readline from "node:readline";
+import { finalizeSession } from "../sessions/session-closeout.js";
+import { sessionProjectId } from "../sessions/session-projects.js";
+// Gemini CLI, Qwen Code and Cursor fire a session-end event too (T-307); their transcript
+// formats are not read, so their sessions are recorded from metadata alone.
+export const SESSION_END_CLIENTS = [
+    "claude",
+    "codex",
+    "gemini",
+    "qwen",
+    "cursor",
+];
+const TRANSCRIPT_CLIENTS = ["claude", "codex"];
+export function isSessionEndClient(value) {
+    return SESSION_END_CLIENTS.includes(value);
+}
+const MAX_TRANSCRIPT_BYTES = 8 * 1024 * 1024;
+const MAX_EVENTS = 30;
+const MAX_EVENT_CHARS = 800;
+function safeSlice(value, max) {
+    return value.replace(/\s+/g, " ").trim().slice(0, max);
+}
+function textFromContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .filter((block) => block &&
+        typeof block === "object" &&
+        block.type === "text" &&
+        typeof block.text === "string")
+        .map((block) => block.text)
+        .join(" ");
+}
+// Codex prepends context blocks (AGENTS.md, environment and plugin lists) as
+// user messages; they are injected text, not something the user typed.
+function isInjectedCodexText(text) {
+    return text.startsWith("<") || text.startsWith("# AGENTS.md");
+}
+// One transcript line → the turn it holds, or null. Claude Code writes
+// {type, message:{role, content}}; Codex writes {type:"response_item",
+// payload:{type:"message", role, content:[{type:"input_text"|"output_text", text}]}}.
+function transcriptTurn(record, client) {
+    if (client === "codex") {
+        const payload = record.payload;
+        if (record.type !== "response_item" || payload?.type !== "message")
+            return null;
+        if (payload.role !== "user" && payload.role !== "assistant")
+            return null;
+        if (!Array.isArray(payload.content))
+            return null;
+        const text = payload.content
+            .filter((block) => block &&
+            typeof block === "object" &&
+            typeof block.text === "string" &&
+            !(payload.role === "user" &&
+                isInjectedCodexText(block.text)))
+            .map((block) => block.text)
+            .join(" ");
+        return { role: payload.role, text };
+    }
+    if (record.type !== "user" && record.type !== "assistant")
+        return null;
+    const message = record.message;
+    return { role: record.type, text: textFromContent(message?.content) };
+}
+/**
+ * Extracts a bounded set of plain-text user/assistant turns from a Claude
+ * Code transcript (JSONL: one record per line, {type, message:{role,
+ * content}}) or a Codex rollout (see transcriptTurn). Skips tool calls, thinking blocks, and any non-text content —
+ * this feeds the same human-narrative pipeline intercepted CLI sessions use
+ * (see session-closeout.ts), not a full transcript mirror. Returns the most
+ * recent MAX_EVENTS turns; never throws (a missing/oversized/malformed
+ * transcript just yields no events, and the caller still closes out the
+ * session on its title alone).
+ */
+export async function readTranscriptEvents(transcriptPath, client = "claude") {
+    try {
+        const info = await stat(transcriptPath);
+        if (info.size > MAX_TRANSCRIPT_BYTES)
+            return [];
+    }
+    catch {
+        return [];
+    }
+    const events = [];
+    try {
+        const rl = readline.createInterface({
+            input: createReadStream(transcriptPath, { encoding: "utf8" }),
+            crlfDelay: Infinity,
+        });
+        for await (const line of rl) {
+            if (!line.trim())
+                continue;
+            let record;
+            try {
+                record = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (!record || typeof record !== "object")
+                continue;
+            const turn = transcriptTurn(record, client);
+            if (!turn)
+                continue;
+            const text = safeSlice(turn.text, MAX_EVENT_CHARS);
+            if (!text)
+                continue;
+            events.push({
+                type: turn.role === "user" ? "user_input" : "provider_output",
+                data: text,
+            });
+        }
+        rl.close();
+    }
+    catch {
+        return [];
+    }
+    return events.slice(-MAX_EVENTS);
+}
+/**
+ * SessionEnd counterpart to claudeSessionStartHook. Unlike SessionStart
+ * (context injection only, no session-store write), this registers the
+ * Claude Code session in sessions.sqlite the first time it is seen, replays
+ * its transcript as bounded user_input/provider_output events, and runs it
+ * through the same finalizeSession pipeline as `ocean run` and `ocean
+ * intercept` sessions — producing the summary, daily narrative, and
+ * brain/00-inbox/brain-dump/ entry. Reuses the sessionId Claude Code itself
+ * assigned, so a hook re-run for the same session (e.g. `/clear` followed by
+ * another SessionEnd) is idempotent via finalizeSession's own closeout guard.
+ * Best-effort throughout: any failure is swallowed so a broken hook can never
+ * block the user's actual session from ending.
+ */
+export async function claudeSessionEndHook(payload, openStore, client = "claude") {
+    const sessionId = payload.session_id;
+    if (!sessionId)
+        return;
+    const roots = payload.workspace_roots;
+    const cwd = payload.cwd ||
+        (Array.isArray(roots) && typeof roots[0] === "string" ? roots[0] : "") ||
+        process.cwd();
+    const store = await openStore();
+    try {
+        let session = store.get(sessionId);
+        if (!session) {
+            store.create({
+                sessionId,
+                provider: client,
+                providerSessionId: sessionId,
+                parentSessionId: null,
+                profile: `desktop:${client}`,
+                profileIdentity: "",
+                workingDirectory: cwd,
+                resumeData: null,
+                projectId: await sessionProjectId(cwd),
+            });
+            store.updateStatus(sessionId, "running");
+            session = store.get(sessionId);
+        }
+        if (!session || session.closedAt)
+            return;
+        const events = payload.transcript_path && TRANSCRIPT_CLIENTS.includes(client)
+            ? await readTranscriptEvents(payload.transcript_path, client)
+            : [];
+        for (const event of events)
+            store.appendEvent(sessionId, event.type, event.data);
+        store.appendEvent(sessionId, "process_exit", JSON.stringify({ exitCode: 0 }));
+        if (session.status !== "completed")
+            store.updateStatus(sessionId, "completed");
+        await finalizeSession(store, sessionId, { exitCode: 0 });
+    }
+    catch {
+        // Best-effort: never surface a hook failure to the user's session end.
+    }
+    finally {
+        store.close();
+    }
+}
+//# sourceMappingURL=session-end-hook.js.map