turntax 0.1.0 → 0.3.0

package/dist/core/diff.js

@@ -0,0 +1,63 @@
+export function diffReports(before, after, base) {
+    const ids = [...new Set([...after.tools.map((t) => t.tool), ...before.tools.map((t) => t.tool)])];
+    const tools = ids.map((id) => {
+        const a = after.tools.find((t) => t.tool === id);
+        const b = before.tools.find((t) => t.tool === id);
+        const av = a?.perTurnO200k ?? null;
+        const bv = b?.perTurnO200k ?? null;
+        return { tool: id, name: (a ?? b).name, before: bv, after: av, delta: (av ?? 0) - (bv ?? 0) };
+    });
+    const alwaysFiles = (r) => {
+        const m = new Map();
+        for (const f of r.files) {
+            if (f.mode !== 'always' || f.scope === 'user')
+                continue;
+            const key = `${f.path}\0${f.part}`;
+            const prev = m.get(key);
+            if (prev)
+                prev.tools.add(f.tool);
+            else
+                m.set(key, { path: f.path, part: f.part, o200k: f.o200k, tools: new Set([f.tool]) });
+        }
+        return m;
+    };
+    const bf = alwaysFiles(before);
+    const af = alwaysFiles(after);
+    const files = [];
+    for (const key of new Set([...bf.keys(), ...af.keys()])) {
+        const b = bf.get(key);
+        const a = af.get(key);
+        const delta = (a?.o200k ?? 0) - (b?.o200k ?? 0);
+        if (a && b && delta === 0)
+            continue;
+        files.push({
+            path: (a ?? b).path,
+            part: (a ?? b).part,
+            before: b?.o200k ?? null,
+            after: a?.o200k ?? null,
+            delta,
+            tools: [...new Set([...(b?.tools ?? []), ...(a?.tools ?? [])])],
+        });
+    }
+    files.sort((x, y) => Math.abs(y.delta) - Math.abs(x.delta) || x.path.localeCompare(y.path));
+    const servers = (r) => new Set((r.mcp ?? []).filter((s) => s.scope === 'project' && s.status !== 'disabled').map((s) => `${s.name} (${s.tool})`));
+    const bs = servers(before);
+    const as = servers(after);
+    return {
+        base,
+        tools,
+        files,
+        mcp: { added: [...as].filter((s) => !bs.has(s)), removed: [...bs].filter((s) => !as.has(s)) },
+    };
+}
+/** Largest per-turn increase across agents (0 when nothing grew). */
+export function maxIncrease(diff) {
+    return Math.max(0, ...diff.tools.map((t) => t.delta));
+}
+/** Validates a parsed JSON report enough to diff against it. */
+export function asDiffInput(data) {
+    const r = data;
+    if (!r || !Array.isArray(r.tools) || !Array.isArray(r.files))
+        throw new Error('not a turntax --json report');
+    return r;
+}

package/dist/core/files.js

@@ -1,5 +1,5 @@
 /** Which repository paths can hold agent instructions. Shared by the CLI and the web page. */
