@thispointon/kondi-chat 0.1.2

package/src/engine/git-tools.ts

@@ -0,0 +1,246 @@
+/**
+ * Git Tools — first-class git awareness.
+ *
+ * detectGitRepo() shells out to git and returns a plain snapshot the
+ * backend caches for prompt injection and the TUI status bar.
+ * Mutating tools refresh the snapshot after execution.
+ */
+
+import { execSync } from 'node:child_process';
+import type { ToolDefinition } from '../types.ts';
+import { computeUnifiedDiff } from './diff.ts';
+
+const GIT_TIMEOUT_MS = 15_000;
+
+export interface GitContext {
+  isGitRepo: boolean;
+  branch: string;
+  dirtyCount: number;
+  untrackedCount: number;
+  stagedCount: number;
+  lastCommitHash: string;
+  lastCommitMessage: string;
+  hasRemote: boolean;
+  remoteUrl?: string;
+  isWorktree: boolean;
+}
+
+function gitQ(cmd: string, cwd: string): string {
+  return execSync(cmd, { cwd, encoding: 'utf-8', timeout: GIT_TIMEOUT_MS, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+}
+
+function tryGit(cmd: string, cwd: string): string {
+  try { return gitQ(cmd, cwd); } catch { return ''; }
+}
+
+export function detectGitRepo(workingDir: string): GitContext {
+  const empty: GitContext = {
+    isGitRepo: false, branch: '', dirtyCount: 0, untrackedCount: 0, stagedCount: 0,
+    lastCommitHash: '', lastCommitMessage: '', hasRemote: false, isWorktree: false,
+  };
+  const isRepo = tryGit('git rev-parse --is-inside-work-tree', workingDir);
+  if (isRepo !== 'true') return empty;
+
+  const branch = tryGit('git rev-parse --abbrev-ref HEAD', workingDir) || 'HEAD';
+  const status = tryGit('git status --porcelain', workingDir);
+  let dirty = 0, untracked = 0, staged = 0;
+  for (const line of status.split('\n')) {
+    if (!line) continue;
+    const x = line[0];
+    const y = line[1];
+    if (x === '?' && y === '?') untracked++;
+    else {
+      if (x !== ' ' && x !== '?') staged++;
+      if (y !== ' ') dirty++;
+    }
+  }
+
+  const lastHash = tryGit('git rev-parse --short HEAD', workingDir);
+  const lastMsg = tryGit('git log -1 --pretty=%s', workingDir);
+  const remoteUrl = tryGit('git config --get remote.origin.url', workingDir);
+  const gitDir = tryGit('git rev-parse --git-dir', workingDir);
+  const commonDir = tryGit('git rev-parse --git-common-dir', workingDir);
+  const isWorktree = gitDir !== '' && commonDir !== '' && gitDir !== commonDir && gitDir !== '.git';
+
+  return {
+    isGitRepo: true,
+    branch,
+    dirtyCount: dirty,
+    untrackedCount: untracked,
+    stagedCount: staged,
+    lastCommitHash: lastHash,
+    lastCommitMessage: lastMsg,
+    hasRemote: remoteUrl !== '',
+    remoteUrl: remoteUrl || undefined,
+    isWorktree,
+  };
+}
+
+export function formatGitContextForPrompt(ctx: GitContext): string {
+  if (!ctx.isGitRepo) return '';
+  const parts: string[] = [];
+  parts.push(`Branch: ${ctx.branch}${ctx.isWorktree ? ' (worktree)' : ''}`);
+  parts.push(`Status: ${ctx.stagedCount} staged, ${ctx.dirtyCount} modified, ${ctx.untrackedCount} untracked`);
+  if (ctx.lastCommitHash) parts.push(`Last commit: ${ctx.lastCommitHash} ${ctx.lastCommitMessage}`);
+  if (ctx.remoteUrl) parts.push(`Remote: ${ctx.remoteUrl}`);
+  return `## Git\n${parts.join('\n')}`;
+}
+
+export const GIT_TOOLS: ToolDefinition[] = [
+  {
+    name: 'git_status',
+    description: 'Show the current git status: branch, modified files, staged files, untracked files.',
+    parameters: { type: 'object', properties: {} },
+  },
+  {
+    name: 'git_diff',
+    description: 'Show the git diff for staged or unstaged changes. Optionally filter to a single file.',
+    parameters: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'File path to diff (optional)' },
+        staged: { type: 'boolean', description: 'Show staged changes only (default false)' },
+      },
+    },
+  },
+  {
+    name: 'git_commit',
+    description: 'Create a git commit. Stages the listed files first; errors if no files provided.',
+    parameters: {
+      type: 'object',
+      properties: {
+        message: { type: 'string', description: 'Commit message' },
+        files: { type: 'array', items: { type: 'string' }, description: 'Files to stage before committing' },
+      },
+      required: ['message', 'files'],
+    },
+  },
+  {
+    name: 'git_log',
+    description: 'Show recent git log entries.',
+    parameters: {
+      type: 'object',
+      properties: {
+        count: { type: 'number', description: 'Number of commits to show (default 10)' },
+      },
+    },
+  },
+  {
+    name: 'git_branch',
+    description: 'List branches, or create/switch to a branch.',
+    parameters: {
+      type: 'object',
+      properties: {
+        create: { type: 'string', description: 'Create and switch to this new branch' },
+        switch: { type: 'string', description: 'Switch to this existing branch' },
+      },
+    },
+  },
+  {
+    name: 'git_create_pr',
+    description: 'Create a GitHub pull request for the current branch via the gh CLI.',
+    parameters: {
+      type: 'object',
+      properties: {
+        title: { type: 'string', description: 'PR title' },
+        body: { type: 'string', description: 'PR body' },
+        base: { type: 'string', description: 'Base branch (default main)' },
+        draft: { type: 'boolean', description: 'Create as draft PR' },
+      },
+      required: ['title'],
+    },
+  },
+];
+
+export async function executeGitTool(
+  name: string,
+  args: Record<string, unknown>,
+  workingDir: string,
+  ctx: GitContext,
+): Promise<{ content: string; isError?: boolean; diff?: string }> {
+  if (!ctx.isGitRepo) {
+    return { content: 'Not a git repository', isError: true };
+  }
+  try {
+    switch (name) {
+      case 'git_status': {
+        const out = gitQ('git status --short --branch', workingDir);
+        return { content: out || '(clean)' };
+      }
+      case 'git_diff': {
+        const path = args.path ? ` -- ${JSON.stringify(String(args.path))}` : '';
+        const staged = args.staged ? ' --cached' : '';
+        const out = gitQ(`git diff${staged}${path}`, workingDir);
+        if (!out) return { content: '(no changes)' };
+        const truncated = out.length > 5000 ? out.slice(0, 5000) + '\n... (truncated)' : out;
+        return { content: truncated, diff: truncated };
+      }
+      case 'git_log': {
+        const count = Math.max(1, Math.min(50, (args.count as number) || 10));
+        const out = gitQ(`git log -n ${count} --oneline --decorate`, workingDir);
+        return { content: out || '(no commits)' };
+      }
+      case 'git_branch': {
+        const create = args.create as string | undefined;
+        const sw = args.switch as string | undefined;
+        if (create) {
+          if (!/^[\w./-]+$/.test(create)) return { content: `Invalid branch name: ${create}`, isError: true };
+          gitQ(`git checkout -b ${JSON.stringify(create)}`, workingDir);
+          return { content: `Created and switched to ${create}` };
+        }
+        if (sw) {
+          if (!/^[\w./-]+$/.test(sw)) return { content: `Invalid branch name: ${sw}`, isError: true };
+          gitQ(`git checkout ${JSON.stringify(sw)}`, workingDir);
+          return { content: `Switched to ${sw}` };
+        }
+        const out = gitQ('git branch -vv', workingDir);
+        return { content: out };
+      }
+      case 'git_commit': {
+        const message = String(args.message || '').trim();
+        if (!message) return { content: 'Empty commit message', isError: true };
+        if (message.split('\n')[0].length > 500) {
+          return { content: 'Commit subject exceeds 500 characters', isError: true };
+        }
+        const files = args.files as string[] | undefined;
+        if (!files || files.length === 0) {
+          return { content: 'git_commit requires a non-empty `files` list', isError: true };
+        }
+        // Stage explicitly listed files (deletions included).
+        const quoted = files.map(f => JSON.stringify(f)).join(' ');
+        gitQ(`git add -- ${quoted}`, workingDir);
+        // Use --cleanup=strip and -F - via env-free execSync: pass message via -m (single arg, escaped).
+        gitQ(`git commit -m ${JSON.stringify(message)}`, workingDir);
+        const hash = tryGit('git rev-parse --short HEAD', workingDir);
+        return { content: `Committed ${hash}: ${message.split('\n')[0]}` };
+      }
+      case 'git_create_pr': {
+        if (ctx.branch === 'main' || ctx.branch === 'master') {
+          return { content: `Refusing to PR from ${ctx.branch}. Create a feature branch first.`, isError: true };
+        }
+        try { gitQ('gh --version', workingDir); }
+        catch { return { content: 'gh CLI not found. Install from https://cli.github.com/', isError: true }; }
+        const title = String(args.title || '').trim();
+        if (!title) return { content: 'PR title required', isError: true };
+        const body = String(args.body || '');
+        const base = String(args.base || 'main');
+        const draft = args.draft ? ' --draft' : '';
+        const out = gitQ(
+          `gh pr create --title ${JSON.stringify(title)} --body ${JSON.stringify(body)} --base ${JSON.stringify(base)}${draft}`,
+          workingDir,
+        );
+        return { content: out };
+      }
+    }
+    return { content: `Unknown git tool: ${name}`, isError: true };
+  } catch (e) {
+    const err = e as any;
+    const stderr = err.stderr?.toString() || '';
+    const stdout = err.stdout?.toString() || '';
+    return { content: `${err.message}\n${stderr || stdout}`.trim(), isError: true };
+  }
+}
+
+// `computeUnifiedDiff` is re-exported for callers that think of git diffs
+// as a single namespace. The canonical implementation lives in ./diff.ts.
+export { computeUnifiedDiff };

