@thispointon/kondi-chat 0.1.2

package/src/engine/verify.ts

@@ -0,0 +1,111 @@
+/**
+ * Verification — run local tests, lint, and typecheck after task execution.
+ */
+
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import type { VerificationResult, RepoMap } from '../types.ts';
+
+const TIMEOUT_MS = 60_000; // 1 minute per command
+
+/**
+ * Run all available verification commands and return results.
+ */
+export function verify(workingDir: string, repoMap?: RepoMap): VerificationResult {
+  const commands = repoMap?.commands || detectCommands(workingDir);
+  const result: VerificationResult = { passed: true };
+
+  // Test
+  if (commands.test) {
+    const testResult = runCommand(commands.test, workingDir);
+    result.testOutput = testResult.output;
+    if (!testResult.ok) result.passed = false;
+  }
+
+  // Typecheck
+  if (commands.typecheck) {
+    const typecheckResult = runCommand(commands.typecheck, workingDir);
+    result.typecheckOutput = typecheckResult.output;
+    if (!typecheckResult.ok) result.passed = false;
+  }
+
+  // Lint
+  if (commands.lint) {
+    const lintResult = runCommand(commands.lint, workingDir);
+    result.lintOutput = lintResult.output;
+    if (!lintResult.ok) result.passed = false;
+  }
+
+  return result;
+}
+
+/**
+ * Auto-detect build/test/lint commands from project files. Exported so the
+ * agent loop's per-edit auto-verify can reuse the same detection instead of
+ * hardcoding `tsc --noEmit` for every project.
+ */
+export function detectCommands(workingDir: string): RepoMap['commands'] {
+  // fs and path imported at top level
+  const commands: RepoMap['commands'] = {};
+
+  // Node.js / package.json
+  const pkgPath = join(workingDir, 'package.json');
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+      const scripts = pkg.scripts || {};
+      if (scripts.test) commands.test = 'npm test';
+      if (scripts.lint) commands.lint = 'npm run lint';
+      if (scripts.typecheck) commands.typecheck = 'npm run typecheck';
+      else if (pkg.devDependencies?.typescript || pkg.dependencies?.typescript) {
+        commands.typecheck = 'npx tsc --noEmit';
+      }
+      if (scripts.build) commands.build = 'npm run build';
+    } catch { /* ignore */ }
+  }
+
+  // Python
+  if (existsSync(join(workingDir, 'pyproject.toml')) || existsSync(join(workingDir, 'setup.py'))) {
+    if (!commands.test) commands.test = 'pytest';
+    if (!commands.lint) commands.lint = 'ruff check .';
+    if (!commands.typecheck) commands.typecheck = 'mypy .';
+  }
+
+  // Rust
+  if (existsSync(join(workingDir, 'Cargo.toml'))) {
+    commands.test = 'cargo test';
+    commands.build = 'cargo build';
+    commands.lint = 'cargo clippy';
+  }
+
+  // Go
+  if (existsSync(join(workingDir, 'go.mod'))) {
+    commands.test = 'go test ./...';
+    commands.build = 'go build ./...';
+    commands.lint = 'golangci-lint run';
+  }
+
+  return commands;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function runCommand(cmd: string, cwd: string): { ok: boolean; output: string } {
+  try {
+    const output = execSync(cmd, {
+      cwd,
+      encoding: 'utf-8',
+      timeout: TIMEOUT_MS,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    return { ok: true, output: output.slice(-2000) }; // Keep last 2K chars
+  } catch (error: any) {
+    const stdout = error.stdout?.toString() || '';
+    const stderr = error.stderr?.toString() || '';
+    const combined = `${stdout}\n${stderr}`.trim().slice(-2000);
+    return { ok: false, output: combined || error.message };
+  }
+}

package/src/mcp/client.ts

@@ -0,0 +1,225 @@
+/**
+ * MCP Client Manager — connects to MCP servers and exposes their tools.
+ *
+ * Supports:
+ *   - stdio: local process (command + args)
+ *   - http/sse: remote server (URL + optional headers)
+ *
+ * Each server's tools are namespaced as "servername__toolname" to avoid
+ * collisions across servers.
+ */
+
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import type {
+  McpScopedConfig, McpServerState, McpToolInfo, McpConnectionStatus,
+} from './types.ts';
+
+// ---------------------------------------------------------------------------
+// MCP Client Manager
+// ---------------------------------------------------------------------------
+
+export class McpClientManager {
+  private servers: Map<string, McpServerState> = new Map();
+  private clients: Map<string, { client: Client; cleanup: () => Promise<void> }> = new Map();
+
+  /** Connect to all configured servers */
+  async connectAll(configs: Map<string, McpScopedConfig>): Promise<void> {
+    const promises = [...configs.entries()].map(([name, config]) =>
+      this.connect(name, config)
+    );
+    await Promise.allSettled(promises);
+  }
+
+  /** Connect to a single server */
+  async connect(name: string, config: McpScopedConfig): Promise<McpServerState> {
+    // Clean up existing connection if any
+    await this.disconnect(name);
+
+    const state: McpServerState = {
+      name,
+      status: 'pending',
+      config,
+      tools: [],
+    };
+    this.servers.set(name, state);
+
+    const configType = 'type' in config ? config.type : 'stdio';
+    process.stderr.write(`[mcp] Connecting to ${name} (${configType || 'stdio'})...\n`);
+
+    try {
+      const { client, cleanup } = await this.createClient(name, config);
+      this.clients.set(name, { client, cleanup });
+
+      // Discover tools
+      const toolsResult = await client.listTools();
+      const tools: McpToolInfo[] = (toolsResult.tools || []).map(tool => ({
+        qualifiedName: `${name}__${tool.name}`,
+        originalName: tool.name,
+        serverName: name,
+        description: tool.description || '',
+        parameters: (tool.inputSchema as Record<string, unknown>) || { type: 'object', properties: {} },
+      }));
+
+      state.status = 'connected';
+      state.tools = tools;
+
+      process.stderr.write(`[mcp] ${name}: connected (${tools.length} tools)\n`);
+    } catch (error) {
+      state.status = 'failed';
+      state.error = (error as Error).message;
+      process.stderr.write(`[mcp] ${name}: failed — ${state.error}\n`);
+    }
+
+    return state;
+  }
+
+  /** Disconnect a server */
+  async disconnect(name: string): Promise<void> {
+    const entry = this.clients.get(name);
+    if (entry) {
+      try {
+        await entry.cleanup();
+      } catch { /* ignore cleanup errors */ }
+      this.clients.delete(name);
+    }
+    this.servers.delete(name);
+  }
+
+  /** Disconnect all servers */
+  async disconnectAll(): Promise<void> {
+    const names = [...this.servers.keys()];
+    await Promise.allSettled(names.map(n => this.disconnect(n)));
+  }
+
+  // -------------------------------------------------------------------------
+  // Tool access
+  // -------------------------------------------------------------------------
+
+  /** Get all tools from all connected servers */
+  getAllTools(): McpToolInfo[] {
+    const tools: McpToolInfo[] = [];
+    for (const state of this.servers.values()) {
+      if (state.status === 'connected') {
+        tools.push(...state.tools);
+      }
+    }
+    return tools;
+  }
+
+  /** Call a tool on an MCP server */
+  async callTool(
+    qualifiedName: string,
+    args: Record<string, unknown>,
+  ): Promise<{ content: string; isError?: boolean }> {
+    // Parse server__tool
+    const sep = qualifiedName.indexOf('__');
+    if (sep < 0) {
+      return { content: `Invalid MCP tool name: ${qualifiedName}`, isError: true };
+    }
+
+    const serverName = qualifiedName.slice(0, sep);
+    const toolName = qualifiedName.slice(sep + 2);
+
+    const entry = this.clients.get(serverName);
+    if (!entry) {
+      return { content: `MCP server not connected: ${serverName}`, isError: true };
+    }
+
+    try {
+      const result = await entry.client.callTool({ name: toolName, arguments: args });
+
+      // Extract text content from MCP response
+      const textParts = (result.content as any[])
+        ?.filter((c: any) => c.type === 'text')
+        .map((c: any) => c.text) || [];
+
+      return {
+        content: textParts.join('\n') || '(no output)',
+        isError: result.isError === true,
+      };
+    } catch (error) {
+      return { content: `MCP tool error: ${(error as Error).message}`, isError: true };
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // Server state
+  // -------------------------------------------------------------------------
+
+  getServers(): McpServerState[] {
+    return [...this.servers.values()];
+  }
+
+  getServer(name: string): McpServerState | undefined {
+    return this.servers.get(name);
+  }
+
+  /** Format for display */
+  format(): string {
+    const servers = this.getServers();
+    if (servers.length === 0) return 'No MCP servers configured. See /mcp add.';
+
+    const lines: string[] = ['MCP Servers:'];
+    for (const s of servers) {
+      const icon = s.status === 'connected' ? 'OK' : s.status === 'failed' ? 'FAIL' : '...';
+      const scope = s.config.scope;
+      const type = s.config.type || 'stdio';
+      lines.push(`  [${icon.padEnd(4)}] ${s.name} (${type}, ${scope})`);
+      if (s.status === 'connected') {
+        lines.push(`         ${s.tools.length} tools: ${s.tools.map(t => t.originalName).join(', ')}`);
+      }
+      if (s.error) {
+        lines.push(`         Error: ${s.error}`);
+      }
+    }
+    return lines.join('\n');
+  }
+
+  // -------------------------------------------------------------------------
+  // Transport creation
+  // -------------------------------------------------------------------------
+
+  private async createClient(
+    name: string,
+    config: McpScopedConfig,
+  ): Promise<{ client: Client; cleanup: () => Promise<void> }> {
+    const client = new Client({ name: `kondi-chat-${name}`, version: '0.1.0' });
+    const type = 'type' in config ? config.type || 'stdio' : 'stdio';
+
+    if (type === 'stdio') {
+      const stdioConfig = config as { command: string; args?: string[]; env?: Record<string, string>; scope: string };
+      const transport = new StdioClientTransport({
+        command: stdioConfig.command,
+        args: stdioConfig.args || [],
+        env: { ...process.env, ...(stdioConfig.env || {}) } as Record<string, string>,
+      });
+
+      await client.connect(transport);
+      return {
+        client,
+        cleanup: async () => {
+          await client.close();
+        },
+      };
+    }
+
+    if (type === 'http' || type === 'sse') {
+      const httpConfig = config as { url: string; headers?: Record<string, string>; scope: string };
+      const transport = new StreamableHTTPClientTransport(
+        new URL(httpConfig.url),
+      );
+
+      await client.connect(transport);
+      return {
+        client,
+        cleanup: async () => {
+          await client.close();
+        },
+      };
+    }
+
+    throw new Error(`Unsupported MCP transport: ${type}`);
+  }
+}

package/src/mcp/config.ts

@@ -0,0 +1,120 @@
+/**
+ * MCP Config — loads server configuration from multiple scopes.
+ *
+ * Config files (checked in order, merged):
+ *   1. Project: .kondi-chat/mcp.json (project-specific)
+ *   2. User: ~/.kondi-chat/mcp.json (user-wide)
+ *
+ * Format (same as Claude Code):
+ * {
+ *   "mcpServers": {
+ *     "filesystem": {
+ *       "command": "npx",
+ *       "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path"]
+ *     },
+ *     "remote-api": {
+ *       "type": "http",
+ *       "url": "https://api.example.com/mcp"
+ *     }
+ *   }
+ * }
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import type { McpConfigFile, McpServerConfig, McpScopedConfig, McpScope } from './types.ts';
+
+// ---------------------------------------------------------------------------
+// Config loader
+// ---------------------------------------------------------------------------
+
+export function loadMcpConfig(projectDir: string): Map<string, McpScopedConfig> {
+  const servers = new Map<string, McpScopedConfig>();
+
+  // Load user-level config first (lower priority)
+  const userDir = join(homedir(), '.kondi-chat');
+  const userConfig = loadConfigFile(join(userDir, 'mcp.json'), 'user');
+  for (const [name, config] of userConfig) {
+    servers.set(name, config);
+  }
+
+  // Load project-level config (higher priority, overrides user)
+  const projectConfig = loadConfigFile(join(projectDir, '.kondi-chat', 'mcp.json'), 'project');
+  for (const [name, config] of projectConfig) {
+    servers.set(name, config);
+  }
+
+  return servers;
+}
+
+function loadConfigFile(path: string, scope: McpScope): Map<string, McpScopedConfig> {
+  const servers = new Map<string, McpScopedConfig>();
+  if (!existsSync(path)) return servers;
+
+  try {
+    const raw = readFileSync(path, 'utf-8');
+    const config: McpConfigFile = JSON.parse(raw);
+
+    if (config.mcpServers) {
+      for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
+        servers.set(name, { ...serverConfig, scope });
+      }
+    }
+  } catch (error) {
+    process.stderr.write(`[mcp] Failed to load ${path}: ${(error as Error).message}\n`);
+  }
+
+  return servers;
+}
+
+// ---------------------------------------------------------------------------
+// Config writer
+// ---------------------------------------------------------------------------
+
+export function saveMcpServer(
+  projectDir: string,
+  name: string,
+  config: McpServerConfig,
+  scope: McpScope = 'project',
+): void {
+  const dir = scope === 'user'
+    ? join(homedir(), '.kondi-chat')
+    : join(projectDir, '.kondi-chat');
+  const path = join(dir, 'mcp.json');
+
+  mkdirSync(dir, { recursive: true });
+
+  let existing: McpConfigFile = { mcpServers: {} };
+  if (existsSync(path)) {
+    try {
+      existing = JSON.parse(readFileSync(path, 'utf-8'));
+    } catch { /* start fresh */ }
+  }
+
+  existing.mcpServers[name] = config;
+  writeFileSync(path, JSON.stringify(existing, null, 2));
+}
+
+export function removeMcpServer(
+  projectDir: string,
+  name: string,
+  scope: McpScope = 'project',
+): boolean {
+  const dir = scope === 'user'
+    ? join(homedir(), '.kondi-chat')
+    : join(projectDir, '.kondi-chat');
+  const path = join(dir, 'mcp.json');
+
+  if (!existsSync(path)) return false;
+
+  try {
+    const existing: McpConfigFile = JSON.parse(readFileSync(path, 'utf-8'));
+    if (!existing.mcpServers[name]) return false;
+    delete existing.mcpServers[name];
+    writeFileSync(path, JSON.stringify(existing, null, 2));
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/mcp/tool-manager.ts

@@ -0,0 +1,192 @@
+/**
+ * Tool Manager — merges built-in tools and MCP tools into a unified set.
+ *
+ * Handles:
+ * - Combining built-in tools (read_file, etc.) with MCP tools
+ * - Dispatching tool calls to the right handler (built-in or MCP)
+ * - Filtering tools per request to save tokens
+ * - Converting MCP tools to our ToolDefinition format
+ */
+
+import type { ToolDefinition } from '../types.ts';
+import { AGENT_TOOLS, executeTool, type ToolContext, type ToolExecutionResult } from '../engine/tools.ts';
+import { McpClientManager } from './client.ts';
+import type { McpToolInfo } from './types.ts';
+import type { HookRunner } from '../engine/hooks.ts';
+
+/** Extra tools registered at runtime (e.g., council) */
+let extraTools: ToolDefinition[] = [];
+let extraExecutors: Map<string, (args: Record<string, unknown>, ctx: ToolContext) => Promise<ToolExecutionResult>> = new Map();
+
+// ---------------------------------------------------------------------------
+// Tool categories for filtering
+// ---------------------------------------------------------------------------
+
+/** Built-in tool categories */
+const BUILTIN_CATEGORIES: Record<string, string[]> = {
+  read_file: ['filesystem', 'coding'],
+  write_file: ['filesystem', 'coding'],
+  edit_file: ['filesystem', 'coding'],
+  list_files: ['filesystem', 'coding'],
+  search_code: ['coding', 'analysis'],
+  run_command: ['system', 'coding'],
+  create_task: ['coding', 'execution'],
+  update_plan: ['planning'],
+  update_memory: ['planning'],
+  spawn_agent: ['planning', 'coding'],
+  git_status: ['git', 'analysis'],
+  git_diff: ['git', 'analysis'],
+  git_log: ['git', 'analysis'],
+  git_branch: ['git', 'coding'],
+  git_commit: ['git', 'coding'],
+  git_create_pr: ['git', 'coding'],
+};
+
+/** Phase → which tool categories are relevant */
+const PHASE_TOOLS: Record<string, string[]> = {
+  discuss: ['filesystem', 'coding', 'analysis', 'planning', 'system', 'git'],
+  dispatch: ['planning'],
+  execute: ['filesystem', 'coding', 'system', 'git'],
+  reflect: [],
+  compress: [],
+  state_update: ['planning'],
+};
+
+// ---------------------------------------------------------------------------
+// Tool Manager
+// ---------------------------------------------------------------------------
+
+export class ToolManager {
+  private mcpClient: McpClientManager;
+  private hookRunner?: HookRunner;
+
+  constructor(mcpClient: McpClientManager) {
+    this.mcpClient = mcpClient;
+  }
+
+  setHookRunner(runner: HookRunner): void {
+    this.hookRunner = runner;
+    runner.setToolExecutor((name, args, ctx) => this.executeWithoutHooks(name, args, ctx));
+  }
+
+  /** Register an extra tool (e.g., council) */
+  registerTool(
+    tool: ToolDefinition,
+    executor: (args: Record<string, unknown>, ctx: ToolContext) => Promise<ToolExecutionResult>,
+  ): void {
+    extraTools.push(tool);
+    extraExecutors.set(tool.name, executor);
+  }
+
+  /**
+   * Get all available tool definitions (built-in + MCP).
+   * Optionally filter by phase for token efficiency.
+   */
+  getTools(phase?: string): ToolDefinition[] {
+    const builtIn = AGENT_TOOLS;
+    const mcpTools = this.mcpClient.getAllTools().map(mcpToToolDef);
+    const all = [...builtIn, ...extraTools, ...mcpTools];
+
+    if (!phase) return all;
+
+    // Filter by phase relevance
+    const relevantCategories = PHASE_TOOLS[phase];
+    if (!relevantCategories) return all;
+
+    return all.filter(tool => {
+      // Built-in tools: check category
+      const categories = BUILTIN_CATEGORIES[tool.name];
+      if (categories) {
+        return categories.some(c => relevantCategories.includes(c));
+      }
+      // MCP tools: always include for now (can't categorize without metadata)
+      // TODO: use tool description to auto-categorize
+      return true;
+    });
+  }
+
+  /**
+   * Execute a tool call — routes to built-in handler or MCP server.
+   * Spec 01: every path goes through the permission wedge first.
+   */
+  async execute(
+    name: string,
+    args: Record<string, unknown>,
+    toolCtx: ToolContext,
+  ): Promise<ToolExecutionResult> {
+    // Spec 12 — before hooks run first (can block before the permission dialog).
+    if (this.hookRunner) {
+      const before = await this.hookRunner.runBefore(name, args, toolCtx, toolCtx.emit);
+      if (before.blocked) {
+        return { content: `Tool blocked by hook: ${before.messages.join('; ')}`, isError: true };
+      }
+    }
+
+    const result = await this.executeWithoutHooks(name, args, toolCtx);
+
+    if (this.hookRunner) {
+      return this.hookRunner.runAfter(name, args, result, toolCtx, toolCtx.emit);
+    }
+    return result;
+  }
+
+  /**
+   * Run a tool without the before/after hook pass — used by `tool:` hooks to
+   * avoid recursion. Permissions still apply (Spec 01 hasn't moved).
+   */
+  async executeWithoutHooks(
+    name: string,
+    args: Record<string, unknown>,
+    toolCtx: ToolContext,
+  ): Promise<ToolExecutionResult> {
+    // Spec 01 — permission gate (applies to built-in, extra, and MCP tools)
+    const pm = toolCtx.permissionManager;
+    if (pm) {
+      const tier = pm.check(name, args);
+      if (tier !== 'auto-approve') {
+        if (!toolCtx.emit) {
+          return { content: `Permission check for ${name} requires an emit channel`, isError: true };
+        }
+        const decision = await pm.requestPermission(name, args, toolCtx.emit);
+        if (decision === 'denied') {
+          return { content: `Permission denied for ${name}.`, isError: true };
+        }
+      }
+    }
+
+    // Check extra tools first (e.g., council)
+    const extraExec = extraExecutors.get(name);
+    if (extraExec) {
+      return extraExec(args, toolCtx);
+    }
+
+    // Check if it's an MCP tool (contains __ separator)
+    if (name.includes('__')) {
+      return this.mcpClient.callTool(name, args);
+    }
+
+    // Built-in tool
+    return executeTool(name, args, toolCtx);
+  }
+
+  /** Get summary for display */
+  getSummary(): { builtIn: number; mcp: number; servers: number } {
+    return {
+      builtIn: AGENT_TOOLS.length,
+      mcp: this.mcpClient.getAllTools().length,
+      servers: this.mcpClient.getServers().filter(s => s.status === 'connected').length,
+    };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function mcpToToolDef(tool: McpToolInfo): ToolDefinition {
+  return {
+    name: tool.qualifiedName,
+    description: `[${tool.serverName}] ${tool.description}`,
+    parameters: tool.parameters,
+  };
+}