vibebug 0.1.0

package/dist/index.js

@@ -0,0 +1,1720 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/utils/constants.ts
+var VERSION, APP_NAME, DB_FILENAME, VIBEBUG_DIR, DEFAULT_DASHBOARD_PORT, DEFAULT_RING_BUFFER_SIZE, DEFAULT_TAIL_LINES, DEFAULT_STREAM_QUIET_TIMEOUT_MS, DEFAULT_STREAM_COOLDOWN_MS, MAX_ERROR_BLOCK_LINES, MAX_DIFF_SIZE, DEFAULT_AI_MODEL, AI_PRICING, DEFAULT_ESTIMATED_OUTPUT_TOKENS, CHARS_PER_TOKEN;
+var init_constants = __esm({
+  "src/utils/constants.ts"() {
+    "use strict";
+    VERSION = "0.1.0";
+    APP_NAME = "vibebug";
+    DB_FILENAME = "vibebug.db";
+    VIBEBUG_DIR = ".vibebug";
+    DEFAULT_DASHBOARD_PORT = 7600;
+    DEFAULT_RING_BUFFER_SIZE = 200 * 1024;
+    DEFAULT_TAIL_LINES = 200;
+    DEFAULT_STREAM_QUIET_TIMEOUT_MS = 2e3;
+    DEFAULT_STREAM_COOLDOWN_MS = 6e4;
+    MAX_ERROR_BLOCK_LINES = 50;
+    MAX_DIFF_SIZE = 50 * 1024;
+    DEFAULT_AI_MODEL = "claude-sonnet";
+    AI_PRICING = {
+      "claude-sonnet": { input: 3, output: 15 },
+      "claude-opus": { input: 15, output: 75 },
+      "claude-haiku": { input: 0.25, output: 1.25 },
+      "gpt-4o": { input: 2.5, output: 10 }
+    };
+    DEFAULT_ESTIMATED_OUTPUT_TOKENS = 1e3;
+    CHARS_PER_TOKEN = 4;
+  }
+});
+
+// src/utils/ring-buffer.ts
+var RingBuffer;
+var init_ring_buffer = __esm({
+  "src/utils/ring-buffer.ts"() {
+    "use strict";
+    RingBuffer = class {
+      chunks = [];
+      totalBytes = 0;
+      maxBytes;
+      constructor(maxBytes) {
+        this.maxBytes = maxBytes;
+      }
+      push(chunk) {
+        this.chunks.push(chunk);
+        this.totalBytes += chunk.length;
+        while (this.totalBytes > this.maxBytes && this.chunks.length > 1) {
+          const dropped = this.chunks.shift();
+          this.totalBytes -= dropped.length;
+        }
+      }
+      toString() {
+        return Buffer.concat(this.chunks).toString("utf-8");
+      }
+      get size() {
+        return this.totalBytes;
+      }
+    };
+  }
+});
+
+// src/core/runner.ts
+import { spawn } from "child_process";
+async function runCommand(argv, onChunk) {
+  if (argv.length === 0) {
+    return {
+      exitCode: 1,
+      signal: null,
+      stdout: "",
+      stderr: "No command provided",
+      durationMs: 0,
+      command: ""
+    };
+  }
+  const commandStr = argv.join(" ");
+  const startTime = performance.now();
+  const stdoutBuffer = new RingBuffer(DEFAULT_RING_BUFFER_SIZE);
+  const stderrBuffer = new RingBuffer(DEFAULT_RING_BUFFER_SIZE);
+  return new Promise((resolve) => {
+    const child = spawn(commandStr, [], {
+      stdio: ["inherit", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        FORCE_COLOR: "1"
+      },
+      shell: true
+    });
+    child.stdout?.on("data", (chunk) => {
+      process.stdout.write(chunk);
+      stdoutBuffer.push(chunk);
+      onChunk?.(chunk.toString("utf-8"));
+    });
+    child.stderr?.on("data", (chunk) => {
+      process.stderr.write(chunk);
+      stderrBuffer.push(chunk);
+      onChunk?.(chunk.toString("utf-8"));
+    });
+    const onSigInt = () => child.kill("SIGINT");
+    const onSigTerm = () => child.kill("SIGTERM");
+    process.on("SIGINT", onSigInt);
+    process.on("SIGTERM", onSigTerm);
+    child.on("close", (exitCode, signal) => {
+      process.removeListener("SIGINT", onSigInt);
+      process.removeListener("SIGTERM", onSigTerm);
+      const durationMs = Math.round(performance.now() - startTime);
+      resolve({
+        exitCode: exitCode ?? (signal ? 1 : 0),
+        signal: signal ?? null,
+        stdout: stdoutBuffer.toString(),
+        stderr: stderrBuffer.toString(),
+        durationMs,
+        command: commandStr
+      });
+    });
+    child.on("error", (err) => {
+      process.removeListener("SIGINT", onSigInt);
+      process.removeListener("SIGTERM", onSigTerm);
+      const durationMs = Math.round(performance.now() - startTime);
+      resolve({
+        exitCode: 1,
+        signal: null,
+        stdout: stdoutBuffer.toString(),
+        stderr: err.message,
+        durationMs,
+        command: commandStr
+      });
+    });
+  });
+}
+var init_runner = __esm({
+  "src/core/runner.ts"() {
+    "use strict";
+    init_ring_buffer();
+    init_constants();
+  }
+});
+
+// src/core/signature.ts
+import { createHash } from "crypto";
+function generateSignature(rawLog, command) {
+  const normalized = normalizeLog(rawLog);
+  const anchors = extractAnchors(normalized);
+  const input2 = anchors.length > 0 ? `${anchors.join("\n")}
+${command}` : `${normalized}
+${command}`;
+  return createHash("sha256").update(input2).digest("hex").slice(0, 16);
+}
+function extractAnchors(normalizedLog) {
+  const lines = normalizedLog.split("\n").map((l) => l.trim()).filter(Boolean);
+  const anchors = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (isErrorHeader(line)) {
+      anchors.push(line);
+      const frames = collectStackFrames(lines, i + 1, 5);
+      anchors.push(...frames);
+    }
+  }
+  return [...new Set(anchors)];
+}
+function isErrorHeader(line) {
+  return ERROR_HEADER_PATTERNS.some((re) => re.test(line));
+}
+function collectStackFrames(lines, startIdx, maxFrames) {
+  const frames = [];
+  let collected = 0;
+  for (let i = startIdx; i < lines.length && collected < maxFrames; i++) {
+    const line = lines[i];
+    if (!line || /^[-=_]{3,}$/.test(line) || /^$/.test(line)) break;
+    if (isErrorHeader(line)) break;
+    if (STACK_FRAME_PATTERNS.some((re) => re.test(line))) {
+      frames.push(line);
+      collected++;
+      continue;
+    }
+    if (/^\s+/.test(lines[startIdx - 1] ? line : "") || isDiagnosticLine(line)) {
+      frames.push(line);
+      collected++;
+      continue;
+    }
+  }
+  return frames;
+}
+function isDiagnosticLine(line) {
+  return DIAGNOSTIC_PATTERNS.some((re) => re.test(line));
+}
+function normalizeLog(raw) {
+  let s = raw;
+  s = s.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
+  s = s.replace(/\d{4}-\d{2}-\d{2}[T_]\d{2}[:\-_]\d{2}[:\-_]\d{2}[.\d_Z]*/g, "<TS>");
+  s = s.replace(/\d{1,2}:\d{2}:\d{2}\s*(AM|PM)?/gi, "<TS>");
+  s = s.replace(/0x[0-9a-fA-F]{6,}/g, "<HEX>");
+  s = s.replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, "<UUID>");
+  s = s.replace(/\b(dep|chunk|vendor|assets?)-[a-zA-Z0-9_-]{4,}\b/g, "$1-<HASH>");
+  s = s.replace(/(?:\/[\w.@-]+)+\/([\w.@-]+)/g, "$1");
+  s = s.replace(/([\w.-]+):\d+:\d+/g, "$1:<L>:<C>");
+  s = s.replace(/([\w.-]+):(\d+)\b(?!:)/g, "$1:<L>");
+  s = s.replace(/\b\d+\.\d+s\b/g, "<DUR>");
+  s = s.replace(/\b\d+ (items?|modules?|files?|tests?|errors?|warnings?|problems?)\b/gi, "<N> $1");
+  s = s.replace(/v?\d+\.\d+\.\d+/g, "<VER>");
+  s = s.replace(/\bplatform (linux|darwin|win32|windows)\b/gi, "platform <PLATFORM>");
+  s = s.replace(/[^\S\n]+/g, " ");
+  s = s.replace(/\n{3,}/g, "\n\n");
+  return s.trim();
+}
+var ERROR_HEADER_PATTERNS, STACK_FRAME_PATTERNS, DIAGNOSTIC_PATTERNS;
+var init_signature = __esm({
+  "src/core/signature.ts"() {
+    "use strict";
+    ERROR_HEADER_PATTERNS = [
+      // JS/TS errors
+      /^(Error|TypeError|ReferenceError|SyntaxError|RangeError|URIError|EvalError):/,
+      /^Uncaught\s/,
+      // TypeScript compiler
+      /error TS\d+:/,
+      // Rust compiler
+      /^error\[E\d+\]:/,
+      /^error: aborting due to/,
+      // Python
+      /^(ModuleNotFoundError|ImportError|ConnectionRefusedError|AssertionError|AttributeError|KeyError|ValueError|RuntimeError|FileNotFoundError|PermissionError|OSError):/,
+      /^Traceback \(most recent call last\)/,
+      // Go
+      /^panic:/,
+      // npm
+      /^npm ERR! code /,
+      // Build tools
+      /^Build failed/i,
+      /^Failed to compile/i,
+      /Module not found/,
+      /Cannot find module/,
+      // Vite/Rollup
+      /Rollup failed to resolve import/,
+      // ESLint
+      /ESLint couldn't find the config/,
+      // Generic
+      /^FATAL/i,
+      /^ERROR\s/,
+      /CompileError/,
+      /ELIFECYCLE/
+    ];
+    STACK_FRAME_PATTERNS = [
+      // JS: "at Function.name (file:line:col)"
+      /^\s*at\s/,
+      // Python: "File "path", line N"
+      /^\s*File\s+"/,
+      // Go: "file.go:42 +0x..."
+      /^\s+[\w./]+\.go:\d+/,
+      // Rust: "--> src/file.rs:line:col"
+      /^\s*-->/,
+      // Generic: "path:line:col"
+      /^\s*[\w./]+\.\w+:<L>:<C>/
+    ];
+    DIAGNOSTIC_PATTERNS = [
+      // TS: "Property 'X' is missing"
+      /Property '.+' is missing/,
+      // TS: "Type 'X' is not assignable to type 'Y'"
+      /Type '.+' is not assignable/,
+      // TS: "Cannot find name 'X'"
+      /Cannot find name/,
+      // TS: "Cannot find module 'X'"
+      /Cannot find module/,
+      // Rust: "expected `X`, found `Y`"
+      /expected `.+`, found/,
+      // Rust: "cannot borrow"
+      /cannot borrow/,
+      // Python: "E  ..."
+      /^E\s{2,}/,
+      // Go: "cannot use"
+      /cannot use/,
+      // npm: peer dependency info
+      /peer .+ from/,
+      // ESLint rule names
+      /@typescript-eslint\//,
+      // Vite/Rollup: resolve info
+      /explicitly add it to/
+    ];
+  }
+});
+
+// src/core/cost-estimator.ts
+function estimateCost(rawLogLength, model) {
+  const modelKey = model ?? DEFAULT_AI_MODEL;
+  const pricing = AI_PRICING[modelKey] ?? AI_PRICING[DEFAULT_AI_MODEL];
+  const inputTokens = Math.ceil(rawLogLength / CHARS_PER_TOKEN);
+  const outputTokens = DEFAULT_ESTIMATED_OUTPUT_TOKENS;
+  const cost = (inputTokens * pricing.input + outputTokens * pricing.output) / 1e6;
+  return { inputTokens, outputTokens, cost };
+}
+var init_cost_estimator = __esm({
+  "src/core/cost-estimator.ts"() {
+    "use strict";
+    init_constants();
+  }
+});
+
+// src/core/git-context.ts
+import { execSync } from "child_process";
+function getGitContext(cwd) {
+  try {
+    const opts = { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] };
+    const branch = execSync("git rev-parse --abbrev-ref HEAD", opts).trim();
+    const commit = execSync("git rev-parse --short HEAD", opts).trim();
+    const statusOutput = execSync("git status --porcelain", opts).trim();
+    const dirty = statusOutput.length > 0;
+    return { branch, commit, dirty };
+  } catch {
+    return { branch: null, commit: null, dirty: null };
+  }
+}
+function getGitDiff(cwd, fromCommit, toCommit, maxSize) {
+  try {
+    const diff = execSync(`git diff ${fromCommit}..${toCommit}`, {
+      cwd,
+      encoding: "utf-8",
+      maxBuffer: maxSize
+    });
+    return diff.length > 0 ? diff.slice(0, maxSize) : null;
+  } catch {
+    return null;
+  }
+}
+var init_git_context = __esm({
+  "src/core/git-context.ts"() {
+    "use strict";
+  }
+});
+
+// src/db/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  fixAttempts: () => fixAttempts,
+  issues: () => issues,
+  occurrences: () => occurrences,
+  projects: () => projects,
+  runLog: () => runLog
+});
+import { sqliteTable, text, integer, real, index, uniqueIndex } from "drizzle-orm/sqlite-core";
+var projects, issues, occurrences, fixAttempts, runLog;
+var init_schema = __esm({
+  "src/db/schema.ts"() {
+    "use strict";
+    projects = sqliteTable("projects", {
+      id: text("id").primaryKey(),
+      name: text("name").notNull(),
+      rootPath: text("root_path").notNull().unique(),
+      createdAt: text("created_at").notNull(),
+      updatedAt: text("updated_at").notNull()
+    });
+    issues = sqliteTable("issues", {
+      id: text("id").primaryKey(),
+      projectId: text("project_id").notNull().references(() => projects.id),
+      title: text("title").notNull(),
+      type: text("type", { enum: ["build", "runtime", "test", "lint", "unknown"] }).notNull().default("unknown"),
+      severity: text("severity", { enum: ["low", "medium", "high", "critical"] }).notNull().default("medium"),
+      status: text("status", { enum: ["open", "resolved", "ignored"] }).notNull().default("open"),
+      signature: text("signature").notNull(),
+      occurrenceCount: integer("occurrence_count").notNull().default(1),
+      estimatedTotalCost: real("estimated_total_cost").notNull().default(0),
+      firstSeenAt: text("first_seen_at").notNull(),
+      lastSeenAt: text("last_seen_at").notNull(),
+      resolvedAt: text("resolved_at"),
+      regressionFlag: integer("regression_flag", { mode: "boolean" }).notNull().default(false),
+      createdAt: text("created_at").notNull(),
+      updatedAt: text("updated_at").notNull()
+    }, (table) => [
+      uniqueIndex("idx_issues_project_signature").on(table.projectId, table.signature),
+      index("idx_issues_project_status").on(table.projectId, table.status)
+    ]);
+    occurrences = sqliteTable("occurrences", {
+      id: text("id").primaryKey(),
+      issueId: text("issue_id").notNull().references(() => issues.id),
+      rawLog: text("raw_log").notNull(),
+      command: text("command").notNull(),
+      exitCode: integer("exit_code"),
+      signal: text("signal"),
+      durationMs: integer("duration_ms"),
+      gitBranch: text("git_branch"),
+      gitCommit: text("git_commit"),
+      gitDirty: integer("git_dirty", { mode: "boolean" }),
+      appliedDiff: text("applied_diff"),
+      estimatedInputTokens: integer("estimated_input_tokens").notNull().default(0),
+      estimatedOutputTokens: integer("estimated_output_tokens").notNull().default(0),
+      estimatedCost: real("estimated_cost").notNull().default(0),
+      capturedFrom: text("captured_from", { enum: ["wrapper", "stream"] }).notNull().default("wrapper"),
+      createdAt: text("created_at").notNull()
+    }, (table) => [
+      index("idx_occurrences_issue_created").on(table.issueId, table.createdAt)
+    ]);
+    fixAttempts = sqliteTable("fix_attempts", {
+      id: text("id").primaryKey(),
+      issueId: text("issue_id").notNull().references(() => issues.id),
+      summary: text("summary"),
+      rootCause: text("root_cause"),
+      prevention: text("prevention"),
+      successful: integer("successful", { mode: "boolean" }),
+      source: text("source", { enum: ["agent", "manual", "api"] }).notNull().default("manual"),
+      createdAt: text("created_at").notNull()
+    }, (table) => [
+      index("idx_fix_attempts_issue").on(table.issueId)
+    ]);
+    runLog = sqliteTable("run_log", {
+      id: text("id").primaryKey(),
+      projectId: text("project_id").notNull().references(() => projects.id),
+      command: text("command").notNull(),
+      exitCode: integer("exit_code"),
+      durationMs: integer("duration_ms"),
+      createdAt: text("created_at").notNull()
+    }, (table) => [
+      index("idx_run_log_project_created").on(table.projectId, table.createdAt)
+    ]);
+  }
+});
+
+// src/utils/paths.ts
+import { join, parse } from "path";
+import { existsSync } from "fs";
+function findProjectRoot(startDir) {
+  let dir = startDir;
+  const { root } = parse(dir);
+  while (dir !== root) {
+    if (existsSync(join(dir, VIBEBUG_DIR))) {
+      return dir;
+    }
+    dir = join(dir, "..");
+  }
+  return null;
+}
+function getVibeBugDir(projectRoot) {
+  return join(projectRoot, VIBEBUG_DIR);
+}
+function getDbPath(projectRoot) {
+  return join(projectRoot, VIBEBUG_DIR, DB_FILENAME);
+}
+var init_paths = __esm({
+  "src/utils/paths.ts"() {
+    "use strict";
+    init_constants();
+  }
+});
+
+// src/db/connection.ts
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import { mkdirSync, existsSync as existsSync2 } from "fs";
+function getDatabase(projectRoot) {
+  if (cachedDb) return cachedDb;
+  const vibebugDir = getVibeBugDir(projectRoot);
+  if (!existsSync2(vibebugDir)) {
+    mkdirSync(vibebugDir, { recursive: true });
+  }
+  const dbPath = getDbPath(projectRoot);
+  const sqlite = new Database(dbPath);
+  sqlite.pragma("journal_mode = WAL");
+  sqlite.pragma("foreign_keys = ON");
+  cachedSqlite = sqlite;
+  cachedDb = drizzle(sqlite, { schema: schema_exports });
+  return cachedDb;
+}
+var cachedDb, cachedSqlite;
+var init_connection = __esm({
+  "src/db/connection.ts"() {
+    "use strict";
+    init_schema();
+    init_paths();
+    cachedDb = null;
+    cachedSqlite = null;
+  }
+});
+
+// src/db/migrate.ts
+import Database2 from "better-sqlite3";
+import { mkdirSync as mkdirSync2, existsSync as existsSync3 } from "fs";
+function runMigrations(projectRoot) {
+  const vibebugDir = getVibeBugDir(projectRoot);
+  if (!existsSync3(vibebugDir)) {
+    mkdirSync2(vibebugDir, { recursive: true });
+  }
+  const dbPath = getDbPath(projectRoot);
+  const db = new Database2(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  db.exec(SCHEMA_SQL);
+  try {
+    db.exec(`ALTER TABLE fix_attempts ADD COLUMN source TEXT NOT NULL DEFAULT 'manual'`);
+  } catch {
+  }
+  db.exec(`
+CREATE TABLE IF NOT EXISTS run_log (
+  id TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL REFERENCES projects(id),
+  command TEXT NOT NULL,
+  exit_code INTEGER,
+  duration_ms INTEGER,
+  created_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_run_log_project_created ON run_log(project_id, created_at);
+  `);
+  db.close();
+}
+var SCHEMA_SQL;
+var init_migrate = __esm({
+  "src/db/migrate.ts"() {
+    "use strict";
+    init_paths();
+    SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS projects (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  root_path TEXT NOT NULL UNIQUE,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS issues (
+  id TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL REFERENCES projects(id),
+  title TEXT NOT NULL,
+  type TEXT NOT NULL DEFAULT 'unknown',
+  severity TEXT NOT NULL DEFAULT 'medium',
+  status TEXT NOT NULL DEFAULT 'open',
+  signature TEXT NOT NULL,
+  occurrence_count INTEGER NOT NULL DEFAULT 1,
+  estimated_total_cost REAL NOT NULL DEFAULT 0,
+  first_seen_at TEXT NOT NULL,
+  last_seen_at TEXT NOT NULL,
+  resolved_at TEXT,
+  regression_flag INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_issues_project_signature ON issues(project_id, signature);
+CREATE INDEX IF NOT EXISTS idx_issues_project_status ON issues(project_id, status);
+
+CREATE TABLE IF NOT EXISTS occurrences (
+  id TEXT PRIMARY KEY,
+  issue_id TEXT NOT NULL REFERENCES issues(id),
+  raw_log TEXT NOT NULL,
+  command TEXT NOT NULL,
+  exit_code INTEGER,
+  signal TEXT,
+  duration_ms INTEGER,
+  git_branch TEXT,
+  git_commit TEXT,
+  git_dirty INTEGER,
+  applied_diff TEXT,
+  estimated_input_tokens INTEGER NOT NULL DEFAULT 0,
+  estimated_output_tokens INTEGER NOT NULL DEFAULT 0,
+  estimated_cost REAL NOT NULL DEFAULT 0,
+  captured_from TEXT NOT NULL DEFAULT 'wrapper',
+  created_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_occurrences_issue_created ON occurrences(issue_id, created_at);
+
+CREATE TABLE IF NOT EXISTS fix_attempts (
+  id TEXT PRIMARY KEY,
+  issue_id TEXT NOT NULL REFERENCES issues(id),
+  summary TEXT,
+  root_cause TEXT,
+  prevention TEXT,
+  successful INTEGER,
+  source TEXT NOT NULL DEFAULT 'manual',
+  created_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_fix_attempts_issue ON fix_attempts(issue_id);
+`;
+  }
+});
+
+// src/db/queries.ts
+import { basename } from "path";
+import { eq, and, desc, sql } from "drizzle-orm";
+import { nanoid } from "nanoid";
+function ensureProject(rootPath) {
+  runMigrations(rootPath);
+  const db = getDatabase(rootPath);
+  const existing = db.select().from(projects).where(eq(projects.rootPath, rootPath)).get();
+  if (existing) {
+    return existing;
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const project = {
+    id: nanoid(),
+    name: basename(rootPath),
+    rootPath,
+    createdAt: now,
+    updatedAt: now
+  };
+  db.insert(projects).values(project).run();
+  return project;
+}
+function findIssueBySignature(projectRoot, projectId, signature) {
+  const db = getDatabase(projectRoot);
+  return db.select().from(issues).where(and(eq(issues.projectId, projectId), eq(issues.signature, signature))).get();
+}
+function createIssue(projectRoot, data) {
+  const db = getDatabase(projectRoot);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const id = nanoid();
+  db.insert(issues).values({
+    id,
+    projectId: data.projectId,
+    title: data.title,
+    type: data.type,
+    severity: "medium",
+    status: "open",
+    signature: data.signature,
+    occurrenceCount: 1,
+    estimatedTotalCost: data.estimatedCost,
+    firstSeenAt: now,
+    lastSeenAt: now,
+    regressionFlag: false,
+    createdAt: now,
+    updatedAt: now
+  }).run();
+  return id;
+}
+function incrementIssue(projectRoot, issueId, additionalCost, wasResolved) {
+  const db = getDatabase(projectRoot);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const updateFields = {
+    occurrenceCount: sql`${issues.occurrenceCount} + 1`,
+    lastSeenAt: now,
+    estimatedTotalCost: sql`${issues.estimatedTotalCost} + ${additionalCost}`,
+    updatedAt: now
+  };
+  if (wasResolved) {
+    updateFields.status = "open";
+    updateFields.regressionFlag = true;
+    updateFields.resolvedAt = null;
+  }
+  db.update(issues).set(updateFields).where(eq(issues.id, issueId)).run();
+}
+function createOccurrence(projectRoot, data) {
+  const db = getDatabase(projectRoot);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.insert(occurrences).values({
+    id: nanoid(),
+    issueId: data.issueId,
+    rawLog: data.rawLog,
+    command: data.command,
+    exitCode: data.exitCode,
+    signal: data.signal,
+    durationMs: data.durationMs,
+    gitBranch: data.gitContext.branch,
+    gitCommit: data.gitContext.commit,
+    gitDirty: data.gitContext.dirty,
+    appliedDiff: data.appliedDiff,
+    estimatedInputTokens: data.costEstimate.inputTokens,
+    estimatedOutputTokens: data.costEstimate.outputTokens,
+    estimatedCost: data.costEstimate.cost,
+    capturedFrom: data.capturedFrom,
+    createdAt: now
+  }).run();
+}
+function getOpenIssues(projectRoot, projectId) {
+  const db = getDatabase(projectRoot);
+  return db.select().from(issues).where(and(eq(issues.projectId, projectId), eq(issues.status, "open"))).orderBy(desc(issues.lastSeenAt)).all();
+}
+function getAllIssues(projectRoot, projectId) {
+  const db = getDatabase(projectRoot);
+  return db.select().from(issues).where(eq(issues.projectId, projectId)).orderBy(desc(issues.lastSeenAt)).all();
+}
+function getLastOccurrenceCommit(projectRoot, issueId) {
+  const db = getDatabase(projectRoot);
+  const last = db.select({ gitCommit: occurrences.gitCommit }).from(occurrences).where(eq(occurrences.issueId, issueId)).orderBy(desc(occurrences.createdAt)).limit(1).get();
+  return last?.gitCommit ?? null;
+}
+function getMostRecentOpenIssue(projectRoot, projectId) {
+  const db = getDatabase(projectRoot);
+  return db.select().from(issues).where(and(eq(issues.projectId, projectId), eq(issues.status, "open"))).orderBy(desc(issues.lastSeenAt)).limit(1).get();
+}
+function resolveIssue(projectRoot, issueId) {
+  const db = getDatabase(projectRoot);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.update(issues).set({
+    status: "resolved",
+    resolvedAt: now,
+    updatedAt: now
+  }).where(eq(issues.id, issueId)).run();
+}
+function getIssueById(projectRoot, issueId) {
+  const db = getDatabase(projectRoot);
+  return db.select().from(issues).where(eq(issues.id, issueId)).get();
+}
+function createFixAttempt(projectRoot, data) {
+  const db = getDatabase(projectRoot);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const id = nanoid();
+  db.insert(fixAttempts).values({
+    id,
+    issueId: data.issueId,
+    summary: data.summary ?? null,
+    rootCause: data.rootCause ?? null,
+    prevention: data.prevention ?? null,
+    successful: null,
+    source: data.source ?? "manual",
+    createdAt: now
+  }).run();
+  return id;
+}
+function logRun(projectRoot, data) {
+  const db = getDatabase(projectRoot);
+  db.insert(runLog).values({
+    id: nanoid(),
+    projectId: data.projectId,
+    command: data.command,
+    exitCode: data.exitCode,
+    durationMs: data.durationMs,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  }).run();
+}
+var init_queries = __esm({
+  "src/db/queries.ts"() {
+    "use strict";
+    init_connection();
+    init_schema();
+    init_migrate();
+  }
+});
+
+// src/core/capture.ts
+import pc from "picocolors";
+async function captureFailure(input2) {
+  const { project, commandStr, result, gitContext, skipSignatures } = input2;
+  const fullLog = result.stderr || result.stdout;
+  if (!fullLog.trim()) return;
+  const rawLog = tailLines(fullLog, DEFAULT_TAIL_LINES);
+  const signature = generateSignature(rawLog, commandStr);
+  if (skipSignatures?.has(signature)) return;
+  const costEstimate = estimateCost(rawLog.length);
+  const issueType = inferType(commandStr);
+  const existing = findIssueBySignature(project.rootPath, project.id, signature);
+  let issueId;
+  let occurrenceCount;
+  let appliedDiff = null;
+  let isRegression = false;
+  if (existing) {
+    issueId = existing.id;
+    const wasResolved = existing.status === "resolved";
+    isRegression = wasResolved;
+    if (gitContext.commit) {
+      const prevCommit = getLastOccurrenceCommit(project.rootPath, issueId);
+      if (prevCommit && prevCommit !== gitContext.commit) {
+        appliedDiff = getGitDiff(project.rootPath, prevCommit, gitContext.commit, MAX_DIFF_SIZE);
+      }
+    }
+    incrementIssue(project.rootPath, issueId, costEstimate.cost, wasResolved);
+    occurrenceCount = existing.occurrenceCount + 1;
+  } else {
+    const title2 = extractTitle(rawLog);
+    issueId = createIssue(project.rootPath, {
+      projectId: project.id,
+      title: title2,
+      type: issueType,
+      signature,
+      estimatedCost: costEstimate.cost
+    });
+    occurrenceCount = 1;
+  }
+  createOccurrence(project.rootPath, {
+    issueId,
+    rawLog,
+    command: commandStr,
+    exitCode: result.exitCode,
+    signal: result.signal,
+    durationMs: result.durationMs,
+    gitContext,
+    appliedDiff,
+    costEstimate,
+    capturedFrom: "wrapper"
+  });
+  const title = existing?.title ?? extractTitle(rawLog);
+  const shortTitle = title.length > 60 ? title.slice(0, 57) + "..." : title;
+  const costStr = formatCost(costEstimate.cost * occurrenceCount);
+  const countStr = occurrenceCount > 1 ? ` (seen ${occurrenceCount} times, ~${costStr} in AI fixes)` : "";
+  const regressionStr = isRegression ? pc.red(" [REGRESSION]") : "";
+  console.error(
+    `
+${pc.cyan("[vibebug]")} ${pc.bold(shortTitle)}${countStr}${regressionStr}`
+  );
+}
+function inferType(command) {
+  const lower = command.toLowerCase();
+  if (/\b(build|compile|tsc)\b/.test(lower)) return "build";
+  if (/\b(test|jest|vitest|mocha|pytest|cargo test|go test)\b/.test(lower)) return "test";
+  if (/\b(lint|eslint|prettier|biome)\b/.test(lower)) return "lint";
+  if (/\b(dev|start|serve|run)\b/.test(lower)) return "runtime";
+  return "unknown";
+}
+function extractTitle(rawLog) {
+  const lines = rawLog.split("\n").filter((l) => l.trim());
+  for (const line of lines) {
+    const stripped = line.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").trim();
+    if (/^(Error|TypeError|ReferenceError|SyntaxError|RangeError):/.test(stripped)) {
+      return stripped.slice(0, 200);
+    }
+    if (/^error(\[|\s|:)/i.test(stripped)) {
+      return stripped.slice(0, 200);
+    }
+    if (/Module not found|Cannot find module/.test(stripped)) {
+      return stripped.slice(0, 200);
+    }
+    if (/FAIL|FATAL|panic:/.test(stripped)) {
+      return stripped.slice(0, 200);
+    }
+  }
+  const last = lines.at(-1)?.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").trim() ?? "Unknown error";
+  return last.slice(0, 200);
+}
+function captureStreamError(input2) {
+  const { project, commandStr, block, gitContext } = input2;
+  const rawLog = block.lines.join("\n");
+  if (!rawLog.trim()) return;
+  const costEstimate = estimateCost(rawLog.length);
+  const issueType = inferType(commandStr);
+  const existing = findIssueBySignature(project.rootPath, project.id, block.signature);
+  let issueId;
+  let occurrenceCount;
+  let appliedDiff = null;
+  let isRegression = false;
+  if (existing) {
+    issueId = existing.id;
+    const wasResolved = existing.status === "resolved";
+    isRegression = wasResolved;
+    if (gitContext.commit) {
+      const prevCommit = getLastOccurrenceCommit(project.rootPath, issueId);
+      if (prevCommit && prevCommit !== gitContext.commit) {
+        appliedDiff = getGitDiff(project.rootPath, prevCommit, gitContext.commit, MAX_DIFF_SIZE);
+      }
+    }
+    incrementIssue(project.rootPath, issueId, costEstimate.cost, wasResolved);
+    occurrenceCount = existing.occurrenceCount + 1;
+  } else {
+    const title2 = extractTitle(rawLog);
+    issueId = createIssue(project.rootPath, {
+      projectId: project.id,
+      title: title2,
+      type: issueType,
+      signature: block.signature,
+      estimatedCost: costEstimate.cost
+    });
+    occurrenceCount = 1;
+  }
+  createOccurrence(project.rootPath, {
+    issueId,
+    rawLog,
+    command: commandStr,
+    exitCode: null,
+    signal: null,
+    durationMs: 0,
+    gitContext,
+    appliedDiff,
+    costEstimate,
+    capturedFrom: "stream"
+  });
+  const title = existing?.title ?? extractTitle(rawLog);
+  const shortTitle = title.length > 60 ? title.slice(0, 57) + "..." : title;
+  const costStr = formatCost(costEstimate.cost * occurrenceCount);
+  const countStr = occurrenceCount > 1 ? ` (seen ${occurrenceCount} times, ~${costStr} in AI fixes)` : "";
+  const regressionStr = isRegression ? pc.red(" [REGRESSION]") : "";
+  console.error(
+    `
+${pc.cyan("[vibebug:stream]")} ${pc.bold(shortTitle)}${countStr}${regressionStr}`
+  );
+}
+function formatCost(cost) {
+  if (cost < 0.01) return `$${cost.toFixed(4)}`;
+  return `$${cost.toFixed(2)}`;
+}
+function tailLines(text2, maxLines) {
+  const lines = text2.split("\n");
+  if (lines.length <= maxLines) return text2;
+  return lines.slice(-maxLines).join("\n");
+}
+var init_capture = __esm({
+  "src/core/capture.ts"() {
+    "use strict";
+    init_signature();
+    init_cost_estimator();
+    init_git_context();
+    init_queries();
+    init_constants();
+  }
+});
+
+// src/core/stream-detector.ts
+var ERROR_MARKERS, StreamDetector;
+var init_stream_detector = __esm({
+  "src/core/stream-detector.ts"() {
+    "use strict";
+    init_signature();
+    init_constants();
+    ERROR_MARKERS = [
+      /^(Error|TypeError|ReferenceError|SyntaxError|RangeError|URIError|EvalError):/,
+      /^Uncaught /,
+      /^Traceback \(most recent call last\)/,
+      /^panic:/,
+      /^FATAL/i,
+      /^npm ERR!/,
+      /^ERR!/,
+      /ELIFECYCLE/,
+      /Module not found/,
+      /Cannot find module/,
+      /Segmentation fault/,
+      /error\[E\d+\]/,
+      /error TS\d+/,
+      /^ERROR\s/,
+      /CompileError/,
+      /Build failed/i,
+      /Failed to compile/i
+    ];
+    StreamDetector = class {
+      state = "idle";
+      blockLines = [];
+      quietTimer = null;
+      recentSignatures = /* @__PURE__ */ new Map();
+      // signature → timestamp
+      onCapture;
+      command;
+      quietTimeoutMs;
+      cooldownMs;
+      constructor(command, onCapture, options) {
+        this.command = command;
+        this.onCapture = onCapture;
+        this.quietTimeoutMs = options?.quietTimeoutMs ?? DEFAULT_STREAM_QUIET_TIMEOUT_MS;
+        this.cooldownMs = options?.cooldownMs ?? DEFAULT_STREAM_COOLDOWN_MS;
+      }
+      /**
+       * Feed a chunk of output to the detector. Call this for each data event
+       * from stdout/stderr.
+       */
+      feed(chunk) {
+        const lines = chunk.split("\n");
+        for (const line of lines) {
+          this.processLine(line);
+        }
+      }
+      /**
+       * Call when the process exits to flush any pending error block.
+       */
+      flush() {
+        if (this.state === "collecting" && this.blockLines.length > 0) {
+          this.finalizeBlock();
+        }
+        this.clearQuietTimer();
+      }
+      destroy() {
+        this.clearQuietTimer();
+      }
+      /**
+       * Returns all signatures that were captured by the stream detector.
+       */
+      getCapturedSignatures() {
+        return new Set(this.recentSignatures.keys());
+      }
+      processLine(line) {
+        const stripped = line.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").trim();
+        if (this.state === "idle") {
+          if (this.isErrorMarker(stripped)) {
+            this.state = "collecting";
+            this.blockLines = [line];
+            this.resetQuietTimer();
+          }
+        } else if (this.state === "collecting") {
+          this.blockLines.push(line);
+          this.resetQuietTimer();
+          if (this.blockLines.length >= MAX_ERROR_BLOCK_LINES) {
+            this.finalizeBlock();
+          }
+        }
+      }
+      isErrorMarker(line) {
+        return ERROR_MARKERS.some((re) => re.test(line));
+      }
+      resetQuietTimer() {
+        this.clearQuietTimer();
+        this.quietTimer = setTimeout(() => {
+          if (this.state === "collecting") {
+            this.finalizeBlock();
+          }
+        }, this.quietTimeoutMs);
+      }
+      clearQuietTimer() {
+        if (this.quietTimer) {
+          clearTimeout(this.quietTimer);
+          this.quietTimer = null;
+        }
+      }
+      finalizeBlock() {
+        this.clearQuietTimer();
+        this.state = "idle";
+        const rawBlock = this.blockLines.join("\n");
+        const signature = generateSignature(rawBlock, this.command);
+        const lastSeen = this.recentSignatures.get(signature);
+        const now = Date.now();
+        if (lastSeen && now - lastSeen < this.cooldownMs) {
+          this.blockLines = [];
+          return;
+        }
+        this.recentSignatures.set(signature, now);
+        for (const [sig, ts] of this.recentSignatures) {
+          if (now - ts > this.cooldownMs * 2) {
+            this.recentSignatures.delete(sig);
+          }
+        }
+        this.onCapture({ lines: this.blockLines, signature });
+        this.blockLines = [];
+      }
+    };
+  }
+});
+
+// src/commands/wrap.ts
+var wrap_exports = {};
+__export(wrap_exports, {
+  wrapCommand: () => wrapCommand
+});
+async function wrapCommand(args) {
+  const commandStr = args.join(" ");
+  const cwd = process.cwd();
+  const project = ensureProject(cwd);
+  const detector = new StreamDetector(commandStr, (block) => {
+    const gitContext = getGitContext(cwd);
+    captureStreamError({
+      project,
+      commandStr,
+      block,
+      gitContext
+    });
+  });
+  const result = await runCommand(args, (chunk) => {
+    detector.feed(chunk);
+  });
+  detector.flush();
+  detector.destroy();
+  logRun(cwd, {
+    projectId: project.id,
+    command: commandStr,
+    exitCode: result.exitCode,
+    durationMs: result.durationMs
+  });
+  if (result.exitCode !== 0) {
+    const gitContext = getGitContext(cwd);
+    await captureFailure({
+      project,
+      commandStr,
+      result,
+      gitContext,
+      skipSignatures: detector.getCapturedSignatures()
+    });
+  }
+  return result.exitCode ?? 1;
+}
+var init_wrap = __esm({
+  "src/commands/wrap.ts"() {
+    "use strict";
+    init_runner();
+    init_capture();
+    init_git_context();
+    init_queries();
+    init_stream_detector();
+  }
+});
+
+// src/commands/init.ts
+var init_exports = {};
+__export(init_exports, {
+  initCommand: () => initCommand
+});
+import pc2 from "picocolors";
+import { existsSync as existsSync4, appendFileSync, readFileSync } from "fs";
+import { join as join2 } from "path";
+async function initCommand() {
+  const cwd = process.cwd();
+  const vibebugDir = join2(cwd, VIBEBUG_DIR);
+  if (existsSync4(vibebugDir)) {
+    console.log(pc2.yellow("VibeBug is already initialized in this project."));
+    return;
+  }
+  const project = ensureProject(cwd);
+  const gitignorePath = join2(cwd, ".gitignore");
+  if (existsSync4(gitignorePath)) {
+    const content = readFileSync(gitignorePath, "utf-8");
+    if (!content.includes(VIBEBUG_DIR)) {
+      appendFileSync(gitignorePath, `
+# VibeBug local data
+${VIBEBUG_DIR}/
+`);
+      console.log(pc2.dim(`Added ${VIBEBUG_DIR}/ to .gitignore`));
+    }
+  }
+  console.log(pc2.green(`VibeBug initialized for "${project.name}".`));
+  console.log();
+  console.log("Quick start:");
+  console.log(`  ${pc2.cyan("vb")} npm run build    Run a command with failure capture`);
+  console.log(`  ${pc2.cyan("vb list")}              View captured issues`);
+  console.log(`  ${pc2.cyan("vb dash")}              Open the dashboard`);
+}
+var init_init = __esm({
+  "src/commands/init.ts"() {
+    "use strict";
+    init_queries();
+    init_constants();
+  }
+});
+
+// src/commands/list.ts
+var list_exports = {};
+__export(list_exports, {
+  listCommand: () => listCommand
+});
+import pc3 from "picocolors";
+async function listCommand() {
+  const cwd = process.cwd();
+  const project = ensureProject(cwd);
+  const issueList = getAllIssues(cwd, project.id);
+  console.log();
+  console.log(pc3.bold(project.name) + pc3.dim(` ${cwd}`));
+  if (issueList.length === 0) {
+    console.log(pc3.dim("No issues captured yet. Run commands with `vb` to start tracking."));
+    return;
+  }
+  console.log();
+  console.log(
+    pc3.dim(
+      pad("ID", 8) + pad("Title", 45) + pad("Type", 10) + pad("Status", 10) + pad("Seen", 6) + pad("Cost", 10) + "Last seen"
+    )
+  );
+  console.log(pc3.dim("\u2500".repeat(110)));
+  for (const issue of issueList) {
+    const title = issue.title.length > 42 ? issue.title.slice(0, 39) + "..." : issue.title;
+    const cost = formatCost2(issue.estimatedTotalCost);
+    const lastSeen = timeAgo(issue.lastSeenAt);
+    const statusColor = issue.status === "open" ? pc3.yellow : issue.status === "resolved" ? pc3.green : pc3.dim;
+    const severityColor = issue.severity === "critical" ? pc3.red : issue.severity === "high" ? pc3.yellow : issue.severity === "medium" ? pc3.white : pc3.dim;
+    const regression = issue.regressionFlag ? pc3.red(" !") : "";
+    console.log(
+      pad(issue.id.slice(0, 7), 8) + severityColor(pad(title, 45)) + pad(issue.type, 10) + statusColor(pad(issue.status, 10)) + pad(String(issue.occurrenceCount), 6) + pad(cost, 10) + lastSeen + regression
+    );
+  }
+  console.log();
+  console.log(pc3.dim(`${issueList.length} issue(s) total`));
+}
+function pad(str, width) {
+  return str.padEnd(width);
+}
+function formatCost2(cost) {
+  if (cost === 0) return "-";
+  if (cost < 0.01) return `$${cost.toFixed(4)}`;
+  return `$${cost.toFixed(2)}`;
+}
+function timeAgo(isoStr) {
+  const diff = Date.now() - new Date(isoStr).getTime();
+  const seconds = Math.floor(diff / 1e3);
+  if (seconds < 60) return "just now";
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+var init_list = __esm({
+  "src/commands/list.ts"() {
+    "use strict";
+    init_queries();
+  }
+});
+
+// src/server/routes/api.ts
+import { Hono } from "hono";
+import { eq as eq2, and as and2, desc as desc2, sql as sql2, like } from "drizzle-orm";
+import { nanoid as nanoid2 } from "nanoid";
+function createApiRoutes(projectRoot) {
+  const api = new Hono();
+  const db = getDatabase(projectRoot);
+  api.get("/project", (c) => {
+    const project = db.select().from(projects).where(eq2(projects.rootPath, projectRoot)).get();
+    if (!project) return c.json({ error: "Project not found" }, 404);
+    return c.json(project);
+  });
+  api.get("/stats", (c) => {
+    const project = db.select().from(projects).where(eq2(projects.rootPath, projectRoot)).get();
+    if (!project) return c.json({ error: "Project not found" }, 404);
+    const totalIssues = db.select({ count: sql2`count(*)` }).from(issues).where(eq2(issues.projectId, project.id)).get()?.count ?? 0;
+    const openIssues = db.select({ count: sql2`count(*)` }).from(issues).where(and2(eq2(issues.projectId, project.id), eq2(issues.status, "open"))).get()?.count ?? 0;
+    const resolvedIssues = db.select({ count: sql2`count(*)` }).from(issues).where(and2(eq2(issues.projectId, project.id), eq2(issues.status, "resolved"))).get()?.count ?? 0;
+    const totalOccurrences = db.select({ count: sql2`count(*)` }).from(occurrences).innerJoin(issues, eq2(occurrences.issueId, issues.id)).where(eq2(issues.projectId, project.id)).get()?.count ?? 0;
+    const totalEstimatedCost = db.select({ total: sql2`coalesce(sum(${issues.estimatedTotalCost}), 0)` }).from(issues).where(eq2(issues.projectId, project.id)).get()?.total ?? 0;
+    const regressions = db.select({ count: sql2`count(*)` }).from(issues).where(and2(eq2(issues.projectId, project.id), eq2(issues.regressionFlag, true))).get()?.count ?? 0;
+    const severityDist = db.select({
+      severity: issues.severity,
+      count: sql2`count(*)`
+    }).from(issues).where(eq2(issues.projectId, project.id)).groupBy(issues.severity).all();
+    const typeDist = db.select({
+      type: issues.type,
+      count: sql2`count(*)`
+    }).from(issues).where(eq2(issues.projectId, project.id)).groupBy(issues.type).all();
+    const occurrencesPerDay = db.select({
+      date: sql2`date(${occurrences.createdAt})`,
+      count: sql2`count(*)`
+    }).from(occurrences).innerJoin(issues, eq2(occurrences.issueId, issues.id)).where(and2(
+      eq2(issues.projectId, project.id),
+      sql2`${occurrences.createdAt} >= datetime('now', '-30 days')`
+    )).groupBy(sql2`date(${occurrences.createdAt})`).orderBy(sql2`date(${occurrences.createdAt})`).all();
+    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const runsToday = db.select({ count: sql2`count(*)` }).from(runLog).where(and2(
+      eq2(runLog.projectId, project.id),
+      sql2`${runLog.createdAt} >= ${today}`
+    )).get()?.count ?? 0;
+    const failuresToday = db.select({ count: sql2`count(*)` }).from(runLog).where(and2(
+      eq2(runLog.projectId, project.id),
+      sql2`${runLog.createdAt} >= ${today}`,
+      sql2`${runLog.exitCode} != 0`
+    )).get()?.count ?? 0;
+    const totalRuns = db.select({ count: sql2`count(*)` }).from(runLog).where(eq2(runLog.projectId, project.id)).get()?.count ?? 0;
+    return c.json({
+      totalIssues,
+      openIssues,
+      resolvedIssues,
+      totalOccurrences,
+      totalEstimatedCost,
+      regressions,
+      severityDistribution: severityDist,
+      typeDistribution: typeDist,
+      occurrencesPerDay,
+      runsToday,
+      failuresToday,
+      totalRuns
+    });
+  });
+  api.get("/issues", (c) => {
+    const project = db.select().from(projects).where(eq2(projects.rootPath, projectRoot)).get();
+    if (!project) return c.json({ error: "Project not found" }, 404);
+    const status = c.req.query("status");
+    const type = c.req.query("type");
+    const severity = c.req.query("severity");
+    const search = c.req.query("search");
+    const sortBy = c.req.query("sort") ?? "lastSeenAt";
+    let conditions = [eq2(issues.projectId, project.id)];
+    if (status) conditions.push(eq2(issues.status, status));
+    if (type) conditions.push(eq2(issues.type, type));
+    if (severity) conditions.push(eq2(issues.severity, severity));
+    if (search) conditions.push(like(issues.title, `%${search}%`));
+    const orderCol = sortBy === "occurrences" ? desc2(issues.occurrenceCount) : sortBy === "cost" ? desc2(issues.estimatedTotalCost) : sortBy === "severity" ? desc2(issues.severity) : desc2(issues.lastSeenAt);
+    const result = db.select().from(issues).where(and2(...conditions)).orderBy(orderCol).all();
+    return c.json(result);
+  });
+  api.get("/issues/:id", (c) => {
+    const issueId = c.req.param("id");
+    const issue = db.select().from(issues).where(eq2(issues.id, issueId)).get();
+    if (!issue) return c.json({ error: "Issue not found" }, 404);
+    const issueOccurrences = db.select().from(occurrences).where(eq2(occurrences.issueId, issueId)).orderBy(desc2(occurrences.createdAt)).all();
+    const fixes = db.select().from(fixAttempts).where(eq2(fixAttempts.issueId, issueId)).orderBy(desc2(fixAttempts.createdAt)).all();
+    return c.json({ ...issue, occurrences: issueOccurrences, fixAttempts: fixes });
+  });
+  api.patch("/issues/:id", async (c) => {
+    const issueId = c.req.param("id");
+    const body = await c.req.json();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const updateFields = { updatedAt: now };
+    if (body.status) {
+      updateFields.status = body.status;
+      if (body.status === "resolved") updateFields.resolvedAt = now;
+      if (body.status === "open") updateFields.resolvedAt = null;
+    }
+    if (body.severity) updateFields.severity = body.severity;
+    db.update(issues).set(updateFields).where(eq2(issues.id, issueId)).run();
+    const updated = db.select().from(issues).where(eq2(issues.id, issueId)).get();
+    return c.json(updated);
+  });
+  api.post("/issues/:id/fix", async (c) => {
+    const issueId = c.req.param("id");
+    const issue = db.select().from(issues).where(eq2(issues.id, issueId)).get();
+    if (!issue) return c.json({ error: "Issue not found" }, 404);
+    const body = await c.req.json();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const fixId = nanoid2();
+    const source = body.source ?? "api";
+    db.insert(fixAttempts).values({
+      id: fixId,
+      issueId,
+      summary: body.summary ?? null,
+      rootCause: body.rootCause ?? null,
+      prevention: body.prevention ?? null,
+      successful: null,
+      source,
+      createdAt: now
+    }).run();
+    db.update(issues).set({
+      status: "resolved",
+      resolvedAt: now,
+      updatedAt: now
+    }).where(eq2(issues.id, issueId)).run();
+    const updated = db.select().from(issues).where(eq2(issues.id, issueId)).get();
+    const fixes = db.select().from(fixAttempts).where(eq2(fixAttempts.issueId, issueId)).orderBy(desc2(fixAttempts.createdAt)).all();
+    return c.json({ ...updated, fixAttempts: fixes }, 201);
+  });
+  api.get("/insights", (c) => {
+    const project = db.select().from(projects).where(eq2(projects.rootPath, projectRoot)).get();
+    if (!project) return c.json({ error: "Project not found" }, 404);
+    const topRecurring = db.select().from(issues).where(eq2(issues.projectId, project.id)).orderBy(desc2(issues.occurrenceCount)).limit(10).all();
+    const mostExpensive = db.select().from(issues).where(eq2(issues.projectId, project.id)).orderBy(desc2(issues.estimatedTotalCost)).limit(10).all();
+    const regressionIssues = db.select().from(issues).where(and2(eq2(issues.projectId, project.id), eq2(issues.regressionFlag, true))).orderBy(desc2(issues.lastSeenAt)).all();
+    const failingCommands = db.select({
+      command: occurrences.command,
+      count: sql2`count(*)`
+    }).from(occurrences).innerJoin(issues, eq2(occurrences.issueId, issues.id)).where(eq2(issues.projectId, project.id)).groupBy(occurrences.command).orderBy(desc2(sql2`count(*)`)).limit(10).all();
+    return c.json({
+      topRecurring,
+      mostExpensive,
+      regressions: regressionIssues,
+      failingCommands
+    });
+  });
+  return api;
+}
+var init_api = __esm({
+  "src/server/routes/api.ts"() {
+    "use strict";
+    init_connection();
+    init_schema();
+  }
+});
+
+// src/server/index.ts
+import { Hono as Hono2 } from "hono";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { fileURLToPath } from "url";
+import { dirname, join as join3 } from "path";
+function createServer(projectRoot) {
+  const app = new Hono2();
+  const api = createApiRoutes(projectRoot);
+  app.route("/api", api);
+  const staticRoot = join3(__dirname, "..", "static");
+  app.use("/*", serveStatic({ root: staticRoot }));
+  app.get("*", serveStatic({ root: staticRoot, path: "index.html" }));
+  return app;
+}
+var __dirname;
+var init_server = __esm({
+  "src/server/index.ts"() {
+    "use strict";
+    init_api();
+    __dirname = dirname(fileURLToPath(import.meta.url));
+  }
+});
+
+// src/commands/dash.ts
+var dash_exports = {};
+__export(dash_exports, {
+  dashCommand: () => dashCommand
+});
+import pc4 from "picocolors";
+import { serve } from "@hono/node-server";
+async function dashCommand(options) {
+  const cwd = process.cwd();
+  const project = ensureProject(cwd);
+  const port = parseInt(options.port ?? String(DEFAULT_DASHBOARD_PORT), 10);
+  const app = createServer(cwd);
+  const server = serve({
+    fetch: app.fetch,
+    port
+  }, (info) => {
+    const url = `http://localhost:${info.port}`;
+    console.log(pc4.green(`VibeBug dashboard running at ${pc4.bold(url)}`));
+    console.log(pc4.dim(`Project: ${project.name} (${cwd})`));
+    console.log(pc4.dim("Press Ctrl+C to stop.\n"));
+    if (options.open !== false) {
+      import("open").then(({ default: open }) => open(url)).catch(() => {
+      });
+    }
+  });
+  await new Promise(() => {
+  });
+}
+var init_dash = __esm({
+  "src/commands/dash.ts"() {
+    "use strict";
+    init_server();
+    init_queries();
+    init_constants();
+  }
+});
+
+// src/commands/fix.ts
+var fix_exports = {};
+__export(fix_exports, {
+  fixCommand: () => fixCommand
+});
+import pc5 from "picocolors";
+import { input, select } from "@inquirer/prompts";
+async function fixCommand(issueId, options) {
+  const cwd = process.cwd();
+  const projectRoot = findProjectRoot(cwd);
+  if (!projectRoot) {
+    console.error(pc5.red("No VibeBug project found. Run `vb init` first."));
+    process.exit(1);
+  }
+  const project = ensureProject(projectRoot);
+  let targetIssue;
+  if (options.last) {
+    targetIssue = getMostRecentOpenIssue(projectRoot, project.id);
+    if (!targetIssue) {
+      console.log(pc5.yellow("No open issues found."));
+      return;
+    }
+  } else if (issueId) {
+    targetIssue = getIssueById(projectRoot, issueId);
+    if (!targetIssue) {
+      const allOpen = getOpenIssues(projectRoot, project.id);
+      targetIssue = allOpen.find((i) => i.id.startsWith(issueId));
+      if (!targetIssue) {
+        console.error(pc5.red(`Issue "${issueId}" not found.`));
+        return;
+      }
+    }
+  } else {
+    const openIssues = getOpenIssues(projectRoot, project.id);
+    if (openIssues.length === 0) {
+      console.log(pc5.yellow("No open issues found."));
+      return;
+    }
+    const answer = await select({
+      message: "Which issue did you fix?",
+      choices: openIssues.map((issue) => ({
+        name: `${issue.id.slice(0, 7)} ${issue.title.slice(0, 60)} (${issue.occurrenceCount}x)`,
+        value: issue.id
+      }))
+    });
+    targetIssue = openIssues.find((i) => i.id === answer);
+  }
+  const isNonInteractive = !!options.summary;
+  let summary = options.summary;
+  let rootCause = options.rootCause;
+  let prevention = options.prevention;
+  if (!isNonInteractive) {
+    summary = await input({
+      message: "Fix summary (what you changed):"
+    });
+    rootCause = await input({
+      message: "Root cause (optional):"
+    }) || void 0;
+    prevention = await input({
+      message: "Prevention (how to avoid in the future, optional):"
+    }) || void 0;
+  }
+  const source = isNonInteractive ? "agent" : "manual";
+  createFixAttempt(projectRoot, {
+    issueId: targetIssue.id,
+    summary,
+    rootCause,
+    prevention,
+    source
+  });
+  resolveIssue(projectRoot, targetIssue.id);
+  if (options.json) {
+    console.log(JSON.stringify({
+      status: "resolved",
+      issueId: targetIssue.id,
+      title: targetIssue.title,
+      fixSummary: summary
+    }));
+  } else {
+    const shortTitle = targetIssue.title.length > 50 ? targetIssue.title.slice(0, 47) + "..." : targetIssue.title;
+    console.log(pc5.green(`Resolved: ${pc5.bold(shortTitle)}`));
+    if (summary) {
+      console.log(pc5.dim(`  Fix: ${summary}`));
+    }
+  }
+}
+var init_fix = __esm({
+  "src/commands/fix.ts"() {
+    "use strict";
+    init_paths();
+    init_queries();
+  }
+});
+
+// src/commands/export.ts
+var export_exports = {};
+__export(export_exports, {
+  exportCommand: () => exportCommand
+});
+import pc6 from "picocolors";
+import { writeFileSync } from "fs";
+import { eq as eq3, desc as desc3 } from "drizzle-orm";
+async function exportCommand(options) {
+  const cwd = process.cwd();
+  const projectRoot = findProjectRoot(cwd);
+  if (!projectRoot) {
+    console.error(pc6.red("No VibeBug project found. Run `vb init` first."));
+    process.exit(1);
+  }
+  const project = ensureProject(projectRoot);
+  const allIssues = getAllIssues(projectRoot, project.id);
+  if (allIssues.length === 0) {
+    console.log(pc6.yellow("No issues to export."));
+    return;
+  }
+  const format = options.format ?? "json";
+  if (format === "json") {
+    const db = getDatabase(projectRoot);
+    const data = allIssues.map((issue) => {
+      const issueOccurrences = db.select().from(occurrences).where(eq3(occurrences.issueId, issue.id)).orderBy(desc3(occurrences.createdAt)).all();
+      const fixes = db.select().from(fixAttempts).where(eq3(fixAttempts.issueId, issue.id)).orderBy(desc3(fixAttempts.createdAt)).all();
+      return { ...issue, occurrences: issueOccurrences, fixAttempts: fixes };
+    });
+    const json = JSON.stringify({ project, issues: data }, null, 2);
+    if (options.output) {
+      writeFileSync(options.output, json, "utf-8");
+      console.log(pc6.green(`Exported ${allIssues.length} issues to ${options.output}`));
+    } else {
+      process.stdout.write(json + "\n");
+    }
+  } else if (format === "csv") {
+    const header = "id,title,type,severity,status,occurrences,estimated_cost,first_seen,last_seen,regression";
+    const rows = allIssues.map(
+      (issue) => [
+        issue.id,
+        `"${issue.title.replace(/"/g, '""')}"`,
+        issue.type,
+        issue.severity,
+        issue.status,
+        issue.occurrenceCount,
+        issue.estimatedTotalCost.toFixed(4),
+        issue.firstSeenAt,
+        issue.lastSeenAt,
+        issue.regressionFlag ? "true" : "false"
+      ].join(",")
+    );
+    const csv = [header, ...rows].join("\n");
+    if (options.output) {
+      writeFileSync(options.output, csv, "utf-8");
+      console.log(pc6.green(`Exported ${allIssues.length} issues to ${options.output}`));
+    } else {
+      process.stdout.write(csv + "\n");
+    }
+  } else {
+    console.error(pc6.red(`Unknown format: "${format}". Use "json" or "csv".`));
+  }
+}
+var init_export = __esm({
+  "src/commands/export.ts"() {
+    "use strict";
+    init_paths();
+    init_queries();
+    init_connection();
+    init_schema();
+  }
+});
+
+// src/commands/config.ts
+var config_exports = {};
+__export(config_exports, {
+  configCommand: () => configCommand
+});
+import pc7 from "picocolors";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync5 } from "fs";
+import { join as join4 } from "path";
+function getConfigPath(projectRoot) {
+  return join4(projectRoot, VIBEBUG_DIR, CONFIG_FILE);
+}
+function readConfig(projectRoot) {
+  const configPath = getConfigPath(projectRoot);
+  if (!existsSync5(configPath)) return {};
+  try {
+    return JSON.parse(readFileSync2(configPath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeConfig(projectRoot, config) {
+  const configPath = getConfigPath(projectRoot);
+  writeFileSync2(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+async function configCommand(action, key, value) {
+  const cwd = process.cwd();
+  const projectRoot = findProjectRoot(cwd);
+  if (!projectRoot) {
+    console.error(pc7.red("No VibeBug project found. Run `vb init` first."));
+    process.exit(1);
+  }
+  const config = readConfig(projectRoot);
+  switch (action) {
+    case "get": {
+      if (key) {
+        const val = config[key];
+        if (val !== void 0) {
+          console.log(`${key} = ${val}`);
+        } else {
+          console.log(pc7.dim(`${key} is not set`));
+        }
+      } else {
+        if (Object.keys(config).length === 0) {
+          console.log(pc7.dim("No configuration set. Using defaults."));
+        } else {
+          for (const [k, v] of Object.entries(config)) {
+            console.log(`${k} = ${v}`);
+          }
+        }
+      }
+      break;
+    }
+    case "set": {
+      if (!key || value === void 0) {
+        console.error(pc7.red("Usage: vb config set <key> <value>"));
+        return;
+      }
+      const spec = VALID_KEYS[key];
+      if (!spec) {
+        console.error(pc7.red(`Unknown config key: "${key}"`));
+        console.log(pc7.dim("Valid keys:"));
+        for (const [k, v] of Object.entries(VALID_KEYS)) {
+          console.log(pc7.dim(`  ${k} \u2014 ${v.description}`));
+        }
+        return;
+      }
+      let parsed = value;
+      if (spec.type === "number") {
+        parsed = Number(value);
+        if (Number.isNaN(parsed)) {
+          console.error(pc7.red(`"${value}" is not a valid number.`));
+          return;
+        }
+      }
+      config[key] = parsed;
+      writeConfig(projectRoot, config);
+      console.log(pc7.green(`Set ${key} = ${parsed}`));
+      break;
+    }
+    case "list": {
+      console.log(pc7.bold("Available configuration keys:\n"));
+      for (const [k, v] of Object.entries(VALID_KEYS)) {
+        const current = config[k];
+        const currentStr = current !== void 0 ? pc7.cyan(` (current: ${current})`) : "";
+        console.log(`  ${pc7.bold(k)}${currentStr}`);
+        console.log(`    ${pc7.dim(v.description)}`);
+      }
+      break;
+    }
+    default:
+      console.error(pc7.red(`Unknown action: "${action}". Use "get", "set", or "list".`));
+  }
+}
+var CONFIG_FILE, VALID_KEYS;
+var init_config = __esm({
+  "src/commands/config.ts"() {
+    "use strict";
+    init_paths();
+    init_constants();
+    CONFIG_FILE = "config.json";
+    VALID_KEYS = {
+      aiModel: { type: "string", description: "AI model for cost estimation (claude-sonnet, claude-opus, claude-haiku, gpt-4o)" },
+      aiInputPricePerMToken: { type: "number", description: "Custom input price per million tokens" },
+      aiOutputPricePerMToken: { type: "number", description: "Custom output price per million tokens" },
+      estimatedOutputTokens: { type: "number", description: "Heuristic for AI response size (default: 1000)" },
+      ringBufferSize: { type: "number", description: "Ring buffer size in bytes (default: 204800)" },
+      streamQuietTimeout: { type: "number", description: "Stream quiet timeout in ms (default: 2000)" },
+      streamCooldown: { type: "number", description: "Stream cooldown in ms (default: 60000)" },
+      dashboardPort: { type: "number", description: "Dashboard port (default: 7600)" },
+      autoOpen: { type: "string", description: "Auto-open dashboard in browser (true/false)" }
+    };
+  }
+});
+
+// src/index.ts
+init_constants();
+import { Command } from "commander";
+var KNOWN_COMMANDS = ["init", "list", "dash", "fix", "export", "config", "help"];
+var firstArg = process.argv[2];
+var isSubcommand = firstArg && (KNOWN_COMMANDS.includes(firstArg) || firstArg.startsWith("-"));
+if (!isSubcommand && firstArg) {
+  const args = process.argv.slice(2);
+  Promise.resolve().then(() => (init_wrap(), wrap_exports)).then(async ({ wrapCommand: wrapCommand2 }) => {
+    const exitCode = await wrapCommand2(args);
+    process.exitCode = exitCode;
+  });
+} else {
+  const program = new Command();
+  program.name(APP_NAME).description("Automatic issue capture for vibe coding failures \u2014 without interrupting flow.").version(VERSION);
+  program.command("init").description("Initialize VibeBug for the current project").action(async () => {
+    const { initCommand: initCommand2 } = await Promise.resolve().then(() => (init_init(), init_exports));
+    await initCommand2();
+  });
+  program.command("list").description("List open issues for the current project").action(async () => {
+    const { listCommand: listCommand2 } = await Promise.resolve().then(() => (init_list(), list_exports));
+    await listCommand2();
+  });
+  program.command("dash").description("Launch the local dashboard").option("--port <port>", "Dashboard port", String(7600)).option("--no-open", "Do not auto-open browser").action(async (options) => {
+    const { dashCommand: dashCommand2 } = await Promise.resolve().then(() => (init_dash(), dash_exports));
+    await dashCommand2(options);
+  });
+  program.command("fix [issueId]").description("Record what fixed an issue (retroactive annotation)").option("--last", "Target the most recent open issue").option("--summary <text>", "Fix summary (what was changed)").option("--root-cause <text>", "Root cause of the issue").option("--prevention <text>", "How to prevent in the future").option("--json", "Output result as JSON (for agent consumption)").action(async (issueId, options) => {
+    const { fixCommand: fixCommand2 } = await Promise.resolve().then(() => (init_fix(), fix_exports));
+    await fixCommand2(issueId, options);
+  });
+  program.command("export").description("Export issues to JSON or CSV").option("--format <format>", "Output format (json or csv)", "json").option("-o, --output <file>", "Write to file instead of stdout").action(async (options) => {
+    const { exportCommand: exportCommand2 } = await Promise.resolve().then(() => (init_export(), export_exports));
+    await exportCommand2(options);
+  });
+  program.command("config <action> [key] [value]").description("Manage VibeBug configuration").action(async (action, key, value) => {
+    const { configCommand: configCommand2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    await configCommand2(action, key, value);
+  });
+  program.parse();
+}
+//# sourceMappingURL=index.js.map