@hecer/yoke 1.21.1 → 1.23.0

package/dist/code-intelligence/mcp-client.js

@@ -12,6 +12,7 @@ export class McpStdioClient {
     pending = new Map();
     nextId = 1;
     stderrBytes = 0;
+    closing;
     constructor(command, args, cwd, framing = 'content-length', maxBytes = 2_000_000) {
         this.command = command;
         this.args = args;
@@ -20,12 +21,26 @@ export class McpStdioClient {
         this.maxBytes = maxBytes;
     }
     async call(tool, arguments_, timeoutMs) {
+        const deadline = Date.now() + timeoutMs;
         await this.start(timeoutMs);
-        return this.request('tools/call', { name: tool, arguments: arguments_ }, timeoutMs);
+        const remaining = deadline - Date.now();
+        if (remaining <= 0) {
+            void this.close();
+            throw new Error('MCP call deadline exceeded during initialization');
+        }
+        return this.request('tools/call', { name: tool, arguments: arguments_ }, remaining);
+    }
+    async listTools(timeoutMs) {
+        const deadline = Date.now() + timeoutMs;
+        await this.start(timeoutMs);
+        const result = await this.request('tools/list', {}, deadline - Date.now());
+        if (!Array.isArray(result.tools))
+            throw new Error('MCP backend did not advertise tools');
+        return result.tools.map(tool => tool.name).filter((name) => typeof name === 'string');
     }
     async close() {
         if (!this.child)
-            return;
+            return this.closing;
         const child = this.child;
         this.child = undefined;
         for (const pending of this.pending.values()) {
@@ -33,12 +48,14 @@ export class McpStdioClient {
             pending.reject(new Error('MCP process closed'));
         }
         this.pending.clear();
-        child.kill('SIGTERM');
-        await new Promise(resolve => {
-            const timer = setTimeout(() => { if (!child.killed)
-                child.kill('SIGKILL'); resolve(); }, 500);
+        this.closing = new Promise(resolve => {
+            const timer = setTimeout(() => { if (child.exitCode === null && child.signalCode === null)
+                child.kill('SIGKILL'); }, 500);
             child.once('close', () => { clearTimeout(timer); resolve(); });
         });
+        child.kill('SIGTERM');
+        await this.closing;
+        this.closing = undefined;
     }
     async start(timeoutMs) {
         if (this.child)
@@ -60,6 +77,8 @@ export class McpStdioClient {
         return Promise.resolve();
     }
     request(method, params, timeoutMs) {
+        if (timeoutMs <= 0)
+            return Promise.reject(new Error(`MCP request deadline exceeded: ${method}`));
         if (!this.child)
             return Promise.reject(new Error('MCP process is not running'));
         const id = this.nextId++;

package/dist/code-intelligence/mcp-server.js

@@ -2,24 +2,27 @@
 import { CodeIntelligenceCoordinator } from './coordinator.js';
 import { TOOL_DEFINITIONS } from './contracts.js';
 import { loadConfig } from '../retrofit/config.js';
+import { workspaceId } from './snapshots.js';
 const INPUT_SCHEMAS = {
     code_context: { type: 'object', required: ['workspace_id', 'query'], properties: { workspace_id: { type: 'string' }, query: { type: 'string' }, snapshot_id: { type: 'string' }, mode: { type: 'string', enum: ['orient', 'locate', 'explain'] }, paths: { type: 'array', items: { type: 'string' } }, include_docs: { type: 'boolean' }, token_budget: { type: 'integer' }, timeout_ms: { type: 'integer' } } },
-    code_symbol: { type: 'object', required: ['workspace_id', 'snapshot_id'], properties: { workspace_id: { type: 'string' }, snapshot_id: { type: 'string' }, symbol_id: { type: 'string' }, query: { type: 'string' }, path: { type: 'string' }, include: { type: 'array' } } },
-    code_trace: { type: 'object', required: ['workspace_id', 'snapshot_id', 'symbol_id', 'direction', 'relations'], properties: { workspace_id: { type: 'string' }, snapshot_id: { type: 'string' }, symbol_id: { type: 'string' }, direction: { type: 'string', enum: ['in', 'out'] }, relations: { type: 'array' }, max_depth: { type: 'integer' }, max_nodes: { type: 'integer' } } },
-    code_impact: { type: 'object', required: ['workspace_id', 'snapshot_id'], properties: { workspace_id: { type: 'string' }, snapshot_id: { type: 'string' }, targets: { type: 'array' }, plan_id: { type: 'string' }, include_docs: { type: 'boolean' }, require_semantic: { type: 'boolean' } } },
-    code_edit_preview: { type: 'object', required: ['workspace_id', 'snapshot_id', 'operations', 'validation_profile'], properties: { workspace_id: { type: 'string' }, snapshot_id: { type: 'string' }, operations: { type: 'array' }, validation_profile: { type: 'string', enum: ['default', 'extended'] } } },
+    code_symbol: { type: 'object', required: ['workspace_id', 'snapshot_id'], properties: { workspace_id: { type: 'string' }, snapshot_id: { type: 'string' }, symbol_id: { type: 'string' }, query: { type: 'string' }, path: { type: 'string' }, include: { type: 'array' }, token_budget: { type: 'integer', minimum: 128, maximum: 16000 }, timeout_ms: { type: 'integer', minimum: 100, maximum: 60000 } } },
+    code_trace: { type: 'object', required: ['workspace_id', 'snapshot_id', 'symbol_id', 'direction', 'relations'], properties: { workspace_id: { type: 'string' }, snapshot_id: { type: 'string' }, symbol_id: { type: 'string' }, direction: { type: 'string', enum: ['in', 'out'] }, relations: { type: 'array' }, max_depth: { type: 'integer' }, max_nodes: { type: 'integer' }, require_resolved: { type: 'boolean' }, timeout_ms: { type: 'integer', minimum: 100, maximum: 60000 } } },
+    code_impact: { type: 'object', required: ['workspace_id', 'snapshot_id'], properties: { workspace_id: { type: 'string' }, snapshot_id: { type: 'string' }, targets: { type: 'array' }, plan_id: { type: 'string' }, include_docs: { type: 'boolean' }, require_semantic: { type: 'boolean' }, max_depth: { type: 'integer' }, timeout_ms: { type: 'integer', minimum: 100, maximum: 60000 } } },
+    code_edit_preview: { type: 'object', required: ['workspace_id', 'snapshot_id', 'operations', 'validation_profile'], properties: { workspace_id: { type: 'string' }, snapshot_id: { type: 'string' }, operations: { type: 'array' }, validation_profile: { type: 'string', enum: ['default', 'extended'] }, timeout_ms: { type: 'integer', minimum: 100, maximum: 600000 } } },
     code_edit_apply: { type: 'object', required: ['workspace_id', 'plan_id', 'expected_snapshot_id', 'idempotency_key'], properties: { workspace_id: { type: 'string' }, plan_id: { type: 'string' }, expected_snapshot_id: { type: 'string' }, idempotency_key: { type: 'string' } } },
 };
 function arg(name, args) { return args.find(value => value.startsWith(`--${name}=`))?.slice(name.length + 3); }
 function summary(response) { return `status=${response.status} snapshot=${response.snapshot_id} warnings=${response.warnings.length} (full result in structuredContent)`; }
-export async function runCodeIntelligenceServer(argv = process.argv.slice(2)) {
+export async function runCodeIntelligenceServer(argv = process.argv.slice(2), io = process) {
     const workspace = arg('workspace', argv) ?? process.cwd();
     const configured = loadConfig(workspace)?.codeIntelligence;
     const mode = arg('mode', argv) ?? configured?.mode ?? 'active';
+    const workspaceIdentifier = configured?.workspaceId ?? workspaceId(workspace);
     const coordinator = new CodeIntelligenceCoordinator(workspace, {
         mode,
+        workspaceId: workspaceIdentifier,
         policy: { excludePatterns: configured?.policy?.excludePatterns, maxFileBytes: configured?.policy?.maxFileBytes },
-        limits: { maxBytes: configured?.limits?.maxBytes, maxBackends: configured?.limits?.maxBackends },
+        limits: configured?.limits,
         graft: configured?.graft, graphify: configured?.graphify, serena: configured?.serena,
     });
     let framing = 'line';
@@ -27,9 +30,9 @@ export async function runCodeIntelligenceServer(argv = process.argv.slice(2)) {
     const send = (message) => {
         const payload = JSON.stringify(message);
         if (framing === 'line')
-            process.stdout.write(`${payload}\n`);
+            io.stdout.write(`${payload}\n`);
         else
-            process.stdout.write(`Content-Length: ${Buffer.byteLength(payload, 'utf8')}\r\n\r\n${payload}`);
+            io.stdout.write(`Content-Length: ${Buffer.byteLength(payload, 'utf8')}\r\n\r\n${payload}`);
     };
     const handle = async (message) => {
         if (message.method === 'notifications/initialized' || message.method?.startsWith('notifications/'))
@@ -39,7 +42,7 @@ export async function runCodeIntelligenceServer(argv = process.argv.slice(2)) {
             return;
         }
         if (message.method === 'tools/list') {
-            send({ jsonrpc: '2.0', id: message.id, result: { tools: TOOL_DEFINITIONS.map(tool => ({ ...tool, inputSchema: INPUT_SCHEMAS[tool.name] })) } });
+            send({ jsonrpc: '2.0', id: message.id, result: { tools: TOOL_DEFINITIONS.map(tool => ({ ...tool, inputSchema: { ...INPUT_SCHEMAS[tool.name], properties: { ...INPUT_SCHEMAS[tool.name].properties, workspace_id: { type: 'string', const: workspaceIdentifier, description: 'Accepted identifier for this configured workspace.' } } } })) } });
             return;
         }
         if (message.method === 'tools/call') {
@@ -51,7 +54,7 @@ export async function runCodeIntelligenceServer(argv = process.argv.slice(2)) {
         if (message.id !== undefined)
             send({ jsonrpc: '2.0', id: message.id, error: { code: -32601, message: `method not found: ${message.method}` } });
     };
-    process.stdin.on('data', chunk => {
+    io.stdin.on('data', chunk => {
         buffer = Buffer.concat([buffer, Buffer.from(chunk)]);
         while (buffer.length) {
             let raw;
@@ -87,7 +90,7 @@ export async function runCodeIntelligenceServer(argv = process.argv.slice(2)) {
             catch { /* malformed protocol input is ignored */ }
         }
     });
-    await new Promise(resolve => { const stop = () => { process.off('SIGTERM', stop); process.off('SIGINT', stop); void coordinator.close().finally(resolve); }; process.once('SIGTERM', stop); process.once('SIGINT', stop); process.stdin.once('end', stop); });
+    await new Promise(resolve => { const stop = () => { process.off('SIGTERM', stop); process.off('SIGINT', stop); io.stdin.off('end', stop); void coordinator.close().finally(resolve); }; process.once('SIGTERM', stop); process.once('SIGINT', stop); io.stdin.once('end', stop); });
 }
 if (process.argv[1]?.endsWith('code-intelligence-server.js'))
     void runCodeIntelligenceServer();

package/dist/code-intelligence/preflight.js

@@ -0,0 +1,71 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { loadConfig } from '../retrofit/config.js';
+import { workspaceId } from './snapshots.js';
+import { createGraftAdapter, createGraphifyAdapter, createSerenaAdapter } from './adapters/index.js';
+/** Probe protocol capabilities in an empty disposable cwd, never create a target snapshot.
+ * Configured commands are arbitrary code and cannot be promised read-only: leave them unprobed. */
+export async function runToolPreflight(root, options = {}) {
+    const configured = loadConfig(root)?.codeIntelligence;
+    const timeout = Math.min(10000, Math.max(100, options.timeoutMs ?? 2000));
+    const version = spawnSync('rtk', ['--version'], { encoding: 'utf8', timeout });
+    const native = spawnSync('rtk', ['hook', 'codex'], {
+        encoding: 'utf8', timeout,
+        input: JSON.stringify({ hook_event_name: 'PreToolUse', permission_mode: 'default', tool_name: 'Bash', tool_input: { command: 'git status' } }),
+    });
+    let nativeRewrite = false;
+    try {
+        const result = JSON.parse(native.stdout);
+        nativeRewrite = native.status === 0 && result.hookSpecificOutput?.permissionDecision === 'allow' && result.hookSpecificOutput?.updatedInput?.command === 'rtk git status';
+    }
+    catch { /* native support unavailable */ }
+    let hookRegistration = 'missing';
+    const hooksPath = join(root, '.codex/hooks.json');
+    if (existsSync(hooksPath)) {
+        try {
+            const hooks = JSON.parse(readFileSync(hooksPath, 'utf8')).hooks?.PreToolUse;
+            if (Array.isArray(hooks) && hooks.some(block => ['Bash', '^Bash$'].includes(block.matcher) && Array.isArray(block.hooks) && block.hooks.some((hook) => hook.type === 'command' && hook.command === 'rtk hook codex')))
+                hookRegistration = 'configured';
+        }
+        catch {
+            hookRegistration = 'invalid';
+        }
+    }
+    const mode = configured?.mode ?? 'off';
+    const probeRoot = mkdtempSync(join(tmpdir(), 'yoke-tool-probe-'));
+    const backends = {};
+    const definitions = [
+        ['graft', configured?.graft, createGraftAdapter, ['graft_find_code', 'graft_trace_calls']],
+        ['graphify', configured?.graphify, createGraphifyAdapter, ['query_graph', 'get_node']],
+        ['serena-lsp', configured?.serena, createSerenaAdapter, ['find_symbol', 'find_referencing_symbols']],
+    ];
+    try {
+        for (const [name, custom, factory, required] of definitions) {
+            if (mode === 'off' || custom) {
+                backends[name] = { status: 'unprobed', tools: [], missingTools: [...required], reason: mode === 'off' ? 'Configured mode is off.' : 'Custom command/arguments were not executed; read-only behavior cannot be verified.' };
+                continue;
+            }
+            const adapter = factory(probeRoot);
+            try {
+                const tools = await adapter.probe(timeout);
+                const missingTools = required.filter(tool => !tools.includes(tool));
+                backends[name] = { status: missingTools.length ? 'unavailable' : 'available', tools, missingTools };
+            }
+            catch {
+                backends[name] = { status: 'unavailable', tools: [], missingTools: [...required], reason: 'Backend protocol initialization or tools/list failed; target indexing was not attempted.' };
+            }
+            finally {
+                await adapter.close();
+            }
+        }
+    }
+    finally {
+        rmSync(probeRoot, { recursive: true, force: true });
+    }
+    return {
+        rtk: { status: nativeRewrite ? 'available' : 'degraded', version: version.status === 0 ? version.stdout.trim() : null, nativeRewrite, hookRegistration, hostActivation: 'unverified', nestedCodeMode: 'unverified', fallback: nativeRewrite ? 'Explicit RTK prefixes remain required for unverified nested code-mode calls; project-hook activation depends on host support and trust.' : 'Use explicit RTK prefixes; update RTK outside this preflight if native Codex support is needed. Use rtk init --codex --dry-run to inspect supported setup flags.' },
+        codeIntelligence: { mode, workspaceId: configured?.workspaceId ?? workspaceId(root), status: mode === 'off' ? 'off' : Object.values(backends).every(backend => backend.status === 'available') ? 'available' : 'degraded', backends, probeScope: 'isolated protocol capabilities only', indexFreshness: 'unverified', fallback: 'Use rg and direct source reads; verify backend candidates against source. Target index freshness and exhaustive coverage are unverified.' },
+    };
+}

package/dist/dashboard/analytics.js

@@ -50,7 +50,8 @@ export function aggregateMeasurements(events, period) {
         for (const target of targets)
             target.activity++;
         if (event.type === 'tokens') {
-            const calls = Array.isArray(data.calls) && data.calls.length ? data.calls : [{ ...data, actualModel: data.model, durationMs: event.durationMs }];
+            const hasCallBreakdown = Array.isArray(data.calls) && data.calls.length > 0;
+            const calls = hasCallBreakdown ? data.calls : [{ ...data, actualModel: data.model, durationMs: event.durationMs }];
             for (const item of calls) {
                 if (!item || typeof item !== 'object')
                     continue;
@@ -70,7 +71,8 @@ export function aggregateMeasurements(events, period) {
                     dimensionTargets.push(dimension);
                 }
                 for (const target of [...targets, get(models, key), get(modelBuckets, JSON.stringify([bucketOf(event.timestamp, period.bucket), provider, model, role])), ...dimensionTargets]) {
-                    const usageAvailable = call.usageAvailable !== false && data.usageAvailable !== false && call.measurementComplete !== false && data.measurementComplete !== false;
+                    const usageAvailable = call.usageAvailable !== false && call.measurementComplete !== false
+                        && (hasCallBreakdown || (data.usageAvailable !== false && data.measurementComplete !== false));
                     if (usageAvailable) {
                         addMetric(target, 'inputTokens', call.inputTokens);
                         addMetric(target, 'outputTokens', call.outputTokens);
@@ -87,7 +89,7 @@ export function aggregateMeasurements(events, period) {
                         target.unknownCalls++;
                     if (finite(call.totalCostUsd))
                         target.costReportedCalls++;
-                    if (call.costMeasurementComplete === false || data.costMeasurementComplete === false)
+                    if (call.costMeasurementComplete === false || (!hasCallBreakdown && data.costMeasurementComplete === false))
                         target.incompleteCosts++;
                 }
             }