@thispointon/kondi-chat 0.1.2

package/src/council-engine/types/mcp.ts

@@ -0,0 +1,122 @@
+export interface MCPServer {
+  id: string;
+  name: string;
+  url: string;
+  transport: 'http' | 'sse' | 'stdio';
+  status: 'disconnected' | 'connecting' | 'connected' | 'error';
+  icon?: string;
+  tools?: MCPTool[];
+  error?: string;
+  accessToken?: string;
+  clientId?: string;
+  clientSecret?: string;
+  sessionId?: string;
+  authHint?: 'none' | 'oauth' | 'token';
+  messageEndpoint?: string; // For SSE transport - the endpoint to POST JSON-RPC commands to
+  type?: 'remote' | 'github_mcp_local';
+  metadata?: Record<string, any>;
+  autoConnect?: boolean; // If true, attempt to connect automatically on app startup
+}
+
+export interface MCPTool {
+  name: string;
+  description: string;
+  inputSchema: {
+    type: string;
+    properties: Record<string, any>;
+    required?: string[];
+  };
+}
+
+export interface ToolCall {
+  id: string;
+  serverId: string;
+  toolName: string;
+  arguments: Record<string, any>;
+  status: 'pending' | 'running' | 'completed' | 'failed';
+  result?: any;
+  error?: string;
+}
+
+export interface MessageAttachment {
+  name: string;
+  type: string;
+  size: number;
+}
+
+export interface MessageUsage {
+  inputTokens: number;
+  outputTokens: number;
+  cacheRead?: number;
+  cacheCreation?: number;
+  /** Estimated payload size in chars (JSON-serialized request body) */
+  payloadChars?: number;
+  /** Number of API calls (tool loop turns) for this response */
+  apiTurns?: number;
+}
+
+export interface Message {
+  id: string;
+  role: 'user' | 'assistant' | 'system';
+  content: string;
+  toolCalls?: ToolCall[];
+  timestamp: Date;
+  provider?: string;
+  attachments?: MessageAttachment[];
+  /** Token usage from the API response (assistant messages only) */
+  usage?: MessageUsage;
+}
+
+export type CollaborationMode = 'single' | 'collaborate' | 'debate';
+
+export interface OAuthDiscovery {
+  requiresAuth: boolean;
+  authorizationEndpoint?: string;
+  tokenEndpoint?: string;
+  registrationEndpoint?: string;
+  supportsDynamicRegistration: boolean;
+  dynamicClientId?: string;
+  dynamicClientSecret?: string;
+  error?: string;
+}
+
+export interface GithubInstallResult {
+  serverPath: string;
+  entrypoint: string;
+  success: boolean;
+  error?: string;
+}
+
+export interface CommandOutput {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+  success: boolean;
+}
+
+export interface McpManifest {
+  name?: string;
+  version?: string;
+  description?: string;
+  entrypoint?: string;
+  runtime?: 'node' | 'python' | 'binary';
+  package?: {
+    name?: string;
+    version?: string;
+    manager?: 'npm' | 'pip' | 'uv' | 'none';
+    module_probe?: string;
+  };
+  // Run configuration - allows full customization
+  run?: {
+    command?: string;           // The command to execute (e.g., "python", "node", "npx")
+    args?: string[];            // Arguments to pass
+    env?: Record<string, string>; // Environment variables
+    workingDir?: string;        // Working directory relative to server path
+    shell?: boolean;            // Run via shell (for complex commands)
+  };
+  // Install configuration
+  install?: {
+    command?: string;           // Custom install command (overrides package.manager)
+    args?: string[];            // Arguments for install command
+  };
+}

package/src/council-engine/utils/filterTools.ts

