@thispointon/kondi-chat 0.1.2

package/src/context/symbol-index.ts

@@ -0,0 +1,240 @@
+/**
+ * Symbol Index — regex-based function/class/export extraction.
+ *
+ * Scans the working directory at startup and after edits, caches
+ * results to .kondi-chat/index/symbols.json. Provides find_symbol
+ * and related_files tools so the agent can navigate the codebase
+ * structurally instead of grep-and-hope.
+ *
+ * Uses simple regex, not tree-sitter — fast, zero native deps,
+ * good enough for 90% of cases. Can upgrade to tree-sitter later
+ * if the regex falls short.
+ */
+
+import { readFileSync, writeFileSync, existsSync, readdirSync, statSync, mkdirSync } from 'node:fs';
+import { join, relative, extname, dirname } from 'node:path';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface SymbolEntry {
+  name: string;
+  kind: 'function' | 'class' | 'interface' | 'type' | 'const' | 'export' | 'method';
+  file: string;
+  line: number;
+}
+
+export interface FileSymbols {
+  file: string;
+  symbols: SymbolEntry[];
+  imports: string[];  // files this file imports from
+  mtime: number;
+}
+
+export interface SymbolIndex {
+  files: Record<string, FileSymbols>;
+  buildTime: string;
+}
+
+// ---------------------------------------------------------------------------
+// Extraction regexes (covers TS, JS, Python, Rust, Go)
+// ---------------------------------------------------------------------------
+
+const EXTRACTORS: Array<{ ext: string[]; patterns: Array<{ re: RegExp; kind: SymbolEntry['kind'] }> }> = [
+  {
+    ext: ['.ts', '.tsx', '.js', '.jsx'],
+    patterns: [
+      { re: /^export\s+(?:async\s+)?function\s+(\w+)/gm, kind: 'function' },
+      { re: /^export\s+(?:default\s+)?class\s+(\w+)/gm, kind: 'class' },
+      { re: /^export\s+interface\s+(\w+)/gm, kind: 'interface' },
+      { re: /^export\s+type\s+(\w+)/gm, kind: 'type' },
+      { re: /^export\s+const\s+(\w+)/gm, kind: 'const' },
+      { re: /^(?:async\s+)?function\s+(\w+)/gm, kind: 'function' },
+      { re: /^class\s+(\w+)/gm, kind: 'class' },
+      { re: /^interface\s+(\w+)/gm, kind: 'interface' },
+    ],
+  },
+  {
+    ext: ['.py'],
+    patterns: [
+      { re: /^def\s+(\w+)/gm, kind: 'function' },
+      { re: /^class\s+(\w+)/gm, kind: 'class' },
+      { re: /^(\w+)\s*=\s*/gm, kind: 'const' },
+    ],
+  },
+  {
+    ext: ['.rs'],
+    patterns: [
+      { re: /^pub\s+(?:async\s+)?fn\s+(\w+)/gm, kind: 'function' },
+      { re: /^pub\s+struct\s+(\w+)/gm, kind: 'class' },
+      { re: /^pub\s+enum\s+(\w+)/gm, kind: 'type' },
+      { re: /^pub\s+trait\s+(\w+)/gm, kind: 'interface' },
+      { re: /^fn\s+(\w+)/gm, kind: 'function' },
+      { re: /^struct\s+(\w+)/gm, kind: 'class' },
+    ],
+  },
+  {
+    ext: ['.go'],
+    patterns: [
+      { re: /^func\s+(?:\([^)]+\)\s+)?(\w+)/gm, kind: 'function' },
+      { re: /^type\s+(\w+)\s+struct/gm, kind: 'class' },
+      { re: /^type\s+(\w+)\s+interface/gm, kind: 'interface' },
+    ],
+  },
+];
+
+const IMPORT_RE_TS = /(?:import|from)\s+['"]([^'"]+)['"]/g;
+const IMPORT_RE_PY = /^(?:from|import)\s+(\S+)/gm;
+
+const SKIP_DIRS = new Set(['node_modules', '.git', '.kondi-chat', '.claude', 'dist', 'target', '__pycache__', '.next', '.venv', 'venv', 'build']);
+const CODE_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.py', '.rs', '.go']);
+const MAX_FILE_SIZE = 200_000;
+
+// ---------------------------------------------------------------------------
+// Index builder
+// ---------------------------------------------------------------------------
+
+export class SymbolIndexer {
+  private workingDir: string;
+  private cachePath: string;
+  private index: SymbolIndex = { files: {}, buildTime: '' };
+
+  constructor(workingDir: string) {
+    this.workingDir = workingDir;
+    const indexDir = join(workingDir, '.kondi-chat', 'index');
+    mkdirSync(indexDir, { recursive: true });
+    this.cachePath = join(indexDir, 'symbols.json');
+    this.load();
+  }
+
+  /** Build or refresh the index. Only re-scans files whose mtime changed. */
+  build(): number {
+    let scanned = 0;
+    const currentFiles = new Set<string>();
+
+    const scan = (dir: string, depth: number) => {
+      if (depth > 4) return;
+      try {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+          if (SKIP_DIRS.has(entry.name)) continue;
+          const abs = join(dir, entry.name);
+          const rel = relative(this.workingDir, abs);
+          if (entry.isDirectory()) {
+            scan(abs, depth + 1);
+          } else if (entry.isFile()) {
+            const ext = extname(entry.name).toLowerCase();
+            if (!CODE_EXTENSIONS.has(ext)) continue;
+            currentFiles.add(rel);
+            const stat = statSync(abs);
+            if (stat.size > MAX_FILE_SIZE) continue;
+            const cached = this.index.files[rel];
+            if (cached && cached.mtime === stat.mtimeMs) continue;
+            // Re-scan this file
+            const content = readFileSync(abs, 'utf-8');
+            this.index.files[rel] = this.extractFileSymbols(rel, content, ext, stat.mtimeMs);
+            scanned++;
+          }
+        }
+      } catch { /* permission error */ }
+    };
+
+    scan(this.workingDir, 0);
+
+    // Remove entries for deleted files
+    for (const file of Object.keys(this.index.files)) {
+      if (!currentFiles.has(file)) delete this.index.files[file];
+    }
+
+    this.index.buildTime = new Date().toISOString();
+    this.save();
+    return scanned;
+  }
+
+  /** Find symbols by name (prefix match). */
+  findSymbol(query: string): SymbolEntry[] {
+    const lower = query.toLowerCase();
+    const results: SymbolEntry[] = [];
+    for (const fs of Object.values(this.index.files)) {
+      for (const sym of fs.symbols) {
+        if (sym.name.toLowerCase().includes(lower)) {
+          results.push(sym);
+        }
+      }
+    }
+    return results.slice(0, 20);
+  }
+
+  /** Find files that import or are imported by a given file. */
+  relatedFiles(filePath: string): string[] {
+    const rel = filePath.replace(/^\.\//, '');
+    const related = new Set<string>();
+
+    // Files that this file imports
+    const entry = this.index.files[rel];
+    if (entry) {
+      for (const imp of entry.imports) related.add(imp);
+    }
+
+    // Files that import this file
+    for (const [file, fs] of Object.entries(this.index.files)) {
+      if (fs.imports.some(i => i.includes(rel) || rel.includes(i))) {
+        related.add(file);
+      }
+    }
+
+    related.delete(rel);
+    return [...related].slice(0, 15);
+  }
+
+  /** Format for display. */
+  format(): string {
+    const totalSymbols = Object.values(this.index.files).reduce((s, f) => s + f.symbols.length, 0);
+    return `Symbol index: ${Object.keys(this.index.files).length} files, ${totalSymbols} symbols (${this.index.buildTime || 'not built'})`;
+  }
+
+  // ── Private ──────────────────────────────────────────────────────────
+
+  private extractFileSymbols(file: string, content: string, ext: string, mtime: number): FileSymbols {
+    const symbols: SymbolEntry[] = [];
+    const imports: string[] = [];
+
+    // Find matching extractor
+    const extractor = EXTRACTORS.find(e => e.ext.includes(ext));
+    if (extractor) {
+      const lines = content.split('\n');
+      for (const { re, kind } of extractor.patterns) {
+        re.lastIndex = 0;
+        let match;
+        while ((match = re.exec(content)) !== null) {
+          const line = content.slice(0, match.index).split('\n').length;
+          symbols.push({ name: match[1], kind, file, line });
+        }
+      }
+    }
+
+    // Extract imports
+    const importRe = ext === '.py' ? IMPORT_RE_PY : IMPORT_RE_TS;
+    importRe.lastIndex = 0;
+    let m;
+    while ((m = importRe.exec(content)) !== null) {
+      const imp = m[1].replace(/^\.\//, '').replace(/\.\w+$/, '');
+      if (!imp.startsWith('.') || imp.includes('/')) {
+        imports.push(imp);
+      }
+    }
+
+    return { file, symbols, imports, mtime };
+  }
+
+  private load(): void {
+    if (!existsSync(this.cachePath)) return;
+    try {
+      this.index = JSON.parse(readFileSync(this.cachePath, 'utf-8'));
+    } catch { /* start fresh */ }
+  }
+
+  private save(): void {
+    writeFileSync(this.cachePath, JSON.stringify(this.index, null, 2));
+  }
+}

package/src/council/profiles.ts

@@ -0,0 +1,137 @@
+/**
+ * Council Profiles — configurations for the `/council` command.
+ *
+ * A council profile is a kondi-council engine config file: a set of
+ * personas (manager / consultants / worker) plus orchestration settings.
+ * The deliberation engine itself is bundled at `src/council-engine/`.
+ *
+ * Presets are seeded on first run by copying the engine's curated
+ * configs (`src/council-engine/configs/councils/*.json`) into
+ * `.kondi-chat/councils/`. Users can edit those or add their own JSON
+ * files there; the filename (without `.json`) is the profile id passed
+ * to `/council run <id>`.
+ */
+
+import { readFileSync, existsSync, mkdirSync, readdirSync, copyFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+// ---------------------------------------------------------------------------
+// Types — mirror the engine's CouncilConfigFile
+// (see src/council-engine/cli/council-config.ts). Kept as a local copy
+// because the engine subtree is excluded from kondi-chat's typecheck.
+// ---------------------------------------------------------------------------
+
+export interface CouncilPersona {
+  name: string;
+  role: 'manager' | 'worker' | 'consultant' | 'reviewer';
+  provider?: string;
+  model?: string;
+  avatar?: string;
+  systemPrompt?: string;
+  traits?: string[];
+  stance?: 'advocate' | 'critic' | 'neutral' | 'wildcard';
+  domain?: string;
+  temperature?: number;
+  suppressPersona?: boolean;
+  toolAccess?: 'full' | 'none';
+}
+
+export interface CouncilProfile {
+  /** Human-readable council title. */
+  name: string;
+  /** Council type — council, coding, analysis, review, agent, code_planning. */
+  type?: string;
+  personas: CouncilPersona[];
+  orchestration?: {
+    maxRounds?: number;
+    maxRevisions?: number;
+    contextTokenBudget?: number;
+    summarizeAfterRound?: number;
+    consultantExecution?: 'sequential' | 'parallel';
+    evolveContext?: boolean;
+    bootstrapContext?: boolean;
+  };
+  output?: { format?: string; directory?: string; sessionExport?: boolean };
+  expectedOutput?: string;
+  decisionCriteria?: string[];
+  testCommand?: string;
+  maxDebugCycles?: number;
+  maxReviewCycles?: number;
+}
+
+/** Bundled engine presets — copied into .kondi-chat/councils/ on first run. */
+const ENGINE_PRESETS_DIR = join(
+  dirname(fileURLToPath(import.meta.url)),
+  '..', 'council-engine', 'configs', 'councils',
+);
+
+// ---------------------------------------------------------------------------
+// Profile manager
+// ---------------------------------------------------------------------------
+
+export class CouncilProfileManager {
+  private profileDir: string;
+
+  constructor(storageDir: string) {
+    this.profileDir = join(storageDir, 'councils');
+    mkdirSync(this.profileDir, { recursive: true });
+    this.ensurePresets();
+  }
+
+  /** Profile ids — the JSON filenames (without extension) in the dir. */
+  ids(): string[] {
+    return readdirSync(this.profileDir)
+      .filter(f => f.endsWith('.json'))
+      .map(f => f.slice(0, -5))
+      .sort();
+  }
+
+  /** Load a profile by id. Returns undefined for unknown / invalid files. */
+  get(id: string): CouncilProfile | undefined {
+    const path = this.getPath(id);
+    if (!existsSync(path)) return undefined;
+    try {
+      return JSON.parse(readFileSync(path, 'utf-8')) as CouncilProfile;
+    } catch {
+      return undefined;
+    }
+  }
+
+  /** Absolute path to a profile's config file (passed to the engine). */
+  getPath(id: string): string {
+    return join(this.profileDir, `${id}.json`);
+  }
+
+  /** Human-readable roster for `/council list`. */
+  format(): string {
+    const ids = this.ids();
+    if (ids.length === 0) return 'No council profiles configured.';
+    const lines: string[] = ['Council profiles — run with /council run <id> "<brief>":'];
+    for (const id of ids) {
+      const p = this.get(id);
+      if (!p) continue;
+      const rounds = p.orchestration?.maxRounds ?? '?';
+      const roster = p.personas.map(x => `${x.name}(${x.role})`).join(', ');
+      lines.push('');
+      lines.push(`  ${id} — ${p.name}`);
+      lines.push(`    Type: ${p.type || 'council'} | Rounds: ${rounds} | ${p.personas.length} personas`);
+      lines.push(`    ${roster}`);
+    }
+    return lines.join('\n');
+  }
+
+  /**
+   * Seed presets from the bundled engine configs. Only copies files that
+   * don't already exist, so user edits to a preset are never clobbered.
+   */
+  private ensurePresets(): void {
+    if (!existsSync(ENGINE_PRESETS_DIR)) return;
+    for (const file of readdirSync(ENGINE_PRESETS_DIR).filter(f => f.endsWith('.json'))) {
+      const dest = join(this.profileDir, file);
+      if (!existsSync(dest)) {
+        copyFileSync(join(ENGINE_PRESETS_DIR, file), dest);
+      }
+    }
+  }
+}

package/src/council/tool.ts

@@ -0,0 +1,138 @@
+/**
+ * Council Tool — runs the bundled kondi-council engine as a subprocess.
+ *
+ * The deliberation engine is vendored at `src/council-engine/` (no
+ * external repo required). Chat passes a brief, a working directory, and
+ * a council profile; the engine deliberates and returns structured JSON.
+ */
+
+import { execSync } from 'node:child_process';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import type { ToolDefinition } from '../types.ts';
+import type { CouncilProfileManager } from './profiles.ts';
+
+// Bundled engine entry point — resolved relative to this module so it
+// works regardless of where kondi-chat was launched from.
+const ENGINE_ENTRY = resolve(
+  dirname(fileURLToPath(import.meta.url)),
+  '..', 'council-engine', 'cli', 'run-council.ts',
+);
+
+// ---------------------------------------------------------------------------
+// Tool definition
+// ---------------------------------------------------------------------------
+
+export const COUNCIL_TOOL: ToolDefinition = {
+  name: 'run_council',
+  description: 'Run a multi-model deliberation council for complex decisions. Use for architecture reviews, security audits, major design decisions, or when you need multiple AI perspectives. This is expensive — use intentionally.',
+  parameters: {
+    type: 'object',
+    properties: {
+      profile: {
+        type: 'string',
+        description: 'Council profile id (e.g., coding, analysis, debate, code-planning)',
+      },
+      brief: {
+        type: 'string',
+        description: 'What to deliberate on — the problem statement',
+      },
+      files: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Relevant file paths to include as context',
+      },
+    },
+    required: ['profile', 'brief'],
+  },
+};
+
+// ---------------------------------------------------------------------------
+// Executor
+// ---------------------------------------------------------------------------
+
+export async function executeCouncil(
+  profileName: string,
+  brief: string,
+  _files: string[],
+  workingDir: string,
+  profileManager: CouncilProfileManager,
+): Promise<{ content: string; isError?: boolean }> {
+  const profile = profileManager.get(profileName);
+  if (!profile) {
+    const available = profileManager.ids().join(', ') || '(none)';
+    return {
+      content: `Unknown council profile: ${profileName}. Available: ${available}`,
+      isError: true,
+    };
+  }
+
+  const configPath = profileManager.getPath(profileName);
+  process.stderr.write(
+    `[council] Running ${profileName} (${profile.type || 'council'}): ${brief.slice(0, 80)}\n`,
+  );
+
+  // Engine CLI contract — see src/council-engine/cli/run-council.ts.
+  // --output none keeps the user's working dir clean; --json-stdout still
+  // emits the structured result on stdout regardless.
+  const args = [
+    '--config', configPath,
+    '--task', brief,
+    '--working-dir', workingDir,
+    '--output', 'none',
+    '--json-stdout',
+    '--no-session-export',
+    '--quiet',
+  ];
+
+  try {
+    const cmd = `npx tsx ${JSON.stringify(ENGINE_ENTRY)} ${args.map(a => JSON.stringify(a)).join(' ')}`;
+    const output = execSync(cmd, {
+      cwd: workingDir,
+      encoding: 'utf-8',
+      timeout: 600_000, // 10 min — councils fan out across models for multiple rounds
+      env: { ...process.env },
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    // The engine writes some internal logs to stdout; the --json-stdout
+    // result is a single JSON line. Extract the last line that parses.
+    const result = parseLastJson(output);
+    if (result) {
+      const summary = [
+        `Council: ${profile.name} (${profile.type || 'council'})`,
+        `Status: ${result.status || 'completed'}`,
+        '',
+        result.decision ? `Decision:\n${result.decision}` : '',
+        result.output ? `Output:\n${result.output}` : '',
+        result.summary ? `Summary:\n${result.summary}` : '',
+      ].filter(Boolean).join('\n');
+      return { content: summary };
+    }
+    // No JSON found — return the tail of raw output as a fallback.
+    return { content: output.slice(-4000) };
+  } catch (error: any) {
+    const stderr = (error.stderr?.toString() || '').slice(-1000);
+    const stdout = (error.stdout?.toString() || '').slice(-1000);
+    return {
+      content: `Council failed: ${error.message}\n${stderr}\n${stdout}`,
+      isError: true,
+    };
+  }
+}
+
+/** Scan output lines bottom-up for the last one that parses as a JSON object. */
+function parseLastJson(output: string): any | undefined {
+  const lines = output.split('\n').map(l => l.trim()).filter(Boolean);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i];
+    if (line.startsWith('{') && line.endsWith('}')) {
+      try {
+        return JSON.parse(line);
+      } catch {
+        /* keep scanning */
+      }
+    }
+  }
+  return undefined;
+}