package/src/engine/hooks.ts

@@ -0,0 +1,181 @@
+/**
+ * Hooks — run shell commands or tool calls before/after any agent tool.
+ *
+ * Config lives at `.kondi-chat/hooks.json`. Keys: `before_<tool>` / `after_<tool>`.
+ * Each hook is either a shorthand shell command string, a shell object, or a
+ * tool-call object. Before-hooks can block execution; after-hooks augment the
+ * tool result.
+ */
+
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import type { ToolContext, ToolExecutionResult } from './tools.ts';
+
+export type HookFailureMode = 'block' | 'warn' | 'ignore';
+
+export type HookDefinition =
+  | string
+  | {
+      type?: 'shell' | 'tool';
+      command?: string;
+      tool?: string;
+      args?: Record<string, unknown>;
+      onFailure?: HookFailureMode;
+      timeoutMs?: number;
+    };
+
+export interface HooksConfig {
+  hooks?: Record<string, HookDefinition | HookDefinition[]>;
+  builtin?: { autoFormat?: boolean };
+  defaultFailureMode?: HookFailureMode;
+  defaultTimeoutMs?: number;
+}
+
+const DEFAULT_TIMEOUT_MS = 15_000;
+const DEFAULT_FAILURE_MODE: HookFailureMode = 'warn';
+const MAX_HOOK_DEPTH = 3;
+
+type ToolExecutor = (name: string, args: Record<string, unknown>, ctx: ToolContext) => Promise<ToolExecutionResult>;
+
+function shellQuote(s: string): string {
+  // Single-quote everything, escape embedded single quotes.
+  return `'${String(s).replace(/'/g, `'\\''`)}'`;
+}
+
+function interpolate(template: string, vars: Record<string, unknown>): string {
+  return template.replace(/\{(\w+)\}/g, (_m, key) => {
+    const v = vars[key];
+    if (v === undefined || v === null) return '';
+    return shellQuote(String(v));
+  });
+}
+
+export class HookRunner {
+  private config: HooksConfig;
+  private workingDir: string;
+  private toolExecutor: ToolExecutor | null = null;
+  private depth = 0;
+
+  constructor(configPath: string, workingDir: string) {
+    this.workingDir = workingDir;
+    this.config = loadConfig(configPath);
+    if (this.config.builtin?.autoFormat) this.installBuiltinFormatters();
+  }
+
+  setToolExecutor(fn: ToolExecutor): void { this.toolExecutor = fn; }
+
+  async runBefore(tool: string, args: Record<string, unknown>, ctx: ToolContext, emit?: (e: any) => void): Promise<{ blocked: boolean; messages: string[] }> {
+    const hooks = this.getHooks(`before_${tool}`);
+    if (hooks.length === 0 || this.depth >= MAX_HOOK_DEPTH) return { blocked: false, messages: [] };
+    const messages: string[] = [];
+    for (const hook of hooks) {
+      const outcome = await this.runHook(hook, tool, args, undefined, ctx, emit);
+      if (outcome.blocked) return { blocked: true, messages: [outcome.message] };
+      if (outcome.message) messages.push(outcome.message);
+    }
+    return { blocked: false, messages };
+  }
+
+  async runAfter(
+    tool: string,
+    args: Record<string, unknown>,
+    result: ToolExecutionResult,
+    ctx: ToolContext,
+    emit?: (e: any) => void,
+  ): Promise<ToolExecutionResult> {
+    const hooks = this.getHooks(`after_${tool}`);
+    if (hooks.length === 0 || this.depth >= MAX_HOOK_DEPTH) return result;
+    let out = { ...result };
+    for (const hook of hooks) {
+      const outcome = await this.runHook(hook, tool, args, out, ctx, emit);
+      if (outcome.blocked) {
+        out = { ...out, isError: true, content: `${out.content}\n[after-hook blocked] ${outcome.message}` };
+      } else if (outcome.message) {
+        out = { ...out, content: `${out.content}\n[hook] ${outcome.message}` };
+      }
+    }
+    return out;
+  }
+
+  private getHooks(key: string): HookDefinition[] {
+    const raw = this.config.hooks?.[key];
+    if (!raw) return [];
+    return Array.isArray(raw) ? raw : [raw];
+  }
+
+  private async runHook(
+    hook: HookDefinition,
+    tool: string,
+    args: Record<string, unknown>,
+    result: ToolExecutionResult | undefined,
+    ctx: ToolContext,
+    emit?: (e: any) => void,
+  ): Promise<{ blocked: boolean; message: string }> {
+    const normalized = typeof hook === 'string' ? { type: 'shell' as const, command: hook } : hook;
+    const onFailure: HookFailureMode = normalized.onFailure ?? this.config.defaultFailureMode ?? DEFAULT_FAILURE_MODE;
+    const timeoutMs = normalized.timeoutMs ?? this.config.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS;
+
+    const vars: Record<string, unknown> = { ...args, cwd: this.workingDir };
+    if (result) vars.result = result.content.slice(0, 2000);
+
+    const started = Date.now();
+    try {
+      if (normalized.type === 'tool' || (!normalized.type && normalized.tool)) {
+        if (!this.toolExecutor) throw new Error('Tool executor not wired');
+        const toolName = normalized.tool!;
+        this.depth++;
+        try { await this.toolExecutor(toolName, normalized.args || {}, ctx); }
+        finally { this.depth--; }
+        emit?.({ type: 'activity', text: `${toolName} (${Date.now() - started}ms)`, activity_type: 'hook' });
+        return { blocked: false, message: `tool:${toolName}` };
+      }
+
+      const template = normalized.command || (typeof hook === 'string' ? hook : '');
+      if (!template) return { blocked: false, message: '' };
+      const command = interpolate(template, vars);
+      execSync(command, {
+        cwd: this.workingDir,
+        encoding: 'utf-8',
+        timeout: timeoutMs,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+      emit?.({ type: 'activity', text: `${tool} (${Date.now() - started}ms)`, activity_type: 'hook' });
+      return { blocked: false, message: `ok (${Date.now() - started}ms)` };
+    } catch (e) {
+      const msg = (e as Error).message;
+      if (onFailure === 'block') return { blocked: true, message: `blocked: ${msg}` };
+      if (onFailure === 'warn') return { blocked: false, message: `warn: ${msg}` };
+      return { blocked: false, message: '' };
+    }
+  }
+
+  private installBuiltinFormatters(): void {
+    const wd = this.workingDir;
+    const hooks: Record<string, HookDefinition | HookDefinition[]> = { ...(this.config.hooks || {}) };
+    const add = (key: string, cmd: string) => {
+      if (!hooks[key]) hooks[key] = cmd;
+    };
+    if (existsSync(join(wd, '.prettierrc')) || existsSync(join(wd, '.prettierrc.json'))) {
+      add('after_write_file', 'npx prettier --write {path}');
+      add('after_edit_file', 'npx prettier --write {path}');
+    } else if (existsSync(join(wd, 'pyproject.toml'))) {
+      add('after_write_file', 'black {path}');
+      add('after_edit_file', 'black {path}');
+    } else if (existsSync(join(wd, 'Cargo.toml'))) {
+      add('after_write_file', 'rustfmt {path}');
+      add('after_edit_file', 'rustfmt {path}');
+    }
+    this.config.hooks = hooks;
+  }
+}
+
+function loadConfig(path: string): HooksConfig {
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(readFileSync(path, 'utf-8')) as HooksConfig;
+  } catch (e) {
+    process.stderr.write(`[hooks] failed to parse ${path}: ${(e as Error).message}\n`);
+    return {};
+  }
+}

package/src/engine/loop-guard.ts

@@ -0,0 +1,155 @@
+/**
+ * Loop Guard — prevents runaway costs in autonomous loops.
+ *
+ * Tracks:
+ *   - Iteration count vs cap
+ *   - Cumulative cost vs budget
+ *   - Error deduplication (same error twice = stuck)
+ *   - Diminishing returns (no progress between iterations)
+ *
+ * Used by the regular agent loop inside handleSubmit and by the autonomous
+ * /loop command which runs handleSubmit with opts.loop = true (so the loop
+ * does not stop at the first no-tool-call response).
+ */
+
+import type { BudgetProfile } from '../router/profiles.ts';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface LoopStatus {
+  iteration: number;
+  maxIterations: number;
+  costUsd: number;
+  costCap: number;
+  lastErrors: string[];
+  stuck: boolean;
+  shouldStop: boolean;
+  stopReason?: string;
+}
+
+// ---------------------------------------------------------------------------
+// Loop Guard
+// ---------------------------------------------------------------------------
+
+export class LoopGuard {
+  private iteration = 0;
+  private costUsd = 0;
+  private recentErrors: string[] = [];
+  private errorCounts: Map<string, number> = new Map();
+  private lastOutputHash = '';
+
+  private maxIterations: number;
+  private costCap: number;
+
+  constructor(profile: BudgetProfile) {
+    this.maxIterations = profile.loopIterationCap;
+    this.costCap = profile.loopCostCap;
+  }
+
+  /** Record a completed iteration */
+  recordIteration(cost: number, error?: string, outputHash?: string): void {
+    this.iteration++;
+    this.costUsd += cost;
+
+    if (error) {
+      // Normalize error for dedup (strip line numbers, timestamps)
+      const normalized = this.normalizeError(error);
+      this.recentErrors.push(normalized);
+      if (this.recentErrors.length > 5) this.recentErrors.shift();
+
+      const count = (this.errorCounts.get(normalized) || 0) + 1;
+      this.errorCounts.set(normalized, count);
+    }
+
+    if (outputHash) {
+      this.lastOutputHash = outputHash;
+    }
+  }
+
+  /** Check if the loop should continue */
+  check(): LoopStatus {
+    const status: LoopStatus = {
+      iteration: this.iteration,
+      maxIterations: this.maxIterations,
+      costUsd: this.costUsd,
+      costCap: this.costCap,
+      lastErrors: [...this.recentErrors.slice(-3)],
+      stuck: false,
+      shouldStop: false,
+    };
+
+    // Iteration cap
+    if (this.iteration >= this.maxIterations) {
+      status.shouldStop = true;
+      status.stopReason = `iteration limit (${this.maxIterations})`;
+      return status;
+    }
+
+    // Cost cap
+    if (this.costUsd >= this.costCap) {
+      status.shouldStop = true;
+      status.stopReason = `cost limit ($${this.costCap.toFixed(2)}, spent $${this.costUsd.toFixed(4)})`;
+      return status;
+    }
+
+    // Error deduplication — same error 3+ times means stuck
+    for (const [error, count] of this.errorCounts) {
+      if (count >= 3) {
+        status.stuck = true;
+        status.shouldStop = true;
+        status.stopReason = `stuck on repeated error (${count}x): ${error.slice(0, 100)}`;
+        return status;
+      }
+    }
+
+    // Same error back-to-back
+    if (this.recentErrors.length >= 2) {
+      const last = this.recentErrors[this.recentErrors.length - 1];
+      const prev = this.recentErrors[this.recentErrors.length - 2];
+      if (last === prev) {
+        status.stuck = true;
+        status.shouldStop = true;
+        status.stopReason = `same error repeated: ${last.slice(0, 100)}`;
+        return status;
+      }
+    }
+
+    return status;
+  }
+
+  /** Get a summary for display */
+  getSummary(): string {
+    const status = this.check();
+    return [
+      `Iteration ${status.iteration}/${status.maxIterations}`,
+      `Cost: $${status.costUsd.toFixed(4)} / $${status.costCap.toFixed(2)}`,
+      status.stuck ? 'STUCK — same error repeating' : '',
+      status.shouldStop ? `Stopped: ${status.stopReason}` : 'Running',
+    ].filter(Boolean).join(' | ');
+  }
+
+  /** Reset for a new loop */
+  reset(): void {
+    this.iteration = 0;
+    this.costUsd = 0;
+    this.recentErrors = [];
+    this.errorCounts.clear();
+    this.lastOutputHash = '';
+  }
+
+  // -------------------------------------------------------------------------
+  // Helpers
+  // -------------------------------------------------------------------------
+
+  private normalizeError(error: string): string {
+    return error
+      .replace(/line \d+/g, 'line N')
+      .replace(/\d{4}-\d{2}-\d{2}/g, 'DATE')
+      .replace(/\d+:\d+:\d+/g, 'TIME')
+      .replace(/0x[a-f0-9]+/gi, '0xADDR')
+      .trim()
+      .slice(0, 300);
+  }
+}