@@ -0,0 +1,73 @@
+import type { MCPTool } from '../types/mcp';
+import { LOCAL_SERVER_ID } from '../services/localTools';
+
+/** Server IDs for built-in/local services that are always available regardless of restrictions. */
+export const BUILTIN_SERVER_IDS = [LOCAL_SERVER_ID, 'kondi-search'];
+
+/**
+ * Filter MCP tools map based on allowed server IDs.
+ *   undefined  → all servers (unrestricted)
+ *   []         → no servers at all (fully restricted)
+ *   ['a','b']  → built-in servers + listed servers
+ */
+export function filterToolsByServerIds(
+  tools: Map<string, { serverId: string; tools: MCPTool[] }>,
+  allowedServerIds?: string[]
+): Map<string, { serverId: string; tools: MCPTool[] }> {
+  if (allowedServerIds === undefined) return tools;
+  const filtered = new Map<string, { serverId: string; tools: MCPTool[] }>();
+  const includeBuiltins = allowedServerIds.length > 0;
+  for (const [key, value] of tools) {
+    if ((includeBuiltins && BUILTIN_SERVER_IDS.includes(key)) || allowedServerIds.includes(key)) {
+      filtered.set(key, value);
+    }
+  }
+  return filtered;
+}
+
+/** Count total tools across all servers */
+export function countTools(tools: Map<string, { serverId: string; tools: MCPTool[] }>): number {
+  let count = 0;
+  for (const [, v] of tools) count += v.tools.length;
+  return count;
+}
+
+/**
+ * Pre-flight check: scan prompt text for MCP tool references and warn if
+ * any referenced tools aren't available. Prevents wasting a full council
+ * run only to fail mid-way because a tool server isn't connected.
+ *
+ * Looks for patterns like `mcp__serverId__toolName` in the prompt text
+ * and verifies the server is in the available tools map.
+ */
+export function verifyRequiredTools(
+  availableTools: Map<string, { serverId: string; tools: MCPTool[] }>,
+  promptText: string,
+  contextLabel: string
+): void {
+  // Match mcp__<server>__<tool> patterns commonly used in prompts
+  const mcpPattern = /mcp__([a-zA-Z0-9_-]+)__([a-zA-Z0-9_-]+)/g;
+  const referencedServers = new Set<string>();
+  let match;
+  while ((match = mcpPattern.exec(promptText)) !== null) {
+    referencedServers.add(match[1]);
+  }
+
+  if (referencedServers.size === 0) return;
+
+  const availableServerIds = new Set<string>();
+  for (const [key] of availableTools) {
+    availableServerIds.add(key);
+  }
+
+  const missing = [...referencedServers].filter(
+    (s) => !availableServerIds.has(s) && !BUILTIN_SERVER_IDS.includes(s)
+  );
+
+  if (missing.length > 0) {
+    console.warn(
+      `[verifyRequiredTools] "${contextLabel}" references MCP servers not currently connected: ${missing.join(', ')}. ` +
+      `Tools from these servers will not be available during execution.`
+    );
+  }
+}

package/src/engine/apply.ts

