@amoree-code/ocean 0.0.0-stage → 1.2.0

package/node_modules/@ocean/brain/dist/memory/model-narrative.js

@@ -0,0 +1,129 @@
+import { execFile as execFileCallback } from "node:child_process";
+import { promisify } from "node:util";
+import { redactRuntimeText } from "@ocean/core/domain/redaction/redaction.js";
+import { oceanEnv, oceanEnvPair } from "@ocean/core/shared/paths.js";
+const execFile = promisify(execFileCallback);
+const SYSTEM_PROMPT = 'You are a terse session summarizer. Read the evidence and reply with ONLY a JSON object, no prose, no markdown fences: {"workLog":"one line, what happened","decision":"one line or omit","problem":"one line or omit","next":"one line or omit"}. Omit a key entirely if the evidence gives nothing for it. Never invent facts not present in the evidence.';
+function safeText(value, max = 400) {
+    return redactRuntimeText(value).replace(/\s+/g, " ").trim().slice(0, max);
+}
+/** Cheap, cost-conscious skip: no point paying for a model call on a trivial session. */
+export function isTrivialSession(events, changedFiles) {
+    if (changedFiles.length > 0)
+        return false;
+    return !events.some((event) => (event.type === "provider_output" || event.type === "text") &&
+        event.data.trim().length > 40);
+}
+function buildPrompt(input) {
+    const objective = input.events.find((event) => event.type === "user_input" || event.type === "resume_requested");
+    const outputs = input.events
+        .filter((event) => event.type === "provider_output" ||
+        event.type === "text" ||
+        event.type === "json")
+        .map((event) => safeText(event.data, 300))
+        .filter(Boolean)
+        .slice(0, 6);
+    const errors = input.events
+        .filter((event) => event.type === "error" || event.type === "provider_blocked")
+        .map((event) => safeText(event.data, 300))
+        .slice(0, 3);
+    const lines = [
+        `Objective: ${safeText(objective?.data ?? input.session.title, 200)}`,
+        `Changed files: ${input.changedFiles.length ? input.changedFiles.slice(0, 20).join("; ") : "none"}`,
+        outputs.length
+            ? `Conversation excerpts:\n${outputs.map((line) => `- ${line}`).join("\n")}`
+            : "Conversation excerpts: none",
+        errors.length
+            ? `Errors/blocks:\n${errors.map((line) => `- ${line}`).join("\n")}`
+            : "",
+        input.nextAction
+            ? `Stated next action: ${safeText(input.nextAction, 200)}`
+            : "",
+    ];
+    return lines.filter(Boolean).join("\n");
+}
+export function parseResult(stdout) {
+    // --output-format json prints one JSON object, but non-interactive terminal
+    // control sequences (e.g. a trailing cursor-show code) can follow it on
+    // stdout even when not attached to a TTY — trim to the outermost braces
+    // before parsing rather than parsing the whole stream verbatim.
+    const start = stdout.indexOf("{");
+    const end = stdout.lastIndexOf("}");
+    if (start < 0 || end < start)
+        return null;
+    let envelope;
+    try {
+        envelope = JSON.parse(stdout.slice(start, end + 1));
+    }
+    catch {
+        return null;
+    }
+    if (typeof envelope.result !== "string")
+        return null;
+    const text = envelope.result
+        .trim()
+        .replace(/^```(?:json)?\s*/i, "")
+        .replace(/```\s*$/, "")
+        .trim();
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== "object")
+        return null;
+    const value = parsed;
+    const narrative = {};
+    for (const key of ["workLog", "decision", "problem", "next"]) {
+        if (typeof value[key] === "string" && value[key].trim())
+            narrative[key] = safeText(value[key], 300);
+    }
+    return Object.keys(narrative).length ? narrative : null;
+}
+/**
+ * Best-effort, cost-conscious human narrative via a cheap headless model call.
+ * Returns null on any failure (auth, timeout, parse error) so the caller falls
+ * back to the deterministic heuristic in daily-narrative.ts. Never throws.
+ *
+ * Guarded against recursion: the spawned call carries OCEAN_NARRATIVE_CALL=1,
+ * and session-closeout.ts skips calling this again when that flag is already
+ * set on the current process (i.e. this IS a narrative-generation session).
+ */
+export async function generateModelNarrative(input) {
+    // Opt-in only: unset (tests, CI, a fresh install) means no model call — no
+    // network, no auth requirement, no cost, fully deterministic by default.
+    if (oceanEnv("MODEL_NARRATIVE") !== "1")
+        return null;
+    if (oceanEnv("NARRATIVE_CALL") === "1")
+        return null;
+    if (isTrivialSession(input.events, input.changedFiles))
+        return null;
+    const prompt = buildPrompt(input);
+    try {
+        const result = await execFile("claude", [
+            "-p",
+            prompt,
+            "--model",
+            "haiku",
+            "--output-format",
+            "json",
+            "--system-prompt",
+            SYSTEM_PROMPT,
+            "--allowedTools",
+            "",
+            "--disallowedTools",
+            "Bash,Edit,Write,Read,Glob,Grep,NotebookEdit,WebFetch,WebSearch",
+        ], {
+            timeout: 30_000,
+            maxBuffer: 65_536,
+            env: { ...process.env, ...oceanEnvPair("NARRATIVE_CALL", "1") },
+        });
+        return parseResult(result.stdout);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=model-narrative.js.map

package/node_modules/@ocean/brain/dist/memory/profile-facts.js

@@ -0,0 +1,103 @@
+import { mkdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import { assertProfileName } from "@ocean/core/domain/profiles/profile.js";
+import { atomicWrite, truncateUtf8, withFileLock, } from "@ocean/core/shared/fs-utils.js";
+import { oceanPath, resolveWithin, SYSTEM_DIR, } from "@ocean/core/shared/paths.js";
+const maxFacts = 100;
+const maxFactBytes = 2_000;
+// The profile name is validated and the path is bounds-checked (including symlinks), so one
+// profile's namespace can never resolve to another file inside or outside the memory root.
+export function profileFactsFile(profile) {
+    return resolveWithin(oceanPath(SYSTEM_DIR, "memory", "profiles"), `${assertProfileName(profile)}.json`);
+}
+export async function readProfileFacts(profile) {
+    try {
+        const facts = JSON.parse(await readFile(profileFactsFile(profile), "utf8"));
+        return Array.isArray(facts) ? facts.slice(0, maxFacts) : [];
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+}
+// Read-modify-write under the file lock, replaced atomically: concurrent writers to the same
+// profile each see the other's facts, and a crash never leaves a truncated file. `change`
+// returns null to skip the write.
+async function updateProfileFacts(profile, change) {
+    const file = profileFactsFile(profile);
+    await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+    await withFileLock(file, async () => {
+        const next = change(await readProfileFacts(profile));
+        if (next)
+            await atomicWrite(file, `${JSON.stringify(next.slice(0, maxFacts), null, 2)}\n`, 0o600);
+    });
+}
+export async function writeProfileFact(profile, key, value) {
+    if (!/^[a-zA-Z0-9._-]+$/.test(key))
+        throw new Error("Fact key must contain only letters, numbers, dot, underscore, or hyphen");
+    if (!value.trim() || Buffer.byteLength(value) > maxFactBytes)
+        throw new Error("Fact value is empty or exceeds 2000 bytes");
+    const fact = {
+        key,
+        value: value.trim(),
+        updatedAt: new Date().toISOString(),
+    };
+    await updateProfileFacts(profile, (facts) => [
+        fact,
+        ...facts.filter((item) => item.key !== key),
+    ]);
+    return fact;
+}
+export async function deleteProfileFact(profile, key) {
+    let deleted = false;
+    await updateProfileFacts(profile, (facts) => {
+        const remaining = facts.filter((fact) => fact.key !== key);
+        deleted = remaining.length !== facts.length;
+        return deleted ? remaining : null;
+    });
+    return deleted;
+}
+export const PROFILE_FACTS_DIGEST_MAX_BYTES = 2_048;
+// A bounded digest of the profile's durable facts for a headless prompt: newest first (by
+// updatedAt, since hand-edited files may not be ordered), whole `- key: value` lines while
+// they fit, and always a pointer to the full set. The whole section stays <= maxBytes; if
+// not even the newest fact fits, it is byte-truncated so at least one fact is visible.
+// `partial` says whether it left anything out (a dropped or byte-truncated fact), in which
+// case the provider must be able to follow the pointer to the store file.
+export function buildProfileFactsDigest(profile, facts, maxBytes = PROFILE_FACTS_DIGEST_MAX_BYTES) {
+    if (!facts.length)
+        return { text: "", partial: false };
+    const time = (fact) => {
+        const value = Date.parse(fact.updatedAt);
+        return Number.isNaN(value) ? Number.NEGATIVE_INFINITY : value;
+    };
+    const ordered = [...facts].sort((a, b) => time(b) - time(a));
+    const heading = "## Durable profile facts";
+    const pointer = (shown) => `(${shown} of ${facts.length} facts, newest first; full set: ocean memory facts ${profile} or ${profileFactsFile(profile)})`;
+    // Reserve the pointer's worst case (shown === total) so its size never grows past the budget.
+    const reserved = Buffer.byteLength(pointer(facts.length)) + 1;
+    const lines = [];
+    let used = Buffer.byteLength(heading);
+    let whole = 0;
+    for (const fact of ordered) {
+        const line = `- ${fact.key}: ${String(fact.value).replace(/\s+/g, " ").trim()}`;
+        const cost = Buffer.byteLength(line) + 1;
+        if (used + cost + reserved <= maxBytes) {
+            lines.push(line);
+            used += cost;
+            whole += 1;
+            continue;
+        }
+        if (!lines.length) {
+            const room = maxBytes - used - reserved - 1 - Buffer.byteLength("...");
+            lines.push(`${truncateUtf8(line, Math.max(0, room))}...`);
+        }
+        break;
+    }
+    return {
+        text: [heading, ...lines, pointer(lines.length)].join("\n"),
+        partial: whole < facts.length,
+    };
+}
+//# sourceMappingURL=profile-facts.js.map

package/node_modules/@ocean/brain/dist/memory/session-promotion.js

@@ -0,0 +1,61 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { redactRuntimeText } from "@ocean/core/domain/redaction/redaction.js";
+import { KNOWLEDGE_DIR, oceanPath } from "@ocean/core/shared/paths.js";
+import { syncMemoryIndexes } from "./index-sync.js";
+const kinds = new Set([
+    "architecture",
+    "decisions",
+    "discoveries",
+    "failures",
+    "research",
+    "results",
+    "solutions",
+    "references",
+]);
+export async function promoteSessionToKnowledge(sessionId, openStore, target = "knowledge/results", approved = false) {
+    if (!approved)
+        throw new Error("Session promotion requires explicit approval: use --approve or approved: true");
+    const match = /^knowledge\/(\w+)$/.exec(target);
+    if (!match || !kinds.has(match[1]))
+        throw new Error("Target must be knowledge/<architecture|decisions|discoveries|failures|research|results|solutions|references>");
+    const store = await openStore();
+    try {
+        const session = store.get(sessionId);
+        if (!session)
+            throw new Error(`Session not found: ${sessionId}`);
+        if (session.status !== "completed")
+            throw new Error(`Only completed sessions can be promoted: ${session.status}`);
+        const events = store.listEvents(sessionId);
+        const evidence = events
+            .filter((event) => event.type === "evidence")
+            .map((event) => event.data)
+            .some((data) => /"result"\s*:\s*"proven"/.test(data));
+        if (!evidence)
+            throw new Error("Session lacks independently recorded successful evidence");
+        const input = events.find((event) => event.type === "user_input")?.data ?? "";
+        const outputs = events
+            .filter((event) => event.type === "provider_output" ||
+            event.type === "text" ||
+            event.type === "json")
+            .map((event) => redactRuntimeText(event.data).trim())
+            .filter(Boolean);
+        if (!outputs.length)
+            throw new Error("Session has no provider output to promote");
+        const slug = `${session.provider}-${sessionId.slice(0, 8)}`.replace(/[^a-zA-Z0-9-]+/g, "-");
+        const file = path.join(oceanPath(KNOWLEDGE_DIR, match[1], `${slug}.md`));
+        await mkdir(path.dirname(file), { recursive: true });
+        await writeFile(file, `---\nname: ${slug}\ndescription: Human-approved result from an Ocean session\nmetadata:\n  type: session-result\n  domain: ${match[1]}\n  status: current\n  verification: human-approved\n  source-session: ${sessionId}\n  provider: ${session.provider}\n---\n\n# ${session.provider} review\n\n## Request\n\n${redactRuntimeText(input)}\n\n## Result\n\n${outputs.join("\n\n")}\n`);
+        store.appendEvent(sessionId, "knowledge_promoted", JSON.stringify({
+            file: path.relative(oceanPath(KNOWLEDGE_DIR), file),
+            target,
+            approved: true,
+        }));
+        await syncMemoryIndexes(true);
+        return { applied: true, sessionId, file: path.relative(oceanPath(), file) };
+    }
+    finally {
+        store.close();
+    }
+}
+//# sourceMappingURL=session-promotion.js.map

package/node_modules/@ocean/brain/dist/memory/session-summary.js

@@ -0,0 +1,113 @@
+import { createHash } from "node:crypto";
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { redactRuntimeText } from "@ocean/core/domain/redaction/redaction.js";
+import { safeJsonParse } from "@ocean/core/shared/fs-utils.js";
+import { localDate, localMoment } from "@ocean/core/shared/local-date.js";
+import { oceanPath, oceanRoot, SYSTEM_DIR } from "@ocean/core/shared/paths.js";
+const maxSummaryBytes = 12_000;
+function safeText(value, max = 800) {
+    return redactRuntimeText(value).replace(/\s+/g, " ").trim().slice(0, max);
+}
+function eventText(events, types, maxItems = 4) {
+    return events
+        .filter((event) => types.includes(event.type))
+        .map((event) => safeText(event.data))
+        .filter(Boolean)
+        .slice(0, maxItems);
+}
+function lastEvent(events, type) {
+    return [...events].reverse().find((event) => event.type === type);
+}
+function renderSessionSummary(input) {
+    const { session, events } = input;
+    const request = eventText(events, ["user_input", "resume_requested"], 1)[0] ??
+        session.title;
+    const outputs = eventText(events, ["provider_output", "text", "json"], 4);
+    const errors = eventText(events, ["error", "provider_blocked"], 4);
+    const evidence = events
+        .filter((event) => event.type === "evidence")
+        .map((event) => safeJsonParse(event.data))
+        .filter((value) => value !== null);
+    const proven = evidence
+        .filter((value) => value.result === "proven")
+        .map((value) => String(value.criterion ?? "verified result"));
+    const notProven = evidence
+        .filter((value) => value.result !== "proven")
+        .map((value) => String(value.criterion ?? value.result ?? "not proven"));
+    const processExit = lastEvent(events, "process_exit");
+    const exit = input.exitCode ??
+        (processExit ? safeJsonParse(processExit.data)?.exitCode : undefined);
+    const status = session.status === "completed" && exit === 0 ? "completed" : session.status;
+    const nextAction = input.nextAction ??
+        session.nextAction ??
+        "Review the summary and verify the next action.";
+    const lines = [
+        "# Session Summary",
+        "",
+        `- Session: ${session.sessionId}`,
+        `- Provider: ${session.provider}`,
+        `- Task: ${session.taskId ?? "none"}`,
+        `- Profile: ${session.profile}`,
+        `- Status: ${status}`,
+        `- Working directory: ${safeText(session.workingDirectory, 240)}`,
+        "",
+        "## Objective",
+        "",
+        request || "No user objective was captured.",
+        "",
+        "## What happened",
+        "",
+        ...(outputs.length
+            ? outputs.map((value) => `- ${value}`)
+            : ["- No provider output was captured."]),
+        "",
+        "## Files changed",
+        "",
+        ...(input.changedFiles?.length
+            ? input.changedFiles.map((value) => `- ${safeText(value, 240)}`)
+            : ["- No changed-file evidence was recorded."]),
+        "",
+        "## Verification",
+        "",
+        ...(proven.length
+            ? proven.map((value) => `- PROVEN: ${safeText(value)}`)
+            : ["- No independently proven verification recorded."]),
+        ...(notProven.length
+            ? notProven.map((value) => `- NOT PROVEN: ${safeText(value)}`)
+            : []),
+        "",
+        "## Problems and limitations",
+        "",
+        ...(errors.length
+            ? errors.map((value) => `- ${value}`)
+            : ["- None recorded."]),
+        "",
+        "## Next action",
+        "",
+        safeText(nextAction, 800),
+        "",
+        "## Retrieval",
+        "",
+        `- Detailed bounded events: ocean session events ${session.sessionId}`,
+        `- Context bytes: ${session.contextBytes}`,
+    ];
+    let content = `${lines.join("\n")}\n`;
+    if (Buffer.byteLength(content) > maxSummaryBytes)
+        content = `${content.slice(0, maxSummaryBytes - 120)}\n\n- Summary truncated; detailed bounded events remain available by session id.\n`;
+    return content;
+}
+export async function writeSessionSummary(input) {
+    const date = localDate(localMoment(input.session.createdAt));
+    const directory = oceanPath(SYSTEM_DIR, "sessions", "summaries");
+    const file = path.join(directory, `${date}-${input.session.sessionId}.md`);
+    await mkdir(directory, { recursive: true });
+    const content = renderSessionSummary(input);
+    await writeFile(file, content, "utf8");
+    return {
+        summaryPath: path.relative(oceanRoot(), file).split(path.sep).join("/"),
+        summaryHash: createHash("sha256").update(content).digest("hex"),
+        summaryBytes: Buffer.byteLength(content),
+    };
+}
+//# sourceMappingURL=session-summary.js.map

package/node_modules/@ocean/brain/package.json

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

package/node_modules/@ocean/context/dist/context/context-compression.js

@@ -0,0 +1,66 @@
+import { createHash } from "node:crypto";
+const REQUIRED = /changed files?|verification|security|approval|error|failed|next action/i;
+function boundedByBytes(value, budget) {
+    return Buffer.from(value).subarray(0, budget).toString("utf8");
+}
+function unique(lines) {
+    return [...new Set(lines.map((line) => line.trim()).filter(Boolean))];
+}
+export function compressContext(input) {
+    const originalBytes = Buffer.byteLength(input.content);
+    const sourceHash = createHash("sha256").update(input.content).digest("hex");
+    if (input.budget <= 0)
+        throw new Error("Compression budget must be positive");
+    if (originalBytes <= input.budget) {
+        return {
+            content: input.content,
+            sourceId: input.sourceId,
+            sourceHash,
+            originalBytes,
+            compressedBytes: originalBytes,
+            method: "none",
+            budget: input.budget,
+            omittedSections: [],
+            recoveryRef: input.sourceId,
+            safeToUse: true,
+        };
+    }
+    const lines = input.content.split(/\r?\n/);
+    const required = unique(lines.filter((line) => REQUIRED.test(line)));
+    const selected = unique([lines[0] ?? "", ...required, lines.at(-1) ?? ""]);
+    const content = selected.join("\n");
+    const compressedBytes = Buffer.byteLength(content);
+    const omittedSections = lines
+        .filter((line) => line.trim() && !selected.includes(line.trim()))
+        .slice(0, 20)
+        .map((line) => line.trim().slice(0, 120));
+    if (compressedBytes <= input.budget &&
+        required.every((line) => content.includes(line.trim()))) {
+        return {
+            content,
+            sourceId: input.sourceId,
+            sourceHash,
+            originalBytes,
+            compressedBytes,
+            method: "ocean-bounded-v1",
+            budget: input.budget,
+            omittedSections,
+            recoveryRef: input.sourceId,
+            safeToUse: true,
+        };
+    }
+    const fallback = boundedByBytes(input.content, input.budget);
+    return {
+        content: fallback,
+        sourceId: input.sourceId,
+        sourceHash,
+        originalBytes,
+        compressedBytes: Buffer.byteLength(fallback),
+        method: "fallback-original-bounded",
+        budget: input.budget,
+        omittedSections,
+        recoveryRef: input.sourceId,
+        safeToUse: false,
+    };
+}
+//# sourceMappingURL=context-compression.js.map