@causyne/agent 1.10.12 → 1.10.17

package/src/commands.js

@@ -20,7 +20,10 @@ import {
 } from './userSkills.js';
 import { buildContextText, buildUsageText, buildCheckpointsText, buildUndoText, buildStatusText } from './reporting.js';
 import { loadConfig, saveConfig } from './config.js';
-import { serverStatus, grantServer, revokeServer, addServer, removeServer } from './mcp/mcpRegistry.js';
+import {
+  serverStatus, grantServer, revokeServer, addServer, removeServer,
+  connectServer, disconnectServer, refreshServer
+} from './mcp/mcpRegistry.js';
 import { analyzeFiles, formatFindings } from './slopDetector.js';
 import { suggestMovements, formatMovementBrief, DESIGN_MOVEMENTS } from './designPalettes.js';
 import fs from 'fs';
@@ -425,6 +428,89 @@ export const COMMANDS = [
     }
   },
 
+  {
+    name: 'plans',
+    scope: 'local',
+    usage: '/plans [import <json-file> | forget]',
+    description: 'Inspect, pre-warm, or clear reusable task plans',
+    dialogTitle: 'Plan cache',
+    run: async (args = []) => {
+      const cache = await import('./planCache.js');
+      const verb = String(args[0] || '').toLowerCase();
+
+      if (verb === 'forget') {
+        const removed = cache.forgetPlans();
+        return ok(`Forgot ${removed} cached plan${removed === 1 ? '' : 's'}.`);
+      }
+
+      if (verb === 'import') {
+        const requested = args.slice(1).join(' ').trim();
+        if (!requested) return fail('Usage: /plans import <json-file>');
+        const file = path.resolve(requested.replace(/^~(?=\/)/, os.homedir()));
+        try {
+          const stat = fs.statSync(file);
+          if (!stat.isFile() || stat.size > 1024 * 1024) {
+            return fail('Plan seed must be one JSON file no larger than 1 MB.');
+          }
+          const outcome = cache.prewarmPlans(JSON.parse(fs.readFileSync(file, 'utf8')));
+          const detail = outcome.errors.length > 0 ? `\n${outcome.errors.join('\n')}` : '';
+          return outcome.accepted > 0
+            ? ok(`Imported ${outcome.accepted} plan${outcome.accepted === 1 ? '' : 's'}; rejected ${outcome.rejected}.${detail}`)
+            : fail(`No plans were imported.${detail}`);
+        } catch (error) {
+          return fail(`Could not import plan seeds: ${error.message}`);
+        }
+      }
+
+      const stats = cache.planStats();
+      return ok([
+        `${stats.count} cached plan${stats.count === 1 ? '' : 's'}`,
+        `Hits: ${stats.hits}/${stats.lookups} (${(stats.hitRate * 100).toFixed(1)}%) — exact ${stats.exactHits}, fuzzy ${stats.fuzzyHits}`,
+        `Average lookup: ${stats.averageLookupMs.toFixed(3)} ms; max ${stats.maxLookupMs.toFixed(3)} ms`,
+        stats.disabled
+          ? `Lookup cooling down until ${new Date(stats.disabledUntil).toISOString()} after persistent misses.`
+          : 'Lookup active.',
+        '',
+        'Pre-warm with /plans import <json-file>. Clear with /plans forget.'
+      ].join('\n'));
+    }
+  },
+
+  {
+    name: 'plugins',
+    scope: 'local',
+    usage: '/plugins [enable <name> | disable <name>]',
+    description: 'Inspect or change trust for local plugins',
+    dialogTitle: 'Plugins',
+    run: async (args = []) => {
+      const manager = await import('./plugins/pluginManager.js');
+      const verb = String(args[0] || '').toLowerCase();
+      const name = String(args[1] || '');
+      if (verb === 'enable') {
+        if (!name) return fail('Usage: /plugins enable <name>');
+        const result = manager.enablePlugin(name);
+        return result.ok
+          ? ok(`Enabled ${name} at manifest digest ${result.digest}. Changes will revoke trust automatically.`)
+          : fail(`Could not enable ${name}: ${result.error}`);
+      }
+      if (verb === 'disable') {
+        if (!name) return fail('Usage: /plugins disable <name>');
+        const result = manager.disablePlugin(name);
+        return result.ok ? ok(`Disabled ${name}.`) : fail(`Could not disable ${name}: ${result.error}`);
+      }
+
+      const rows = manager.listPlugins();
+      if (rows.length === 0) return ok(`No local plugins. Plugin root: ${manager.PLUGIN_ROOT}`);
+      return ok(rows.map((plugin) => {
+        const state = plugin.invalid ? 'invalid' : plugin.modified ? 'modified; trust revoked' : plugin.enabled ? 'enabled' : 'disabled';
+        const capabilities = Array.isArray(plugin.capabilities) && plugin.capabilities.length > 0
+          ? plugin.capabilities.join(', ')
+          : 'none';
+        return `  ${plugin.name} ${plugin.version || ''} — ${state}; capabilities: ${capabilities}`;
+      }).join('\n') + `\n\nPlugin root: ${manager.PLUGIN_ROOT}`);
+    }
+  },
+
   {
     name: 'sessions',
     aliases: ['session'],
@@ -574,10 +660,10 @@ export const COMMANDS = [
   {
     name: 'mcp',
     scope: 'local',
-    usage: '/mcp [add <name> <cmd…> | add <name> --url <url> | remove|grant|revoke <name>]',
-    description: 'Manage MCP servers: list, add, remove, grant, revoke',
+    usage: '/mcp [add <name> <cmd…> | add <name> --url <url> | remove|grant|revoke|connect|disconnect|test|refresh <name>]',
+    description: 'Manage and diagnose MCP server connections',
     dialogTitle: 'MCP servers',
-    run: (argv) => {
+    run: async (argv) => {
       const [action, serverName, ...rest] = argv;
 
       if (action === 'add') {
@@ -619,15 +705,40 @@ export const COMMANDS = [
         const known = serverStatus().some(s => s.name === serverName);
         if (!known) return fail(`No MCP server named "${serverName}" is configured.`);
         if (action === 'grant') {
-          grantServer(serverName);
+          const granted = grantServer(serverName);
+          if (!granted.ok) return fail(granted.error);
           return ok(`Granted "${serverName}". Its tools enter the catalogue on the next task.`);
         }
         revokeServer(serverName);
         return ok(`Revoked "${serverName}". Its tools are no longer callable.`);
       }
 
+      if (['connect', 'test', 'refresh', 'disconnect'].includes(action)) {
+        if (!serverName) return fail(`Usage: /mcp ${action} <server>`);
+        const known = serverStatus().some(server => server.name === serverName);
+        if (!known) return fail(`No MCP server named "${serverName}" is configured.`);
+
+        if (action === 'disconnect') {
+          await disconnectServer(serverName);
+          return ok(`Disconnected "${serverName}". Its grant remains in place.`);
+        }
+
+        if (action === 'refresh') {
+          const tools = await refreshServer(serverName);
+          return ok(`Refreshed "${serverName}": ${tools.length} tool(s) available${tools.length ? ` — ${tools.map(tool => tool.name).join(', ')}` : ''}.`);
+        }
+
+        const client = await connectServer(serverName);
+        return ok(
+          `${action === 'test' ? 'MCP test passed' : 'Connected'}: "${serverName}"\n`
+          + `Transport: ${client.status.transport || 'unknown'}\n`
+          + `Server: ${client.serverInfo ? `${client.serverInfo.name} ${client.serverInfo.version}` : 'identity not provided'}\n`
+          + `Tools: ${client.tools.length}${client.tools.length ? ` — ${client.tools.map(tool => tool.name).join(', ')}` : ''}`
+        );
+      }
+
       if (action) {
-        return fail(`Unknown mcp action "${action}". Try: add, remove, grant, revoke, or mcp on its own to list.`);
+        return fail(`Unknown mcp action "${action}". Try: add, remove, grant, revoke, connect, disconnect, test, refresh, or mcp on its own to list.`);
       }
 
       const servers = serverStatus();
@@ -636,12 +747,13 @@ export const COMMANDS = [
       }
       const lines = ['MCP servers', ''];
       for (const server of servers) {
-        lines.push(`  ${server.name}  [${server.transport}]  ${server.granted ? 'granted' : 'NOT granted'}${server.connected ? ', connected' : ''}`);
+        lines.push(`  ${server.name}  [${server.transport}]  ${server.granted ? 'granted' : 'NOT granted'}  ${server.status}`);
         lines.push(`    ${server.target}`);
         if (server.tools.length > 0) lines.push(`    tools: ${server.tools.join(', ')}`);
+        if (server.error) lines.push(`    error: ${server.error}`);
       }
       lines.push('');
-      lines.push('  mcp grant <name> to enable, mcp remove <name> to delete.');
+      lines.push('  mcp grant <name> to enable, mcp test <name> to diagnose, mcp remove <name> to delete.');
       return ok(lines.join('\n'), { effect: 'pick-mcp' });
     }
   },

package/src/config.d.ts

@@ -0,0 +1,2 @@
+export function loadConfig(): Record<string, unknown>;
+export function saveConfig(config: Record<string, unknown>): void;

package/src/cortex/autoCondenser.js

@@ -44,7 +44,7 @@ function serialiseContent(content) {
  * Records what was attempted, which files were touched and what failed —
  * exactly the things the agent asks itself again ten steps later.
  */
-function buildStructuralSummary(droppedMessages) {
+export function buildStructuralSummary(droppedMessages) {
   const toolCounts = new Map();
   const touchedPaths = new Set();
   const failures = [];

package/src/hooks.js

@@ -0,0 +1,150 @@
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+const MAX_HOOKS_PER_EVENT = 32;
+const MAX_OUTPUT_BYTES = 32 * 1024;
+const DEFAULT_TIMEOUT_MS = 5_000;
+function safeObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+function matchesTool(rule, toolName) {
+    const tools = Array.isArray(rule.tools)
+        ? rule.tools
+        : [rule.tool == null ? '*' : rule.tool];
+    return tools.some((candidate) => candidate === '*' || candidate === toolName);
+}
+function normalizeRule(rule, event, toolName) {
+    if (rule === null || typeof rule !== 'object' || Array.isArray(rule))
+        return null;
+    const candidate = rule;
+    if (candidate.enabled === false || candidate.event !== event || !matchesTool(candidate, toolName))
+        return null;
+    if (!Array.isArray(candidate.command) || candidate.command.length === 0)
+        return null;
+    const command = candidate.command.map((part) => String(part));
+    const executable = command[0];
+    if (!executable || command.length > 64 || command.some((part) => part.length > 4096))
+        return null;
+    return {
+        name: String(candidate.name || `${event}:${toolName}`).slice(0, 128),
+        command: [executable, ...command.slice(1)],
+        timeoutMs: Number.isInteger(candidate.timeoutMs)
+            ? Math.max(100, Math.min(candidate.timeoutMs, 10_000))
+            : DEFAULT_TIMEOUT_MS
+    };
+}
+export function hasMatchingHook(hooks, event, toolName) {
+    return (Array.isArray(hooks) ? hooks : [])
+        .some((rule) => normalizeRule(rule, event, toolName) !== null);
+}
+function runOneHook(rule, payload, cwd) {
+    return new Promise((resolve) => {
+        const child = spawn(rule.command[0], rule.command.slice(1), {
+            cwd,
+            shell: false,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: {
+                PATH: process.env.PATH || '',
+                LANG: process.env.LANG || 'C.UTF-8',
+                TMPDIR: process.env.TMPDIR || ''
+            }
+        });
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        const finish = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(value);
+        };
+        const timer = setTimeout(() => {
+            child.kill('SIGTERM');
+            finish({ exitCode: null, timedOut: true, stdout, stderr });
+        }, rule.timeoutMs);
+        timer.unref();
+        const collect = (target, chunk) => {
+            const next = target + chunk.toString();
+            if (Buffer.byteLength(next, 'utf8') > MAX_OUTPUT_BYTES) {
+                child.kill('SIGTERM');
+                finish({ exitCode: null, overflow: true, stdout, stderr });
+                return target;
+            }
+            return next;
+        };
+        child.stdout.on('data', (chunk) => { stdout = collect(stdout, chunk); });
+        child.stderr.on('data', (chunk) => { stderr = collect(stderr, chunk); });
+        child.on('error', (error) => finish({ exitCode: null, spawnError: error.message, stdout, stderr }));
+        child.on('close', (code) => finish({ exitCode: code, stdout, stderr }));
+        child.stdin.end(JSON.stringify(payload));
+    });
+}
+function feedbackFor(rule, result) {
+    const output = [result.stdout, result.stderr].filter(Boolean).join('\n').trim();
+    if (output)
+        return `${rule.name}: ${output}`.slice(0, MAX_OUTPUT_BYTES);
+    if (result.timedOut)
+        return `${rule.name}: timed out after ${rule.timeoutMs} ms`;
+    if (result.overflow)
+        return `${rule.name}: output exceeded ${MAX_OUTPUT_BYTES} bytes`;
+    if (result.spawnError)
+        return `${rule.name}: ${result.spawnError}`;
+    if (result.exitCode !== 0)
+        return `${rule.name}: exited with code ${result.exitCode}`;
+    return '';
+}
+function resolveWorkspaceRoots(workspacePaths) {
+    if (!Array.isArray(workspacePaths))
+        return [process.cwd()];
+    const roots = workspacePaths
+        .filter((value) => typeof value === 'string' && value.length > 0)
+        .map((value) => path.resolve(value));
+    return roots.length > 0 ? roots : [process.cwd()];
+}
+/**
+ * Run user-owned lifecycle hooks from ~/.causyne/config.json.
+ *
+ * Hooks are arrays of argv values and never pass through a shell. Project files
+ * are not searched for hooks, which prevents repository code from executing
+ * during startup before the user has trusted the workspace.
+ */
+export async function runConfiguredHooks({ hooks, event, toolName, args, result, taskId, toolCallId, workspacePaths }) {
+    const source = Array.isArray(hooks) ? hooks : [];
+    const rules = source
+        .map((rule) => normalizeRule(rule, event, toolName))
+        .filter((rule) => rule !== null)
+        .slice(0, MAX_HOOKS_PER_EVENT);
+    if (rules.length === 0)
+        return { denied: false, messages: [] };
+    const roots = resolveWorkspaceRoots(workspacePaths);
+    const primaryRoot = roots[0] ?? process.cwd();
+    const payload = {
+        event,
+        tool: toolName,
+        args: safeObject(args),
+        taskId: String(taskId || ''),
+        toolCallId: String(toolCallId || ''),
+        workspacePaths: roots
+    };
+    if (result !== null && typeof result === 'object')
+        payload.result = result;
+    const messages = [];
+    for (const rule of rules) {
+        const hookResult = await runOneHook(rule, payload, primaryRoot);
+        const feedback = feedbackFor(rule, hookResult);
+        if (feedback)
+            messages.push(feedback);
+        if (hookResult.exitCode === 2) {
+            return feedback
+                ? { denied: true, messages, reason: feedback }
+                : { denied: true, messages };
+        }
+        if (event === 'PreToolUse' && hookResult.exitCode !== 0) {
+            return { denied: true, messages, reason: feedback || `${rule.name} failed closed` };
+        }
+    }
+    return { denied: false, messages };
+}
+export { MAX_HOOKS_PER_EVENT, MAX_OUTPUT_BYTES, DEFAULT_TIMEOUT_MS };

package/src/hooks.ts

@@ -0,0 +1,193 @@
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+
+import type { HookDecision, HookEvent } from './types/contracts.js';
+
+const MAX_HOOKS_PER_EVENT = 32;
+const MAX_OUTPUT_BYTES = 32 * 1024;
+const DEFAULT_TIMEOUT_MS = 5_000;
+
+type UnknownRecord = Record<string, unknown>;
+
+interface NormalizedHookRule {
+  name: string;
+  command: [string, ...string[]];
+  timeoutMs: number;
+}
+
+interface HookProcessResult {
+  exitCode: number | null;
+  stdout: string;
+  stderr: string;
+  timedOut?: boolean;
+  overflow?: boolean;
+  spawnError?: string;
+}
+
+interface RunConfiguredHooksOptions {
+  hooks?: unknown;
+  event: HookEvent;
+  toolName: string;
+  args?: unknown;
+  result?: unknown;
+  taskId?: unknown;
+  toolCallId?: unknown;
+  workspacePaths?: unknown;
+}
+
+function safeObject(value: unknown): UnknownRecord {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+    ? value as UnknownRecord
+    : {};
+}
+
+function matchesTool(rule: UnknownRecord, toolName: string): boolean {
+  const tools = Array.isArray(rule.tools)
+    ? rule.tools
+    : [rule.tool == null ? '*' : rule.tool];
+  return tools.some((candidate) => candidate === '*' || candidate === toolName);
+}
+
+function normalizeRule(rule: unknown, event: HookEvent, toolName: string): NormalizedHookRule | null {
+  if (rule === null || typeof rule !== 'object' || Array.isArray(rule)) return null;
+  const candidate = rule as UnknownRecord;
+  if (candidate.enabled === false || candidate.event !== event || !matchesTool(candidate, toolName)) return null;
+  if (!Array.isArray(candidate.command) || candidate.command.length === 0) return null;
+
+  const command = candidate.command.map((part) => String(part));
+  const executable = command[0];
+  if (!executable || command.length > 64 || command.some((part) => part.length > 4096)) return null;
+
+  return {
+    name: String(candidate.name || `${event}:${toolName}`).slice(0, 128),
+    command: [executable, ...command.slice(1)],
+    timeoutMs: Number.isInteger(candidate.timeoutMs)
+      ? Math.max(100, Math.min(candidate.timeoutMs as number, 10_000))
+      : DEFAULT_TIMEOUT_MS
+  };
+}
+
+export function hasMatchingHook(hooks: unknown, event: HookEvent, toolName: string): boolean {
+  return (Array.isArray(hooks) ? hooks : [])
+    .some((rule) => normalizeRule(rule, event, toolName) !== null);
+}
+
+function runOneHook(rule: NormalizedHookRule, payload: UnknownRecord, cwd: string): Promise<HookProcessResult> {
+  return new Promise((resolve) => {
+    const child = spawn(rule.command[0], rule.command.slice(1), {
+      cwd,
+      shell: false,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: {
+        PATH: process.env.PATH || '',
+        LANG: process.env.LANG || 'C.UTF-8',
+        TMPDIR: process.env.TMPDIR || ''
+      }
+    });
+    let stdout = '';
+    let stderr = '';
+    let settled = false;
+
+    const finish = (value: HookProcessResult): void => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const timer = setTimeout(() => {
+      child.kill('SIGTERM');
+      finish({ exitCode: null, timedOut: true, stdout, stderr });
+    }, rule.timeoutMs);
+    timer.unref();
+
+    const collect = (target: string, chunk: Buffer | string): string => {
+      const next = target + chunk.toString();
+      if (Buffer.byteLength(next, 'utf8') > MAX_OUTPUT_BYTES) {
+        child.kill('SIGTERM');
+        finish({ exitCode: null, overflow: true, stdout, stderr });
+        return target;
+      }
+      return next;
+    };
+    child.stdout.on('data', (chunk: Buffer | string) => { stdout = collect(stdout, chunk); });
+    child.stderr.on('data', (chunk: Buffer | string) => { stderr = collect(stderr, chunk); });
+    child.on('error', (error: Error) => finish({ exitCode: null, spawnError: error.message, stdout, stderr }));
+    child.on('close', (code: number | null) => finish({ exitCode: code, stdout, stderr }));
+    child.stdin.end(JSON.stringify(payload));
+  });
+}
+
+function feedbackFor(rule: NormalizedHookRule, result: HookProcessResult): string {
+  const output = [result.stdout, result.stderr].filter(Boolean).join('\n').trim();
+  if (output) return `${rule.name}: ${output}`.slice(0, MAX_OUTPUT_BYTES);
+  if (result.timedOut) return `${rule.name}: timed out after ${rule.timeoutMs} ms`;
+  if (result.overflow) return `${rule.name}: output exceeded ${MAX_OUTPUT_BYTES} bytes`;
+  if (result.spawnError) return `${rule.name}: ${result.spawnError}`;
+  if (result.exitCode !== 0) return `${rule.name}: exited with code ${result.exitCode}`;
+  return '';
+}
+
+function resolveWorkspaceRoots(workspacePaths: unknown): string[] {
+  if (!Array.isArray(workspacePaths)) return [process.cwd()];
+  const roots = workspacePaths
+    .filter((value): value is string => typeof value === 'string' && value.length > 0)
+    .map((value) => path.resolve(value));
+  return roots.length > 0 ? roots : [process.cwd()];
+}
+
+/**
+ * Run user-owned lifecycle hooks from ~/.causyne/config.json.
+ *
+ * Hooks are arrays of argv values and never pass through a shell. Project files
+ * are not searched for hooks, which prevents repository code from executing
+ * during startup before the user has trusted the workspace.
+ */
+export async function runConfiguredHooks({
+  hooks,
+  event,
+  toolName,
+  args,
+  result,
+  taskId,
+  toolCallId,
+  workspacePaths
+}: RunConfiguredHooksOptions): Promise<HookDecision> {
+  const source: unknown[] = Array.isArray(hooks) ? hooks : [];
+  const rules = source
+    .map((rule) => normalizeRule(rule, event, toolName))
+    .filter((rule): rule is NormalizedHookRule => rule !== null)
+    .slice(0, MAX_HOOKS_PER_EVENT);
+  if (rules.length === 0) return { denied: false, messages: [] };
+
+  const roots = resolveWorkspaceRoots(workspacePaths);
+  const primaryRoot = roots[0] ?? process.cwd();
+  const payload: UnknownRecord = {
+    event,
+    tool: toolName,
+    args: safeObject(args),
+    taskId: String(taskId || ''),
+    toolCallId: String(toolCallId || ''),
+    workspacePaths: roots
+  };
+  if (result !== null && typeof result === 'object') payload.result = result;
+  const messages: string[] = [];
+
+  for (const rule of rules) {
+    const hookResult = await runOneHook(rule, payload, primaryRoot);
+    const feedback = feedbackFor(rule, hookResult);
+    if (feedback) messages.push(feedback);
+
+    if (hookResult.exitCode === 2) {
+      return feedback
+        ? { denied: true, messages, reason: feedback }
+        : { denied: true, messages };
+    }
+    if (event === 'PreToolUse' && hookResult.exitCode !== 0) {
+      return { denied: true, messages, reason: feedback || `${rule.name} failed closed` };
+    }
+  }
+
+  return { denied: false, messages };
+}
+
+export { MAX_HOOKS_PER_EVENT, MAX_OUTPUT_BYTES, DEFAULT_TIMEOUT_MS };