-import { findImports, resolvePath } from './markdown.js';
+import { configList, findImports, resolvePath } from './markdown.js';
 export const SKIP_DIRS = new Set([
     'node_modules',
     '.git',
@@ -30,6 +30,13 @@ const NAMES = new Set([
     'GEMINI.md',
     '.cursorrules',
     '.windsurfrules',
+    '.clinerules',
+    '.roorules',
+    '.rules',
+    'AGENT.md',
+    'CONVENTIONS.md',
+    '.goosehints',
+    '.aider.conf.yml',
 ]);
 const PATTERNS = [
     /^\.github\/copilot-instructions\.md$/,
@@ -40,6 +47,13 @@ const PATTERNS = [
     /(^|\/)\.agents\/skills\/[^/]+\/SKILL\.md$/,
     /(^|\/)\.cursor\/rules\/.+\.mdc?$/,
     /(^|\/)\.(devin|windsurf)\/rules\/.+\.md$/,
+    /^\.(clinerules|cline\/rules)\/.+\.md$/,
+    /^\.roo\/rules(-[\w-]+)?\/.+\.(md|txt)$/,
+    /^\.roorules-[\w-]+$/,
+    /^\.kiro\/steering\/[^/]+\.md$/,
+    /^\.junie\/(AGENTS|playbook|guidelines)\.md$/,
+    /^\.junie\/(rules|guidelines)\/[^/]+\.md$/,
+    /^\.continue\/rules\/[^/]+\.md$/,
 ];
 export const MAX_DEPTH = 12;
 export function isInstructionFile(path) {
@@ -51,15 +65,22 @@ export function isSkippedDir(path) {
     const name = path.slice(path.lastIndexOf('/') + 1);
     return SKIP_DIRS.has(name) || path === '.claude/worktrees' || path.endsWith('/.claude/worktrees');
 }
-/** Adds in-repo files reached through @imports (up to five levels) to `found`. */
+/** Files a file pulls in: its @imports, or the read: list of .aider.conf.yml. */
+function references(f) {
+    if (f.path === '.aider.conf.yml')
+        return configList(f, 'read');
+    return findImports(f.text)
+        .map((t) => resolvePath(f.path, t))
+        .filter((p) => p !== null);
+}
+/** Adds in-repo files reached through @imports or config read lists (up to five levels) to `found`. */
 export async function addImports(found, read) {
     let queue = [...found.values()];
     for (let depth = 0; depth < 5 && queue.length; depth++) {
         const next = [];
         for (const f of queue) {
-            for (const target of findImports(f.text)) {
-                const rel = resolvePath(f.path, target);
-                if (rel === null || found.has(rel))
+            for (const rel of references(f)) {
+                if (found.has(rel))
                     continue;
                 const text = await read(rel);
                 if (text === null)

package/dist/core/markdown.js

@@ -168,3 +168,13 @@ export function resolvePath(fromFile, target) {
     }
     return parts.join('/');
 }
+/** Paths listed under `key` in a small YAML config (string, inline list or block list). */
+export function configList(config, key) {
+    const value = parseFrontmatter(`---\n${config.text}\n---\n`).frontmatter[key];
+    const list = value === undefined || value === '' ? [] : Array.isArray(value) ? value : [String(value)];
+    return list
+        .map((p) => p.replace(/\s+#.*$/, '').trim())
+        .filter(Boolean)
+        .map((p) => resolvePath(config.path, p))
+        .filter((p) => p !== null);
+}

package/dist/core/mcp.js

@@ -0,0 +1,227 @@
+const CHECKED_AT = '2026-10-11';
+/** Where each agent reads MCP servers from. Paths and keys come from the cited pages. */
+export const MCP_CONFIGS = [
+    { tool: 'claude-code', path: '.mcp.json', scope: 'project', key: 'mcpServers', shape: 'standard', source: 'https://code.claude.com/docs/en/mcp' },
+    { tool: 'cursor', path: '.cursor/mcp.json', scope: 'project', key: 'mcpServers', shape: 'standard', source: 'https://cursor.com/docs/context/mcp' },
+    { tool: 'copilot', path: '.vscode/mcp.json', scope: 'project', key: 'servers', shape: 'vscode', source: 'https://code.visualstudio.com/docs/copilot/customization/mcp-servers' },
+    { tool: 'gemini-cli', path: '.gemini/settings.json', scope: 'project', key: 'mcpServers', shape: 'gemini', source: 'https://geminicli.com/docs/tools/mcp-server/' },
+    { tool: 'kiro', path: '.kiro/settings/mcp.json', scope: 'project', key: 'mcpServers', shape: 'standard', source: 'https://kiro.dev/docs/mcp/configuration/' },
+    { tool: 'roo-code', path: '.roo/mcp.json', scope: 'project', key: 'mcpServers', shape: 'standard', source: 'https://roocodeinc.github.io/Roo-Code/features/mcp/using-mcp-in-roo' },
+    { tool: 'opencode', path: 'opencode.json', scope: 'project', key: 'mcp', shape: 'opencode', source: 'https://opencode.ai/docs/mcp-servers/' },
+    { tool: 'opencode', path: 'opencode.jsonc', scope: 'project', key: 'mcp', shape: 'opencode', source: 'https://opencode.ai/docs/mcp-servers/' },
+    { tool: 'zed', path: '.zed/settings.json', scope: 'project', key: 'context_servers', shape: 'zed', source: 'https://zed.dev/docs/ai/mcp' },
+    { tool: 'codex', path: '.codex/config.toml', scope: 'project', key: 'mcp_servers', shape: 'codex-toml', source: 'https://learn.chatgpt.com/docs/extend/mcp' },
+    { tool: 'claude-code', path: '.claude.json', scope: 'user', key: 'mcpServers', shape: 'claude-json', source: 'https://code.claude.com/docs/en/mcp' },
+    { tool: 'cursor', path: '.cursor/mcp.json', scope: 'user', key: 'mcpServers', shape: 'standard', source: 'https://cursor.com/docs/context/mcp' },
+    { tool: 'gemini-cli', path: '.gemini/settings.json', scope: 'user', key: 'mcpServers', shape: 'gemini', source: 'https://geminicli.com/docs/tools/mcp-server/' },
+    { tool: 'kiro', path: '.kiro/settings/mcp.json', scope: 'user', key: 'mcpServers', shape: 'standard', source: 'https://kiro.dev/docs/mcp/configuration/' },
+    { tool: 'windsurf', path: '.config/devin/mcp_config.json', scope: 'user', key: 'mcpServers', shape: 'standard', source: 'https://docs.devin.ai/desktop/cascade/mcp' },
+    { tool: 'windsurf', path: 'AppData/Roaming/devin/mcp_config.json', scope: 'user', key: 'mcpServers', shape: 'standard', source: 'https://docs.devin.ai/desktop/cascade/mcp' },
+    { tool: 'codex', path: '.codex/config.toml', scope: 'user', key: 'mcp_servers', shape: 'codex-toml', source: 'https://learn.chatgpt.com/docs/extend/mcp' },
+    { tool: 'opencode', path: '.config/opencode/opencode.json', scope: 'user', key: 'mcp', shape: 'opencode', source: 'https://opencode.ai/docs/mcp-servers/' },
+];
+export const MCP_CHECKED_AT = CHECKED_AT;
+/** True for a repo-relative path that holds project MCP servers for some agent. */
+export function isMcpConfigFile(path) {
+    return MCP_CONFIGS.some((c) => c.scope === 'project' && c.path === path);
+}
+/** Home-relative paths of user-level MCP configs. */
+export const USER_MCP_PATHS = [...new Set(MCP_CONFIGS.filter((c) => c.scope === 'user').map((c) => c.path))];
+/** JSON with comments and trailing commas (VS Code, Zed and OpenCode accept both). */
+export function parseJsonc(text) {
+    let out = '';
+    let inString = false;
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (inString) {
+            out += c;
+            if (c === '\\')
+                out += text[++i] ?? '';
+            else if (c === '"')
+                inString = false;
+        }
+        else if (c === '"') {
+            inString = true;
+            out += c;
+        }
+        else if (c === '/' && text[i + 1] === '/') {
+            while (i < text.length && text[i] !== '\n')
+                i++;
+            out += '\n';
+        }
+        else if (c === '/' && text[i + 1] === '*') {
+            i = text.indexOf('*/', i + 2);
+            if (i < 0)
+                break;
+            i++;
+        }
+        else
+            out += c;
+    }
+    return JSON.parse(out.replace(/,(\s*[}\]])/g, '$1').replace(/^/, ''));
+}
+const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const strings = (v) => (Array.isArray(v) ? v.map(String) : undefined);
+const record = (v) => isObj(v) ? Object.fromEntries(Object.entries(v).map(([k, x]) => [k, String(x)])) : undefined;
+function fromStandard(name, v, gemini = false) {
+    const type = String(v.type ?? v.transport ?? '').toLowerCase();
+    // Gemini CLI has no type field: `httpUrl` is streamable HTTP and `url` is SSE.
+    // Elsewhere `url` (Windsurf: `serverUrl`) is streamable HTTP unless the type says SSE.
+    const httpUrl = typeof v.httpUrl === 'string' ? v.httpUrl : undefined;
+    const url = httpUrl ?? (typeof v.url === 'string' ? v.url : typeof v.serverUrl === 'string' ? v.serverUrl : undefined);
+    const transport = !url ? 'stdio' : httpUrl ? 'http' : gemini || type === 'sse' ? 'sse' : 'http';
+    return {
+        name,
+        transport,
+        command: typeof v.command === 'string' ? v.command : undefined,
+        args: strings(v.args),
+        env: record(v.env),
+        cwd: typeof v.cwd === 'string' ? v.cwd : undefined,
+        url,
+        headers: record(v.headers),
+        disabled: v.disabled === true || v.enabled === false,
+        ...(v.alwaysLoad === true ? { alwaysLoad: true } : {}),
+    };
+}
+function fromOpencode(name, v) {
+    const command = strings(v.command) ?? [];
+    const remote = v.type === 'remote' || typeof v.url === 'string';
+    return {
+        name,
+        transport: remote ? 'http' : 'stdio',
+        command: remote ? undefined : command[0],
+        args: remote ? undefined : command.slice(1),
+        env: record(v.environment),
+        url: typeof v.url === 'string' ? v.url : undefined,
+        headers: record(v.headers),
+        disabled: v.enabled === false,
+    };
+}
+function fromZed(name, v) {
+    // Older Zed settings nest the command: { "command": { "path", "args", "env" } }.
+    if (isObj(v.command)) {
+        const c = v.command;
+        return fromStandard(name, { ...v, command: c.path ?? c.command, args: c.args, env: c.env });
+    }
+    return fromStandard(name, v);
+}
+function serversIn(container, shape) {
+    if (!isObj(container))
+        return [];
+    return Object.entries(container)
+        .filter(([, v]) => isObj(v))
+        .map(([name, v]) => shape === 'opencode'
+        ? fromOpencode(name, v)
+        : shape === 'zed'
+            ? fromZed(name, v)
+            : fromStandard(name, v, shape === 'gemini'));
+}
+/** Minimal TOML reader for Codex `[mcp_servers.<name>]` tables: strings, string arrays and inline tables. */
+export function parseCodexToml(text) {
+    const servers = {};
+    let current = null;
+    let sub = null;
+    const value = (raw) => {
+        const t = raw.trim();
+        if (t.startsWith('['))
+            return [...t.matchAll(/"((?:[^"\\]|\\.)*)"|'([^']*)'/g)].map((m) => m[1] ?? m[2] ?? '');
+        if (t.startsWith('{'))
+            return Object.fromEntries([...t.matchAll(/([\w-]+|"[^"]*")\s*=\s*(?:"((?:[^"\\]|\\.)*)"|'([^']*)')/g)].map((m) => [m[1].replace(/"/g, ''), m[2] ?? m[3] ?? '']));
+        if (t === 'true' || t === 'false')
+            return t === 'true';
+        const s = /^"((?:[^"\\]|\\.)*)"|^'([^']*)'/.exec(t);
+        return s ? (s[1] ?? s[2]) : t;
+    };
+    for (const line of text.split(/\r?\n/)) {
+        const header = /^\s*\[\s*mcp_servers\.(?:"([^"]+)"|([\w-]+))(?:\.(\w+))?\s*\]/.exec(line);
+        if (header) {
+            const name = (header[1] ?? header[2]);
+            servers[name] ??= {};
+            current = servers[name];
+            sub = header[3] ?? null;
+            continue;
+        }
+        if (/^\s*\[/.test(line)) {
+            current = null;
+            continue;
+        }
+        const kv = /^\s*([\w-]+)\s*=\s*(.+?)\s*(?:#.*)?$/.exec(line);
+        if (!kv || !current)
+            continue;
+        if (sub) {
+            const table = (current[sub] ??= {});
+            table[kv[1]] = value(kv[2]);
+        }
+        else
+            current[kv[1]] = value(kv[2]);
+    }
+    // Codex calls HTTP headers `http_headers`.
+    for (const v of Object.values(servers))
+        if (isObj(v) && v.http_headers && !v.headers)
+            v.headers = v.http_headers;
+    return servers;
+}
+/**
+ * Parses the MCP configs among `files`. Project files use repo-relative paths; user files are passed
+ * with a `~/` prefix. `projectRoot` (absolute) selects the per-project entry in ~/.claude.json.
+ */
+export function parseMcpConfigs(files, projectRoot) {
+    const servers = [];
+    const problems = [];
+    for (const f of files) {
+        const user = f.path.startsWith('~/');
+        const rel = user ? f.path.slice(2) : f.path;
+        const specs = MCP_CONFIGS.filter((c) => c.path === rel && c.scope === (user ? 'user' : 'project'));
+        if (!specs.length)
+            continue;
+        let data;
+        try {
+            data = specs[0].shape === 'codex-toml' ? parseCodexToml(f.text) : parseJsonc(f.text);
+        }
+        catch (e) {
+            problems.push({ path: f.path, message: `could not be parsed: ${e.message}` });
+            continue;
+        }
+        if (!isObj(data))
+            continue;
+        for (const spec of specs) {
+            const containers = spec.shape === 'codex-toml'
+                ? [data]
+                : spec.shape === 'claude-json'
+                    ? [data.mcpServers, projectEntry(data, projectRoot)?.mcpServers]
+                    : [data[spec.key]];
+            for (const c of containers)
+                for (const s of serversIn(c, spec.shape))
+                    servers.push({ ...s, tool: spec.tool, configPath: f.path, scope: spec.scope });
+        }
+    }
+    return { servers, problems };
+}
+/** The `projects["<abs path>"]` entry of ~/.claude.json for this repository, matched case- and slash-insensitively. */
+function projectEntry(data, root) {
+    if (!root || !isObj(data.projects))
+        return undefined;
+    const norm = (p) => p.replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase();
+    const hit = Object.entries(data.projects).find(([p]) => norm(p) === norm(root));
+    return hit && isObj(hit[1]) ? hit[1] : undefined;
+}
+/** Same server started by several agents or configs: one launch, one measurement. */
+export function serverKey(s) {
+    return JSON.stringify([s.transport, s.command ?? '', s.args ?? [], s.url ?? '', s.cwd ?? '']);
+}
+/**
+ * Claude Code defers MCP tool definitions by default (tool search): only tool names are in context
+ * until a tool is used. A server with `alwaysLoad: true` is exempt.
+ */
+export function defersTools(s) {
+    return s.tool === 'claude-code' && !s.alwaysLoad;
+}
+export const DEFERRED_NOTE = 'Claude Code defers MCP tool definitions by default (tool search): only tool names load every turn; full definitions load when a tool is used. Set ENABLE_TOOL_SEARCH=false or alwaysLoad: true to load them upfront.';
+/** Tool names only, as listed when definitions are deferred. */
+export function toolNamesText(tools) {
+    return tools.map((t) => t.name).join('\n');
+}
+/** The text an agent receives for a server's tools, as one JSON document per tool. */
+export function toolDefinitionsText(tools) {
+    return tools.map((t) => JSON.stringify({ name: t.name, description: t.description ?? '', input_schema: t.inputSchema ?? {} })).join('\n');
+}