@amoree-code/ocean 0.0.0-stage → 1.1.0

package/node_modules/@ocean/market/dist/skills/core-skill-sync.js

@@ -0,0 +1,113 @@
+import { createHash } from "node:crypto";
+import { cp, lstat, mkdir, readdir, readFile, rm, stat, } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { enginePath } from "@ocean/core/shared/paths.js";
+export const clientSkillRoots = {
+    claude: (home) => path.join(home, ".claude", "skills"),
+    codex: (home) => path.join(home, ".codex", "skills"),
+    gemini: (home) => path.join(home, ".gemini", "skills"),
+    hermes: (home) => path.join(home, ".hermes", "skills"),
+    cursor: (home) => path.join(home, ".cursor", "skills"),
+    antigravity: (home) => path.join(home, ".config", "antigravity", "skills"),
+};
+async function coreSkillNames() {
+    const core = path.join(enginePath("skills"), "core");
+    return (await readdir(core, { withFileTypes: true }))
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+        .sort();
+}
+export async function coreSkillReports(home = os.homedir()) {
+    const names = await coreSkillNames();
+    return Promise.all(Object.keys(clientSkillRoots).map(async (client) => {
+        const root = clientSkillRoots[client](home);
+        try {
+            await stat(root);
+        }
+        catch {
+            return {
+                client,
+                root,
+                status: "unavailable",
+                missing: names,
+                drifted: [],
+            };
+        }
+        const missing = [];
+        const drifted = [];
+        for (const name of names) {
+            const source = await readFile(path.join(enginePath("skills"), "core", name, "SKILL.md"));
+            const targetPath = path.join(root, name, "SKILL.md");
+            try {
+                const target = await readFile(targetPath);
+                if (!same(source, target))
+                    drifted.push(name);
+            }
+            catch {
+                missing.push(name);
+            }
+        }
+        return {
+            client,
+            root,
+            status: missing.length
+                ? "missing"
+                : drifted.length
+                    ? "drifted"
+                    : "synchronized",
+            missing,
+            drifted,
+        };
+    }));
+}
+export async function syncCoreSkills(home = os.homedir()) {
+    const names = await coreSkillNames();
+    const results = [];
+    for (const report of await coreSkillReports(home)) {
+        if (report.status === "unavailable") {
+            results.push({
+                client: report.client,
+                root: report.root,
+                copied: [],
+                status: report.status,
+            });
+            continue;
+        }
+        const copied = [];
+        for (const name of names) {
+            const source = path.join(enginePath("skills"), "core", name, "SKILL.md");
+            const target = path.join(report.root, name, "SKILL.md");
+            // A link left behind by a moved source makes mkdir throw ENOENT; it holds nothing.
+            const skillDir = path.dirname(target);
+            if ((await lstat(skillDir).catch(() => null))?.isSymbolicLink() &&
+                !(await stat(skillDir).catch(() => null)))
+                await rm(skillDir);
+            await mkdir(skillDir, { recursive: true });
+            const sourceBytes = await readFile(source);
+            let current = null;
+            try {
+                current = await readFile(target);
+            }
+            catch {
+                /* new client skill */
+            }
+            if (!current || !same(sourceBytes, current)) {
+                await cp(source, target);
+                copied.push(name);
+            }
+        }
+        results.push({
+            client: report.client,
+            root: report.root,
+            copied,
+            status: "synchronized",
+        });
+    }
+    return results;
+}
+function same(left, right) {
+    return (createHash("sha256").update(left).digest("hex") ===
+        createHash("sha256").update(right).digest("hex"));
+}
+//# sourceMappingURL=core-skill-sync.js.map

package/node_modules/@ocean/market/dist/skills/signal-detection.js