@@ -0,0 +1,238 @@
+/**
+ * Apply — parses model output and writes changes to disk.
+ *
+ * Supports two output modes:
+ *   - file_replacements: model returns full file contents with path labels
+ *   - diff: model returns unified diffs
+ *
+ * All writes are backed up before overwriting. Backup files go to
+ * .kondi-chat/backups/<task-id>/ so they can be restored.
+ */
+
+import {
+  readFileSync, writeFileSync, existsSync, mkdirSync, copyFileSync,
+} from 'node:fs';
+import { join, resolve, dirname, relative } from 'node:path';
+
+function isPathSafe(base: string, fullPath: string): boolean {
+  const rel = relative(base, fullPath);
+  return !rel.startsWith('..') && !resolve(fullPath).includes('\0');
+}
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface FileChange {
+  path: string;
+  content: string;
+  isNew: boolean;
+}
+
+export interface ApplyResult {
+  applied: FileChange[];
+  skipped: string[];
+  backupDir?: string;
+}
+
+// ---------------------------------------------------------------------------
+// Parse model output
+// ---------------------------------------------------------------------------
+
+/**
+ * Parse file replacements from model output.
+ *
+ * Expects patterns like:
+ *   #### path/to/file.ts
+ *   ```
+ *   file content
+ *   ```
+ *
+ * Or:
+ *   **File: path/to/file.ts**
+ *   ```typescript
+ *   file content
+ *   ```
+ *
+ * Or:
+ *   // path/to/file.ts
+ *   ```
+ *   file content
+ *   ```
+ */
+export function parseFileReplacements(output: string): FileChange[] {
+  const changes: FileChange[] = [];
+
+  // Pattern 1: #### path/to/file
+  // Pattern 2: **File: path/to/file**
+  // Pattern 3: ## path/to/file
+  // Pattern 4: `path/to/file`:
+  const headerPatterns = [
+    /^#{1,4}\s+([^\n]+?)$/gm,
+    /^\*\*(?:File:\s*)?([^\n*]+?)\*\*$/gm,
+    /^`([^`\n]+?)`\s*:?\s*$/gm,
+    /^\/\/\s+([^\n]+?)$/gm,
+  ];
+
+  // Find all code blocks
+  const codeBlockRegex = /```[a-z]*\n([\s\S]*?)```/g;
+  const blocks: { start: number; end: number; content: string }[] = [];
+  let match;
+  while ((match = codeBlockRegex.exec(output)) !== null) {
+    blocks.push({
+      start: match.index,
+      end: match.index + match[0].length,
+      content: match[1],
+    });
+  }
+
+  if (blocks.length === 0) return [];
+
+  // For each code block, look backwards for a path header
+  for (const block of blocks) {
+    const textBefore = output.slice(Math.max(0, block.start - 300), block.start);
+    let filePath: string | null = null;
+
+    for (const pattern of headerPatterns) {
+      pattern.lastIndex = 0;
+      let headerMatch;
+      let lastMatch: RegExpExecArray | null = null;
+      while ((headerMatch = pattern.exec(textBefore)) !== null) {
+        lastMatch = headerMatch;
+      }
+      if (lastMatch) {
+        const candidate = lastMatch[1].trim()
+          .replace(/^`|`$/g, '')
+          .replace(/^\*\*|\*\*$/g, '')
+          .replace(/^File:\s*/i, '')
+          .trim();
+        // Validate it looks like a file path
+        if (candidate.includes('/') || candidate.includes('.')) {
+          filePath = candidate;
+          break;
+        }
+      }
+    }
+
+    if (filePath) {
+      // Clean up the content — remove trailing newline
+      let content = block.content;
+      if (content.endsWith('\n')) {
+        content = content.slice(0, -1);
+      }
+      changes.push({
+        path: filePath,
+        content,
+        isNew: false, // Will be set during apply
+      });
+    }
+  }
+
+  return changes;
+}
+
+// ---------------------------------------------------------------------------
+// Apply changes to disk
+// ---------------------------------------------------------------------------
+
+/**
+ * Apply file changes to the working directory.
+ *
+ * @param workingDir  Root directory for the project
+ * @param changes     Parsed file changes
+ * @param backupDir   Where to store backups (optional)
+ */
+export function applyChanges(
+  workingDir: string,
+  changes: FileChange[],
+  backupDir?: string,
+): ApplyResult {
+  const base = resolve(workingDir);
+  const applied: FileChange[] = [];
+  const skipped: string[] = [];
+
+  // Create backup directory
+  if (backupDir) {
+    mkdirSync(backupDir, { recursive: true });
+  }
+
+  for (const change of changes) {
+    const fullPath = resolve(join(workingDir, change.path));
+
+    // Path traversal check
+    if (!isPathSafe(base, fullPath)) {
+      skipped.push(`${change.path} (path traversal blocked)`);
+      continue;
+    }
+
+    // Backup existing file
+    if (existsSync(fullPath) && backupDir) {
+      const backupPath = join(backupDir, change.path);
+      mkdirSync(dirname(backupPath), { recursive: true });
+      copyFileSync(fullPath, backupPath);
+    }
+
+    change.isNew = !existsSync(fullPath);
+
+    // Create parent directories
+    mkdirSync(dirname(fullPath), { recursive: true });
+
+    // Write the file
+    writeFileSync(fullPath, change.content + '\n');
+    applied.push(change);
+  }
+
+  return { applied, skipped, backupDir };
+}
+
+// ---------------------------------------------------------------------------
+// Restore from backup
+// ---------------------------------------------------------------------------
+
+/**
+ * Restore files from a backup directory.
+ */
+export function restoreBackup(workingDir: string, backupDir: string, files: string[]): string[] {
+  const restored: string[] = [];
+
+  for (const relPath of files) {
+    const backupPath = join(backupDir, relPath);
+    const targetPath = join(workingDir, relPath);
+
+    if (existsSync(backupPath)) {
+      mkdirSync(dirname(targetPath), { recursive: true });
+      copyFileSync(backupPath, targetPath);
+      restored.push(relPath);
+    }
+  }
+
+  return restored;
+}
+
+// ---------------------------------------------------------------------------
+// Format for display
+// ---------------------------------------------------------------------------
+
+export function formatApplyResult(result: ApplyResult): string {
+  const lines: string[] = [];
+
+  if (result.applied.length > 0) {
+    lines.push(`Applied ${result.applied.length} file(s):`);
+    for (const f of result.applied) {
+      lines.push(`  ${f.isNew ? '+' : '~'} ${f.path}`);
+    }
+  }
+
+  if (result.skipped.length > 0) {
+    lines.push(`Skipped ${result.skipped.length}:`);
+    for (const s of result.skipped) {
+      lines.push(`  ✗ ${s}`);
+    }
+  }
+
+  if (result.backupDir) {
+    lines.push(`Backups: ${result.backupDir}`);
+  }
+
+  return lines.join('\n');
+}

package/src/engine/checkpoints.ts

@@ -0,0 +1,237 @@
+/**
+ * Checkpoints — automatic restore points taken before the first mutating
+ * tool call in a turn. Git mode uses `git stash create`; file mode copies
+ * mutated files into `.kondi-chat/checkpoints/<session-id>/<cp-id>/files/`.
+ */
+
+import { execSync } from 'node:child_process';
+import {
+  existsSync, readFileSync, writeFileSync, mkdirSync, rmSync, copyFileSync, renameSync,
+} from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+
+export type CheckpointMode = 'git' | 'file';
+
+export interface Checkpoint {
+  id: string;
+  turnNumber: number;
+  timestamp: string;
+  mode: CheckpointMode;
+  stashRef?: string;        // git sha of the stash commit
+  preHead?: string;         // HEAD at checkpoint time (git mode)
+  filesChanged: string[];
+  summary: string;
+  costUsd: number;
+  userMessage: string;
+}
+
+const MAX_CHECKPOINTS = 20;
+const NON_MUTATING_COMMAND_PREFIXES = [
+  'ls', 'cat', 'grep', 'find', 'echo', 'pwd', 'which', 'file', 'head', 'tail', 'wc',
+  'git status', 'git log', 'git diff', 'git show', 'git blame', 'git branch',
+  'npm test', 'npm run test', 'npx vitest', 'npx tsc',
+  'cargo check', 'cargo test', 'cargo fmt --check', 'cargo clippy',
+  'tsc --noEmit', 'python -c', 'node -v', 'node --version',
+];
+
+const MUTATING_TOOLS = new Set([
+  'write_file', 'edit_file', 'create_task', 'update_memory',
+  'git_commit', 'git_branch', 'git_create_pr',
+]);
+
+/** Predict which files this tool call will touch (for file-mode pre-snapshots). */
+export function predictedMutations(name: string, args: Record<string, unknown>): string[] {
+  if (name === 'write_file' || name === 'edit_file') {
+    const p = args.path;
+    return typeof p === 'string' ? [p] : [];
+  }
+  return [];
+}
+
+/** Return true if this tool call should cause a checkpoint snapshot before running. */
+export function isMutatingToolCall(name: string, args: Record<string, unknown>): boolean {
+  if (MUTATING_TOOLS.has(name)) return true;
+  if (name === 'run_command') {
+    const cmd = String(args.command || '').trim();
+    if (!cmd) return false;
+    for (const prefix of NON_MUTATING_COMMAND_PREFIXES) {
+      if (cmd === prefix || cmd.startsWith(prefix + ' ')) return false;
+    }
+    return true;
+  }
+  return false;
+}
+
+function tryGit(cmd: string, cwd: string): string {
+  try {
+    return execSync(cmd, { cwd, encoding: 'utf-8', timeout: 15_000, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+  } catch { return ''; }
+}
+
+function atomicWrite(path: string, data: string) {
+  const tmp = path + '.tmp';
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(tmp, data);
+  try { renameSync(tmp, path); } catch { writeFileSync(path, data); }
+}
+
+export class CheckpointManager {
+  private workingDir: string;
+  private storageDir: string;
+  private indexPath: string;
+  private checkpoints: Checkpoint[] = [];
+  private isGitRepo: boolean;
+
+  constructor(workingDir: string, sessionId: string, storageRoot: string) {
+    this.workingDir = resolve(workingDir);
+    this.storageDir = join(storageRoot, 'checkpoints', sessionId);
+    this.indexPath = join(this.storageDir, 'index.json');
+    mkdirSync(this.storageDir, { recursive: true });
+    this.isGitRepo = tryGit('git rev-parse --is-inside-work-tree', this.workingDir) === 'true';
+    this.loadIndex();
+  }
+
+  list(): Checkpoint[] {
+    return [...this.checkpoints].reverse();
+  }
+
+  get(id: string): Checkpoint | undefined {
+    return this.checkpoints.find(c => c.id === id);
+  }
+
+  /**
+   * Create a checkpoint just before the first mutation in a turn.
+   * `mutatedFiles` is used in file mode; `summary` is shown in /checkpoints.
+   */
+  create(summary: string, userMessage: string, turnNumber: number, costUsd: number, mutatedFiles: Set<string>): Checkpoint {
+    const id = `cp-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+    const timestamp = new Date().toISOString();
+
+    let cp: Checkpoint;
+    if (this.isGitRepo) {
+      const stashRef = tryGit('git stash create', this.workingDir);
+      if (stashRef) {
+        const preHead = tryGit('git rev-parse HEAD', this.workingDir);
+        cp = {
+          id, turnNumber, timestamp, mode: 'git',
+          stashRef, preHead, filesChanged: [...mutatedFiles], summary, costUsd, userMessage,
+        };
+      } else {
+        cp = this.createFileCheckpoint(id, timestamp, turnNumber, summary, userMessage, costUsd, mutatedFiles);
+      }
+    } else {
+      cp = this.createFileCheckpoint(id, timestamp, turnNumber, summary, userMessage, costUsd, mutatedFiles);
+    }
+
+    this.checkpoints.push(cp);
+    this.saveIndex();
+    this.prune();
+    return cp;
+  }
+
+  private createFileCheckpoint(
+    id: string, timestamp: string, turnNumber: number,
+    summary: string, userMessage: string, costUsd: number,
+    mutatedFiles: Set<string>,
+  ): Checkpoint {
+    const dir = join(this.storageDir, id, 'files');
+    mkdirSync(dir, { recursive: true });
+    const files: string[] = [];
+    for (const rel of mutatedFiles) {
+      const source = join(this.workingDir, rel);
+      if (!existsSync(source)) { files.push(rel); continue; }
+      const dest = join(dir, rel);
+      mkdirSync(dirname(dest), { recursive: true });
+      try { copyFileSync(source, dest); files.push(rel); } catch { /* skip */ }
+    }
+    return { id, turnNumber, timestamp, mode: 'file', filesChanged: files, summary, costUsd, userMessage };
+  }
+
+  /**
+   * Restore to the given checkpoint. If `target` is a negative number, restore
+   * to the Nth checkpoint from the tail (so -1 == latest).
+   */
+  restore(target: string | number): { restored: Checkpoint; filesRestored: string[]; errors: string[] } {
+    let cp: Checkpoint | undefined;
+    if (typeof target === 'number') {
+      const idx = this.checkpoints.length + target; // e.g. -1 -> last index
+      cp = this.checkpoints[idx];
+    } else {
+      cp = this.get(target);
+    }
+    if (!cp) throw new Error(`Checkpoint not found: ${target}`);
+
+    const errors: string[] = [];
+    const filesRestored: string[] = [];
+
+    if (cp.mode === 'git' && cp.stashRef) {
+      // Stash current state first so user can recover it manually if desired.
+      tryGit('git stash push -u -m "kondi-chat pre-undo"', this.workingDir);
+      const out = tryGit(`git stash apply ${cp.stashRef}`, this.workingDir);
+      if (!out && tryGit('git status --porcelain', this.workingDir) === '') {
+        errors.push('Apply returned no output — stash may be empty');
+      }
+      filesRestored.push(...cp.filesChanged);
+    } else {
+      const dir = join(this.storageDir, cp.id, 'files');
+      for (const rel of cp.filesChanged) {
+        const source = join(dir, rel);
+        const dest = join(this.workingDir, rel);
+        try {
+          if (existsSync(source)) {
+            mkdirSync(dirname(dest), { recursive: true });
+            copyFileSync(source, dest);
+            filesRestored.push(rel);
+          } else if (existsSync(dest)) {
+            // File was created in that turn; delete it
+            rmSync(dest, { force: true });
+            filesRestored.push(rel);
+          }
+        } catch (e) {
+          errors.push(`${rel}: ${(e as Error).message}`);
+        }
+      }
+    }
+
+    return { restored: cp, filesRestored, errors };
+  }
+
+  /** Remove the oldest checkpoints beyond MAX_CHECKPOINTS. */
+  prune(): number {
+    if (this.checkpoints.length <= MAX_CHECKPOINTS) return 0;
+    const removeCount = this.checkpoints.length - MAX_CHECKPOINTS;
+    const removed = this.checkpoints.splice(0, removeCount);
+    for (const cp of removed) {
+      if (cp.mode === 'file') {
+        try { rmSync(join(this.storageDir, cp.id), { recursive: true, force: true }); } catch { /* ignore */ }
+      }
+    }
+    this.saveIndex();
+    return removeCount;
+  }
+
+  format(): string {
+    if (this.checkpoints.length === 0) return 'No checkpoints yet.';
+    const lines = ['Checkpoints (newest first):'];
+    for (const cp of this.list()) {
+      lines.push(
+        `  ${cp.id}  turn ${cp.turnNumber}  ${cp.mode}  ${cp.filesChanged.length} files  $${cp.costUsd.toFixed(4)}`
+        + `\n    "${cp.summary}"`,
+      );
+    }
+    return lines.join('\n');
+  }
+
+  private loadIndex(): void {
+    if (!existsSync(this.indexPath)) { this.checkpoints = []; return; }
+    try {
+      this.checkpoints = JSON.parse(readFileSync(this.indexPath, 'utf-8'));
+    } catch {
+      this.checkpoints = [];
+    }
+  }
+
+  private saveIndex(): void {
+    atomicWrite(this.indexPath, JSON.stringify(this.checkpoints, null, 2));
+  }
+}