@amoree-code/ocean 0.0.0-stage → 1.1.0

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

@@ -0,0 +1,587 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { clientSkillRoots, } from "@ocean/market/skills/core-skill-sync.js";
+// Read-only measurement of each client's always-on context: the text an interactive client
+// loads on every request before the user types anything (global rules, an auto-loaded memory
+// index, the frontmatter of every model-visible skill, and for Claude its commands, agents
+// and enabled plugins). Reports only display paths (~/...),
+// byte counts and fixed notes — never file contents and never raw error messages, which can
+// carry absolute paths.
+export const DEFAULT_CONTEXT_BUDGET = 12_288;
+// Keyed by every SkillClient, so TypeScript forces an entry when a client is added.
+const clientSources = {
+    claude: {
+        rules: [".claude/CLAUDE.md"],
+        imports: true,
+        nested: false,
+        skillsRoot: clientSkillRoots.claude,
+        notes: ["project-level CLAUDE.md/AGENTS.md walk-up is not measured"],
+    },
+    codex: {
+        rules: [".codex/AGENTS.override.md", ".codex/AGENTS.md"],
+        imports: false,
+        nested: true,
+        skillsRoot: clientSkillRoots.codex,
+        notes: ["assumed: AGENTS.override.md precedence and ~/.agents usage"],
+    },
+    gemini: {
+        rules: [".gemini/GEMINI.md"],
+        imports: true,
+        nested: false,
+        skillsRoot: clientSkillRoots.gemini,
+        notes: [],
+    },
+    hermes: {
+        rules: [".hermes/SOUL.md"],
+        imports: false,
+        nested: true,
+        skillsRoot: clientSkillRoots.hermes,
+        notes: [
+            "assumed: SOUL.md is the always-on rules file",
+            "memories are not counted (auto-load unverified)",
+        ],
+    },
+    cursor: {
+        rules: [],
+        imports: false,
+        nested: false,
+        skillsRoot: clientSkillRoots.cursor,
+        notes: ["user rules live in the app settings store, not a file"],
+    },
+    antigravity: {
+        rules: [],
+        imports: false,
+        nested: false,
+        skillsRoot: clientSkillRoots.antigravity,
+        notes: ["global rules location not known to the engine"],
+    },
+    agents: {
+        rules: [],
+        imports: false,
+        nested: false,
+        skillsRoot: (home) => path.join(home, ".agents", "skills"),
+        shared: true,
+        notes: [
+            "shared skills root; clients that symlink into it count the same files",
+        ],
+    },
+};
+export function displayPath(abs, home) {
+    const relative = path.relative(home, abs);
+    if (!relative)
+        return "~";
+    if (!relative.startsWith("..") && !path.isAbsolute(relative))
+        return `~/${relative.split(path.sep).join("/")}`;
+    return `<outside-home>/${path.basename(abs)}`;
+}
+async function sizeOf(file) {
+    try {
+        const info = await stat(file);
+        return info.isFile() ? info.size : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function isDirectory(target) {
+    try {
+        return (await stat(target)).isDirectory();
+    }
+    catch {
+        return null;
+    }
+}
+const IMPORT_TOKEN = /(?:^|\s)@(\S+)/g;
+// `@path` tokens outside code fences and inline code spans that look like a path (so
+// `@handle` mentions are ignored).
+function importTargets(text) {
+    const targets = [];
+    let fenced = false;
+    for (const raw of text.split("\n")) {
+        if (raw.trimStart().startsWith("```")) {
+            fenced = !fenced;
+            continue;
+        }
+        if (fenced)
+            continue;
+        const line = raw.replace(/`[^`]*`/g, " ");
+        for (const match of line.matchAll(IMPORT_TOKEN)) {
+            const token = match[1];
+            if (/^(~\/|\.\/|\.\.\/|\/)/.test(token) ||
+                token.includes("/") ||
+                token.endsWith(".md"))
+                targets.push(token);
+        }
+    }
+    return targets;
+}
+function resolveImport(token, includer, home) {
+    if (token.startsWith("~/"))
+        return path.join(home, token.slice(2));
+    if (path.isAbsolute(token))
+        return token;
+    return path.resolve(path.dirname(includer), token);
+}
+async function measureRules(sources, home) {
+    if (!sources.rules.length)
+        return [];
+    let chosen = null;
+    let bytes = null;
+    for (const candidate of sources.rules) {
+        const file = path.join(home, candidate);
+        bytes = await sizeOf(file);
+        if (bytes !== null) {
+            chosen = file;
+            break;
+        }
+    }
+    if (chosen === null || bytes === null) {
+        const canonical = path.join(home, sources.rules[sources.rules.length - 1]);
+        return [{ path: displayPath(canonical, home), bytes: 0, missing: true }];
+    }
+    const rules = [{ path: displayPath(chosen, home), bytes }];
+    if (!sources.imports)
+        return rules;
+    let text;
+    try {
+        text = await readFile(chosen, "utf8");
+    }
+    catch {
+        rules[0].unreadable = true;
+        return rules;
+    }
+    const seen = new Set([chosen]);
+    const via = displayPath(chosen, home);
+    for (const token of importTargets(text)) {
+        const target = resolveImport(token, chosen, home);
+        if (seen.has(target))
+            continue;
+        seen.add(target);
+        const size = await sizeOf(target);
+        rules.push(size === null
+            ? { path: displayPath(target, home), bytes: 0, via, missing: true }
+            : { path: displayPath(target, home), bytes: size, via });
+    }
+    return rules;
+}
+// Walks up the path string (never realpath'd, matching how the slug is built) to the nearest
+// `.git`. A `.git` directory marks the root; a `.git` file is a linked worktree (or a
+// submodule), followed through `gitdir:` and `commondir` to the main checkout when it has
+// one. Only git metadata is read, and nothing from it is reported.
+async function memoryProjectRoot(projectDir) {
+    let current = projectDir;
+    for (;;) {
+        const dotGit = path.join(current, ".git");
+        const info = await stat(dotGit).catch(() => null);
+        if (info?.isDirectory())
+            return current;
+        if (info?.isFile())
+            return (await worktreeMainRoot(dotGit)) ?? current;
+        const parent = path.dirname(current);
+        if (parent === current)
+            return projectDir;
+        current = parent;
+    }
+}
+async function worktreeMainRoot(dotGitFile) {
+    try {
+        const match = /^gitdir:[ \t]*(.+)$/m.exec(await readFile(dotGitFile, "utf8"));
+        if (!match)
+            return null;
+        const gitDir = path.resolve(path.dirname(dotGitFile), match[1].trim());
+        const commonDir = path.resolve(gitDir, (await readFile(path.join(gitDir, "commondir"), "utf8")).trim());
+        return path.basename(commonDir) === ".git" ? path.dirname(commonDir) : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function measureMemory(client, home, projectDir, notes) {
+    if (client !== "claude")
+        return [];
+    if (!projectDir) {
+        notes.push("claude per-project memory skipped; pass --project <dir>");
+        return [];
+    }
+    // Claude keys auto-memory by the project's git repository root (every subdirectory and
+    // worktree of one repo shares it), falling back to the directory itself outside a repo.
+    // The slug is that path string with every non-alphanumeric character replaced by '-'. It
+    // encodes an absolute path, so it is never displayed.
+    const slug = (await memoryProjectRoot(projectDir)).replace(/[^a-zA-Z0-9]/g, "-");
+    const file = path.join(home, ".claude", "projects", slug, "memory", "MEMORY.md");
+    const display = "~/.claude/projects/<project-slug>/memory/MEMORY.md";
+    notes.push("Claude loads up to the first 200 lines; whole-file bytes shown");
+    const bytes = await sizeOf(file);
+    return bytes === null
+        ? [{ path: display, bytes: 0, missing: true }]
+        : [{ path: display, bytes }];
+}
+// Frontmatter is the leading `---` line through the closing `---` line inclusive.
+function frontmatterBytes(buffer) {
+    const text = buffer.toString("utf8");
+    const open = /^---[ \t]*\r?\n/.exec(text);
+    if (!open)
+        return 0;
+    const close = /\n---[ \t]*(\r?\n|$)/.exec(text.slice(open[0].length - 1));
+    if (!close)
+        return 0;
+    const end = open[0].length - 1 + close.index + close[0].length;
+    return Buffer.byteLength(text.slice(0, end));
+}
+// The `name:` and `disable-model-invocation:` of a frontmatter block — all the listing rules
+// need. A missing name falls back to the directory or file name.
+function frontmatterFields(buffer, bytes) {
+    const text = buffer.subarray(0, bytes).toString("utf8");
+    const name = /^name:[ \t]*["']?([^"'\r\n]+?)["']?[ \t]*$/m.exec(text)?.[1];
+    return {
+        name: name ?? null,
+        modelHidden: /^disable-model-invocation:[ \t]*true[ \t]*$/m.test(text),
+    };
+}
+// Claude's `skillOverrides` values that keep a skill out of the model's listing.
+const HIDDEN_OVERRIDES = new Set(["off", "user-invocable-only"]);
+async function readClaudeSettings(home, notes) {
+    const settings = { hidden: new Set(), enabledPlugins: [] };
+    let parsed;
+    try {
+        parsed = JSON.parse(await readFile(path.join(home, ".claude", "settings.json"), "utf8"));
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            notes.push("settings.json unreadable; skill overrides not applied");
+        return settings;
+    }
+    if (!parsed || typeof parsed !== "object")
+        return settings;
+    const { skillOverrides, enabledPlugins } = parsed;
+    if (skillOverrides && typeof skillOverrides === "object")
+        for (const [name, value] of Object.entries(skillOverrides))
+            if (typeof value === "string" && HIDDEN_OVERRIDES.has(value))
+                settings.hidden.add(name);
+    if (enabledPlugins && typeof enabledPlugins === "object")
+        settings.enabledPlugins = Object.entries(enabledPlugins)
+            .filter(([, enabled]) => enabled === true)
+            .map(([id]) => id);
+    return settings;
+}
+// The skills the owner hid from Claude's model; `ocean client sync` hides the same ones from
+// Codex and Gemini.
+export async function claudeHiddenSkills(home = os.homedir()) {
+    return (await readClaudeSettings(home, [])).hidden;
+}
+// The SKILL.md paths that `~/.codex/config.toml` disables with
+// `[[skills.config]] path = "..." enabled = false`.
+export async function codexDisabledSkillPaths(home = os.homedir()) {
+    const disabled = new Set();
+    let text;
+    try {
+        text = await readFile(path.join(home, ".codex", "config.toml"), "utf8");
+    }
+    catch {
+        return disabled;
+    }
+    let entry = null;
+    const flush = () => {
+        if (entry?.path && entry.enabled === false)
+            disabled.add(path.resolve(entry.path));
+    };
+    for (const raw of text.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (line.startsWith("[")) {
+            flush();
+            entry = line === "[[skills.config]]" ? {} : null;
+            continue;
+        }
+        if (!entry)
+            continue;
+        const value = /^path\s*=\s*("(?:[^"\\]|\\.)*"|'[^']*')\s*(#.*)?$/.exec(line)?.[1];
+        if (value)
+            try {
+                entry.path = value.startsWith("'")
+                    ? value.slice(1, -1)
+                    : JSON.parse(value);
+            }
+            catch {
+                // An unreadable path disables nothing.
+            }
+        const enabled = /^enabled\s*=\s*(true|false)\s*(#.*)?$/.exec(line)?.[1];
+        if (enabled)
+            entry.enabled = enabled === "true";
+    }
+    flush();
+    return disabled;
+}
+const unquoteName = (value) => value.trim().replace(/^(["'])(.*)\1$/, "$2");
+export function readHermesDisabled(text) {
+    const lines = text.split("\n");
+    const skills = lines.findIndex((line) => /^skills:\s*(#.*)?$/.test(line));
+    if (skills < 0)
+        return lines.some((line) => /^skills\s*:/.test(line))
+            ? null
+            : { names: [], lines, skills: -1, disabled: null, indent: "  " };
+    let end = skills + 1;
+    while (end < lines.length && !/^[^\s#]/.test(lines[end]))
+        end += 1;
+    const child = lines
+        .slice(skills + 1, end)
+        .find((line) => /^\s+[^\s#]/.test(line));
+    const indent = child?.match(/^\s+/)?.[0] ?? "  ";
+    const key = lines.findIndex((line, index) => index > skills &&
+        index < end &&
+        line.startsWith(`${indent}disabled:`) &&
+        !line.startsWith(`${indent} `));
+    if (key < 0)
+        return { names: [], lines, skills, disabled: null, indent };
+    const value = lines[key]
+        .slice(`${indent}disabled:`.length)
+        .replace(/\s+#.*$/, "")
+        .trim();
+    if (value.startsWith("[") && value.endsWith("]")) {
+        const inner = value.slice(1, -1).trim();
+        const names = inner ? inner.split(",").map(unquoteName) : [];
+        return names.every((name) => /^[\w.:-]+$/.test(name))
+            ? { names, lines, skills, disabled: [key, key + 1], indent }
+            : null;
+    }
+    if (value)
+        return null;
+    const names = [];
+    let next = key + 1;
+    for (; next < end; next += 1) {
+        const line = lines[next];
+        if (!line.trim() || /^\s*#/.test(line))
+            continue;
+        const item = /^(\s*)-\s+(.+?)\s*$/.exec(line);
+        if (!item || item[1].length < indent.length)
+            break;
+        const name = unquoteName(item[2]);
+        if (!/^[\w.:-]+$/.test(name))
+            return null;
+        names.push(name);
+    }
+    // Trailing blank lines stay outside the range.
+    while (next > key + 1 && !lines[next - 1].trim())
+        next -= 1;
+    return { names, lines, skills, disabled: [key, next], indent };
+}
+export async function hermesDisabledSkills(home = os.homedir()) {
+    try {
+        const text = await readFile(path.join(home, ".hermes", "config.yaml"), "utf8");
+        return new Set(readHermesDisabled(text)?.names ?? []);
+    }
+    catch {
+        return new Set();
+    }
+}
+// The skill names `~/.gemini/settings.json` lists under `skills.disabled`.
+export async function geminiDisabledSkills(home = os.homedir()) {
+    try {
+        const parsed = JSON.parse(await readFile(path.join(home, ".gemini", "settings.json"), "utf8"));
+        const list = parsed?.skills?.disabled;
+        return new Set(Array.isArray(list)
+            ? list.filter((name) => typeof name === "string")
+            : []);
+    }
+    catch {
+        return new Set();
+    }
+}
+// One always-on listing: the frontmatter of every model-visible `*.md` (or `<dir>/SKILL.md`
+// when `skillDirs`) directly under `dir`. Hidden entries cost nothing.
+async function listingBytes(dir, options) {
+    let entries;
+    try {
+        entries = (await readdir(dir)).sort();
+    }
+    catch {
+        return 0;
+    }
+    let total = 0;
+    for (const entry of entries) {
+        if (entry.startsWith("."))
+            continue;
+        const file = options.skillDirs
+            ? path.join(dir, entry, "SKILL.md")
+            : entry.endsWith(".md")
+                ? path.join(dir, entry)
+                : null;
+        if (!file)
+            continue;
+        let buffer;
+        try {
+            buffer = await readFile(file);
+        }
+        catch {
+            continue;
+        }
+        const bytes = frontmatterBytes(buffer);
+        const fields = frontmatterFields(buffer, bytes);
+        const name = fields.name ?? entry.replace(/\.md$/, "");
+        if (fields.modelHidden || options.hidden(name))
+            continue;
+        total += bytes;
+    }
+    return total;
+}
+// Claude also lists custom commands, subagents and each enabled plugin's skills, commands
+// and agents on every request; each is reported as one line.
+async function measureClaudeExtras(home, settings, notes) {
+    const claude = path.join(home, ".claude");
+    const extras = [];
+    const add = (dir, bytes) => {
+        if (bytes)
+            extras.push({ path: displayPath(dir, home), bytes });
+    };
+    const userHidden = (name) => settings.hidden.has(name);
+    for (const kind of ["commands", "agents"])
+        add(path.join(claude, kind), await listingBytes(path.join(claude, kind), {
+            skillDirs: false,
+            hidden: userHidden,
+        }));
+    if (!settings.enabledPlugins.length)
+        return extras;
+    let installed = {};
+    try {
+        installed =
+            JSON.parse(await readFile(path.join(claude, "plugins", "installed_plugins.json"), "utf8")).plugins ?? {};
+    }
+    catch {
+        notes.push("installed_plugins.json unreadable; plugins not measured");
+        return extras;
+    }
+    for (const id of settings.enabledPlugins) {
+        const root = installed[id]?.[0]?.installPath;
+        if (typeof root !== "string")
+            continue;
+        const plugin = id.split("@")[0];
+        const hidden = (name) => settings.hidden.has(`${plugin}:${name}`) || settings.hidden.has(name);
+        let bytes = await listingBytes(path.join(root, "skills"), {
+            skillDirs: true,
+            hidden,
+        });
+        for (const kind of ["commands", "agents"])
+            bytes += await listingBytes(path.join(root, kind), {
+                skillDirs: false,
+                hidden,
+            });
+        add(root, bytes);
+    }
+    return extras;
+}
+async function measureSkills(sources, home, notes, hidden = () => false) {
+    const root = sources.skillsRoot(home);
+    const result = {
+        root: displayPath(root, home),
+        present: false,
+        count: 0,
+        frontmatterBytes: 0,
+        bodyBytes: 0,
+        hidden: 0,
+        hiddenFrontmatterBytes: 0,
+    };
+    let entries;
+    try {
+        if (!(await isDirectory(root)))
+            return result;
+        entries = (await readdir(root)).sort();
+    }
+    catch {
+        return result;
+    }
+    result.present = true;
+    let broken = 0;
+    const count = async (file) => {
+        try {
+            const buffer = await readFile(file);
+            const frontmatter = frontmatterBytes(buffer);
+            const fields = frontmatterFields(buffer, frontmatter);
+            const name = fields.name ?? path.basename(path.dirname(file));
+            if (fields.modelHidden || hidden(name, file)) {
+                result.hidden += 1;
+                result.hiddenFrontmatterBytes += frontmatter;
+                return;
+            }
+            result.count += 1;
+            result.frontmatterBytes += frontmatter;
+            result.bodyBytes += buffer.byteLength - frontmatter;
+        }
+        catch {
+            broken += 1;
+        }
+    };
+    for (const name of entries) {
+        if (name.startsWith(".") && !sources.nested)
+            continue;
+        const dir = path.join(root, name);
+        const directory = await isDirectory(dir);
+        if (directory === null) {
+            broken += 1;
+            continue;
+        }
+        if (!directory)
+            continue;
+        const skillFile = path.join(dir, "SKILL.md");
+        if ((await sizeOf(skillFile)) !== null) {
+            await count(skillFile);
+            continue;
+        }
+        if (!sources.nested)
+            continue;
+        let children;
+        try {
+            children = (await readdir(dir)).sort();
+        }
+        catch {
+            broken += 1;
+            continue;
+        }
+        for (const child of children) {
+            const nestedFile = path.join(dir, child, "SKILL.md");
+            if ((await sizeOf(nestedFile)) !== null)
+                await count(nestedFile);
+        }
+    }
+    if (broken)
+        notes.push(`${broken} unreadable or broken skill entries skipped`);
+    return result;
+}
+export async function measureContextCost(options = {}) {
+    const home = options.home ?? os.homedir();
+    const projectDir = options.projectDir ?? null;
+    const budget = options.budget ?? DEFAULT_CONTEXT_BUDGET;
+    const clients = [];
+    for (const client of Object.keys(clientSources)) {
+        const sources = clientSources[client];
+        const notes = [...sources.notes];
+        const rules = await measureRules(sources, home);
+        const memory = await measureMemory(client, home, projectDir, notes);
+        const claude = client === "claude" ? await readClaudeSettings(home, notes) : null;
+        const codexOff = client === "codex" ? await codexDisabledSkillPaths(home) : null;
+        const geminiOff = client === "gemini" ? await geminiDisabledSkills(home) : null;
+        const hermesOff = client === "hermes" ? await hermesDisabledSkills(home) : null;
+        const skills = await measureSkills(sources, home, notes, (name, file) => Boolean(claude?.hidden.has(name) ||
+            codexOff?.has(path.resolve(file)) ||
+            geminiOff?.has(name) ||
+            hermesOff?.has(name)));
+        const extras = claude ? await measureClaudeExtras(home, claude, notes) : [];
+        const alwaysOnBytes = [...rules, ...memory, ...extras].reduce((total, file) => total + file.bytes, 0) + skills.frontmatterBytes;
+        clients.push({
+            client,
+            shared: sources.shared ?? false,
+            rules,
+            memory,
+            skills,
+            extras,
+            alwaysOnBytes,
+            overBudget: alwaysOnBytes > budget,
+            notes,
+        });
+    }
+    return {
+        budget,
+        project: projectDir ? displayPath(projectDir, home) : null,
+        clients,
+    };
+}
+//# sourceMappingURL=context-cost.js.map