@@ -0,0 +1,84 @@
+import { redactRuntimeText } from "@ocean/core/domain/redaction/redaction.js";
+const CORRECTION_PATTERN = /\bno,|\bactually,|\bnot that\b|\binstead of\b|\bshould use\b|\bthat'?s wrong\b/i;
+// biome-ignore lint/suspicious/noControlCharactersInRegex: matching terminal escape sequences
+const ANSI_PATTERN = /\u001b\[[0-?]*[ -/]*[@-~]/g;
+// Runtime chatter (hook_response JSON, terminal redraws) repeats by construction, not by lesson.
+function isRuntimeNoise(text) {
+    if (text.length <= 12)
+        return true;
+    if (!text.startsWith("{"))
+        return false;
+    try {
+        return JSON.parse(text)?.type === "system";
+    }
+    catch {
+        return false;
+    }
+}
+function userInputTexts(events) {
+    return events
+        .filter((event) => event.type === "user_input")
+        .map((event) => ({
+        id: event.eventId,
+        text: redactRuntimeText(event.data).replace(/\s+/g, " ").trim(),
+    }))
+        .filter((event) => event.text.length > 12)
+        .slice(0, 80);
+}
+// True when the user pushed back in this session ("no, use X", "that's wrong").
+export function hasUserCorrection(events) {
+    return userInputTexts(events).some((event) => CORRECTION_PATTERN.test(event.text));
+}
+// What a completed, proven session is worth remembering. Pure: reads events, writes nothing.
+export function detectSessionSignals(events) {
+    const proven = events.filter((event) => event.type === "evidence" && /"result"\s*:\s*"proven"/.test(event.data));
+    if (!proven.length)
+        return [];
+    const outputs = events
+        .filter((event) => ["provider_output", "text", "json"].includes(event.type))
+        .map((event) => ({
+        id: event.eventId,
+        text: redactRuntimeText(event.data)
+            .replace(ANSI_PATTERN, "")
+            .replace(/\s+/g, " ")
+            .trim(),
+    }))
+        .filter((event) => !isRuntimeNoise(event.text))
+        .slice(0, 80);
+    const userInputs = userInputTexts(events);
+    const candidates = [];
+    const decisions = outputs.filter((event) => /\bdecision\s*:/i.test(event.text));
+    if (decisions.length)
+        candidates.push({
+            signalType: "explicit-decision",
+            summary: decisions[0].text.slice(0, 500),
+            refs: decisions.slice(0, 4).map((event) => `event:${event.id}`),
+            confidence: 0.9,
+        });
+    const counts = new Map();
+    for (const event of outputs) {
+        const normalized = event.text.toLocaleLowerCase();
+        const current = counts.get(normalized) ?? { count: 0, refs: [] };
+        current.count += 1;
+        current.refs.push(`event:${event.id}`);
+        counts.set(normalized, current);
+    }
+    const repeated = [...counts.entries()].find(([, value]) => value.count >= 2);
+    if (repeated)
+        candidates.push({
+            signalType: "repeated-procedure",
+            summary: repeated[0].slice(0, 500),
+            refs: repeated[1].refs.slice(0, 4),
+            confidence: 0.8,
+        });
+    const corrections = userInputs.filter((event) => CORRECTION_PATTERN.test(event.text));
+    if (corrections.length)
+        candidates.push({
+            signalType: "repeated-correction",
+            summary: corrections[0].text.slice(0, 500),
+            refs: corrections.slice(0, 4).map((event) => `event:${event.id}`),
+            confidence: 0.7,
+        });
+    return candidates;
+}
+//# sourceMappingURL=signal-detection.js.map

package/node_modules/@ocean/market/dist/skills/skill-curation.js

@@ -0,0 +1,123 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { redactRuntimeText } from "@ocean/core/domain/redaction/redaction.js";
+import { truncateUtf8 } from "@ocean/core/shared/fs-utils.js";
+import { oceanPath, SYSTEM_DIR } from "@ocean/core/shared/paths.js";
+const file = () => oceanPath(SYSTEM_DIR, "skills", "candidates.json");
+async function load() {
+    try {
+        return JSON.parse(await readFile(file(), "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+}
+async function save(items) {
+    await mkdir(path.dirname(file()), { recursive: true });
+    await writeFile(file(), `${JSON.stringify(items, null, 2)}\n`, {
+        mode: 0o600,
+    });
+}
+export async function addSkillCandidate(candidate) {
+    if (!candidate.id ||
+        !candidate.name ||
+        !candidate.instructions ||
+        candidate.instructions.length > 32_000 ||
+        /(api[_ -]?key|token|password|secret)\s*[:=]/i.test(candidate.instructions))
+        throw new Error("Invalid or sensitive skill candidate");
+    const items = await load();
+    if (items.some((item) => item.id === candidate.id || item.name === candidate.name))
+        throw new Error("Duplicate skill candidate");
+    const result = {
+        ...candidate,
+        version: "1.0.0",
+        status: "candidate",
+        verification: "unverified",
+        createdAt: new Date().toISOString(),
+    };
+    await save([...items, result]);
+    return result;
+}
+export async function listSkillCandidates() {
+    return load();
+}
+export async function loadPromotedSkills(prompt, maxBytes = 32_000) {
+    const normalizedPrompt = prompt.toLocaleLowerCase();
+    const candidates = (await load()).filter((candidate) => candidate.status === "promoted" &&
+        candidate.verification === "owner-reviewed");
+    const selected = [];
+    let bytes = 0;
+    for (const candidate of candidates) {
+        const aliases = [candidate.id, candidate.name].map((value) => value.toLocaleLowerCase().replaceAll("-", " "));
+        if (!aliases.some((alias) => normalizedPrompt.includes(alias)))
+            continue;
+        const remaining = maxBytes - bytes;
+        if (remaining <= 0)
+            break;
+        const size = Buffer.byteLength(candidate.instructions);
+        if (size <= remaining) {
+            selected.push({ ...candidate, truncated: false });
+            bytes += size;
+            continue;
+        }
+        // A usable pointer: the store file and the command that prints it. The store is not
+        // granted to restricted providers because it also holds unreviewed candidates.
+        const marker = `\n[truncated to the run budget; full text: entry id "${candidate.id}" in \`ocean skill list\` or ${file()}]`;
+        const markerBytes = Buffer.byteLength(marker);
+        if (remaining <= markerBytes)
+            break;
+        const instructions = `${truncateUtf8(candidate.instructions, remaining - markerBytes)}${marker}`;
+        selected.push({ ...candidate, instructions, truncated: true });
+        bytes += Buffer.byteLength(instructions);
+    }
+    return selected;
+}
+export async function learnSkillFromSession(sessionId, openStore) {
+    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 teach a skill: ${session.status}`);
+        if (!store
+            .listEvents(sessionId)
+            .some((event) => event.type === "evidence" &&
+            /"result"\s*:\s*"proven"/.test(event.data)))
+            throw new Error("Session lacks independently recorded successful evidence");
+        const instructions = store
+            .listEvents(sessionId)
+            .filter((event) => event.type === "provider_output" ||
+            event.type === "text" ||
+            event.type === "json")
+            .map((event) => redactRuntimeText(event.data).trim())
+            .filter(Boolean)
+            .join("\n\n")
+            .slice(0, 32_000);
+        if (!instructions)
+            throw new Error("Session has no provider output to learn from");
+        const id = `learned-${session.provider}-${sessionId.slice(0, 8)}`;
+        return addSkillCandidate({
+            id,
+            name: `Learned ${session.provider} skill`,
+            instructions,
+            sourceSessionId: sessionId,
+        });
+    }
+    finally {
+        store.close();
+    }
+}
+export async function reviewSkillCandidate(id, status) {
+    const items = await load();
+    const item = items.find((candidate) => candidate.id === id);
+    if (!item)
+        throw new Error(`Skill candidate not found: ${id}`);
+    item.status = status;
+    item.verification = status === "promoted" ? "owner-reviewed" : "unverified";
+    await save(items);
+    return item;
+}
+//# sourceMappingURL=skill-curation.js.map

package/node_modules/@ocean/market/dist/skills/skill-hub.js

@@ -0,0 +1,220 @@
+import { createHash } from "node:crypto";
+import { cp, lstat, mkdir, readdir, readFile, readlink, rename, rm, stat, symlink, } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { enginePath, oceanPath, SYSTEM_DIR } from "@ocean/core/shared/paths.js";
+import { clientSkillRoots } from "./core-skill-sync.js";
+// The hub is the one place skills live inside Ocean. Clients hold symlinks into it, so
+// there is a single copy to edit and nothing drifts per client.
+export function skillHubRoot() {
+    return oceanPath(SYSTEM_DIR, "skills");
+}
+async function skillDirectories(root) {
+    const names = [];
+    for (const entry of await readdir(root, { withFileTypes: true })) {
+        // Follow symlinks: a client may expose another store's skills as links.
+        const full = path.join(root, entry.name);
+        const isDirectory = entry.isDirectory() || (await stat(full)).isDirectory();
+        if (!isDirectory)
+            continue;
+        try {
+            await stat(path.join(full, "SKILL.md"));
+            names.push(entry.name);
+        }
+        catch {
+            /* not a skill directory */
+        }
+    }
+    return names.sort();
+}
+// Additive: copies the engine's core skills and any extra source folders into the hub.
+// An existing hub skill is never overwritten.
+export async function populateSkillHub(extraSources = []) {
+    const hub = skillHubRoot();
+    await mkdir(hub, { recursive: true });
+    const added = [];
+    const kept = [];
+    for (const source of [enginePath("skills", "core"), ...extraSources]) {
+        for (const name of await skillDirectories(source)) {
+            const target = path.join(hub, name);
+            try {
+                await lstat(target);
+                kept.push(name);
+            }
+            catch {
+                await cp(path.join(source, name), target, {
+                    recursive: true,
+                    dereference: true,
+                });
+                added.push(name);
+            }
+        }
+    }
+    return { added, kept };
+}
+// Dry run unless `apply`. Skills a client does not already have are only added with `all`:
+// every extra skill costs that client always-on context. A real directory (or a link elsewhere) already at the target is
+// moved into a timestamped backup under the bridge archive before the link is made.
+export async function linkClientSkills(options) {
+    const home = options.home ?? os.homedir();
+    const hub = options.hub ?? skillHubRoot();
+    const backup = path.join(oceanPath(SYSTEM_DIR, "archive"), `skills-backup-${new Date().toISOString().replace(/[:.]/g, "-")}`);
+    const actions = [];
+    let backedUp = false;
+    const names = await skillDirectories(hub);
+    for (const client of Object.keys(clientSkillRoots)) {
+        const root = clientSkillRoots[client](home);
+        try {
+            await stat(root);
+        }
+        catch {
+            continue; // client not installed
+        }
+        for (const skill of names) {
+            const target = path.join(root, skill);
+            const wanted = path.join(hub, skill);
+            let action = "create";
+            try {
+                const info = await lstat(target);
+                if (info.isSymbolicLink() &&
+                    path.resolve(root, await readlink(target)) === wanted) {
+                    action = "linked";
+                }
+                else {
+                    action = "replace";
+                }
+            }
+            catch {
+                /* absent */
+            }
+            if (action === "create" && !options.all)
+                action = "skip";
+            actions.push({ client, skill, action });
+            if (!options.apply || action === "linked" || action === "skip")
+                continue;
+            if (action === "replace") {
+                const saved = path.join(backup, client);
+                await mkdir(saved, { recursive: true });
+                await rename(target, path.join(saved, skill));
+                backedUp = true;
+            }
+            await symlink(wanted, target, "dir");
+        }
+    }
+    return { actions, backup: backedUp ? backup : null };
+}
+// Clients that get the hub's skills as copies. Hermes manages its own bundle and curator,
+// so it is left alone unless asked for by name.
+export const COPY_CLIENTS = [
+    "claude",
+    "codex",
+    "gemini",
+    "hermes",
+];
+// Content hash of a whole skill directory: paths and bytes, so a changed script or reference
+// counts as drift, not only SKILL.md.
+// A symlink inside a skill is refused: copying it would either dereference into data outside
+// the hub or leave a dangling link in the client, and a loop would never finish.
+async function directoryHash(directory) {
+    const hash = createHash("sha256");
+    async function walk(current, prefix) {
+        const entries = (await readdir(current, { withFileTypes: true })).sort((left, right) => left.name.localeCompare(right.name));
+        for (const entry of entries) {
+            const full = path.join(current, entry.name);
+            const relative = path.posix.join(prefix, entry.name);
+            const info = await lstat(full);
+            if (info.isSymbolicLink())
+                throw new Error(`${relative} is a symlink inside a skill`);
+            if (info.isDirectory())
+                await walk(full, relative);
+            else
+                hash.update(relative).update(await readFile(full));
+        }
+    }
+    await walk(directory, "");
+    return hash.digest("hex");
+}
+// Gives every client a real copy of every hub skill, replacing the symlink farm. Dry run
+// unless `apply`. A symlink is only unlinked (its target is untouched); a real directory
+// that differs from the hub is moved into a timestamped backup, never deleted. Anything in a
+// client that the hub does not name is left alone.
+export async function copyClientSkills(options) {
+    const home = options.home ?? os.homedir();
+    const hub = options.hub ?? skillHubRoot();
+    const backup = path.join(options.archive ?? oceanPath(SYSTEM_DIR, "archive"), `skills-backup-${new Date().toISOString().replace(/[:.]/g, "-")}`);
+    const actions = [];
+    let backedUp = false;
+    const names = await skillDirectories(hub);
+    for (const client of options.clients ?? COPY_CLIENTS) {
+        const root = clientSkillRoots[client](home);
+        try {
+            await stat(root);
+        }
+        catch {
+            continue; // client not installed
+        }
+        for (const skill of names) {
+            const target = path.join(root, skill);
+            const source = path.join(hub, skill);
+            try {
+                let action = "create";
+                let info = null;
+                try {
+                    info = await lstat(target);
+                }
+                catch {
+                    /* absent */
+                }
+                const wanted = await directoryHash(source);
+                let ours = false;
+                if (info?.isSymbolicLink()) {
+                    action = "unlink";
+                    // A link into the hub holds nothing of its own. Any other link is moved into the
+                    // backup (the link itself, intact) so what it pointed at stays reachable.
+                    ours = path
+                        .resolve(root, await readlink(target))
+                        .startsWith(hub + path.sep);
+                }
+                else if (info) {
+                    action =
+                        info.isDirectory() && (await directoryHash(target)) === wanted
+                            ? "synchronized"
+                            : "replace";
+                }
+                actions.push({ client, skill, action });
+                if (!options.apply || action === "synchronized")
+                    continue;
+                if (action === "replace" || (action === "unlink" && !ours)) {
+                    const saved = path.join(backup, client);
+                    await mkdir(saved, { recursive: true });
+                    await rename(target, path.join(saved, skill));
+                    backedUp = true;
+                }
+                else if (action === "unlink")
+                    await rm(target);
+                // Copy beside the target and rename, so a failed copy never leaves a half skill.
+                const staging = path.join(root, `.${skill}.copying`);
+                await rm(staging, { recursive: true, force: true });
+                try {
+                    await cp(source, staging, { recursive: true });
+                    await rename(staging, target);
+                }
+                catch (error) {
+                    await rm(staging, { recursive: true, force: true });
+                    throw error;
+                }
+            }
+            catch (error) {
+                // One bad skill must not abort the run halfway through every client.
+                actions.push({
+                    client,
+                    skill,
+                    action: "failed",
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+    }
+    return { actions, backup: backedUp ? backup : null };
+}
+//# sourceMappingURL=skill-hub.js.map