vibecop 0.4.1 → 0.4.3

package/README.md

@@ -66,11 +66,13 @@ Agent writes code → vibecop hook fires → Findings? Agent fixes → Clean? Co
 
 Four tools: `vibecop_scan`, `vibecop_check`, `vibecop_explain`, `vibecop_context_benchmark`.
 
-## Context Optimization
+## Context Optimization (Beta)
+
+> **Beta:** This feature is under active testing. Re-run `vibecop init --context` after upgrading vibecop or reinstalling dependencies.
 
 Reduce token consumption by ~35% on Read tool re-reads. When Claude Code reads a file it's already seen, vibecop intercepts the Read and serves a compact AST skeleton instead of the full file. Unchanged files get smart-limited to 30 lines + skeleton context.
 
-**Requires bun runtime** (uses `bun:sqlite` for zero-dependency caching).
+**Requires bun runtime** (uses `bun:sqlite` for zero-dependency caching). Claude Code only.
 
 ```bash
 vibecop context benchmark  # See projected savings for your project
@@ -133,7 +135,7 @@ Catches: god functions, N+1 queries, unsafe shell exec, SQL injection, hardcoded
 - [x] **Phase 2.5**: Agent integration (7 tools), 6 LLM/agent detectors, `vibecop init`
 - [x] **Phase 3**: Test quality detectors, custom YAML rules (28 → 35)
 - [x] **Phase 3.5**: MCP server with scan/check/explain tools
-- [x] **Phase 4**: Context optimization (Read tool interception, AST skeleton caching)
+- [x] **Phase 4**: Context optimization — Beta (Read tool interception, AST skeleton caching)
 - [ ] **Phase 5**: VS Code extension, cross-file analysis
 
 ## Links

package/dist/cli.js

@@ -22847,12 +22847,12 @@ import { execSync } from "node:child_process";
 import { existsSync as existsSync6, mkdirSync, readFileSync as readFileSync7, writeFileSync } from "node:fs";
 import { join as join7 } from "node:path";
 function resolveContextScript() {
-  const fromDist = new URL("../dist/context.js", import.meta.url);
-  try {
-    const { existsSync: existsSync7 } = __require("node:fs");
-    if (existsSync7(fromDist))
-      return fromDist.pathname;
-  } catch {}
+  const sibling = new URL("./context.js", import.meta.url);
+  if (existsSync6(sibling))
+    return sibling.pathname;
+  const fromSource = new URL("../dist/context.js", import.meta.url);
+  if (existsSync6(fromSource))
+    return fromSource.pathname;
   const { resolve: resolve4 } = __require("node:path");
   return resolve4("dist/context.js");
 }
@@ -23167,7 +23167,7 @@ async function runInit(cwd, options) {
       console.log("");
       return;
     }
-    console.log("  Setting up context optimization...");
+    console.log("  Setting up context optimization (beta)...");
     console.log("");
     const generated2 = generateContextHooks(root);
     if (generated2.length > 0) {
@@ -23178,7 +23178,8 @@ async function runInit(cwd, options) {
       }
       console.log("");
     }
-    console.log("  Context optimization configured.");
+    console.log("  Context optimization configured (beta).");
+    console.log("  Re-run this command after upgrading vibecop or reinstalling deps.");
     console.log("  Run 'vibecop context stats' to see token savings.");
     console.log("");
     return;

package/dist/context.js

@@ -0,0 +1,765 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/context.ts
+import { readFileSync as readFileSync3, readdirSync as readdirSync2 } from "fs";
+import { dirname as dirname2, extname as extname2, resolve as resolve2 } from "path";
+
+// src/context/cache.ts
+import { Database } from "bun:sqlite";
+import { existsSync, mkdirSync } from "fs";
+import { dirname, join } from "path";
+var DB_FILENAME = ".vibecop-context.db";
+function getDbPath(projectRoot) {
+  return join(projectRoot, ".vibecop", DB_FILENAME);
+}
+function openDb(projectRoot) {
+  const dbPath = getDbPath(projectRoot);
+  const dir = dirname(dbPath);
+  if (!existsSync(dir))
+    mkdirSync(dir, { recursive: true });
+  const db = new Database(dbPath);
+  db.run("PRAGMA journal_mode = WAL");
+  db.run("PRAGMA busy_timeout = 1000");
+  initSchema(db);
+  return db;
+}
+function initSchema(db) {
+  db.run(`
+    CREATE TABLE IF NOT EXISTS skeletons (
+      path TEXT PRIMARY KEY,
+      hash TEXT NOT NULL,
+      skeleton TEXT NOT NULL,
+      language TEXT NOT NULL,
+      full_tokens INTEGER NOT NULL DEFAULT 0,
+      skeleton_tokens INTEGER NOT NULL DEFAULT 0,
+      updated_at INTEGER NOT NULL DEFAULT (unixepoch())
+    )
+  `);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS session_reads (
+      session_id TEXT NOT NULL,
+      path TEXT NOT NULL,
+      hash TEXT NOT NULL,
+      read_at INTEGER NOT NULL DEFAULT (unixepoch()),
+      PRIMARY KEY (session_id, path)
+    )
+  `);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS stats (
+      session_id TEXT NOT NULL,
+      total_reads INTEGER NOT NULL DEFAULT 0,
+      cache_hits INTEGER NOT NULL DEFAULT 0,
+      tokens_saved INTEGER NOT NULL DEFAULT 0,
+      updated_at INTEGER NOT NULL DEFAULT (unixepoch()),
+      PRIMARY KEY (session_id)
+    )
+  `);
+}
+function getSkeleton(db, path, hash) {
+  const row = db.query("SELECT skeleton, full_tokens, skeleton_tokens FROM skeletons WHERE path = ? AND hash = ?").get(path, hash);
+  if (!row)
+    return null;
+  return { skeleton: row.skeleton, fullTokens: row.full_tokens, skeletonTokens: row.skeleton_tokens };
+}
+function upsertSkeleton(db, path, hash, skeleton, language, fullTokens, skeletonTokens) {
+  db.run(`INSERT INTO skeletons (path, hash, skeleton, language, full_tokens, skeleton_tokens, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, unixepoch())
+     ON CONFLICT(path) DO UPDATE SET hash=excluded.hash, skeleton=excluded.skeleton, language=excluded.language, full_tokens=excluded.full_tokens, skeleton_tokens=excluded.skeleton_tokens, updated_at=excluded.updated_at`, [path, hash, skeleton, language, fullTokens, skeletonTokens]);
+}
+function hasSessionRead(db, sessionId, path) {
+  const row = db.query("SELECT hash FROM session_reads WHERE session_id = ? AND path = ?").get(sessionId, path);
+  return row ?? null;
+}
+function recordSessionRead(db, sessionId, path, hash) {
+  db.run(`INSERT INTO session_reads (session_id, path, hash, read_at)
+     VALUES (?, ?, ?, unixepoch())
+     ON CONFLICT(session_id, path) DO UPDATE SET hash=excluded.hash, read_at=excluded.read_at`, [sessionId, path, hash]);
+}
+function incrementStats(db, sessionId, fields) {
+  db.run(`INSERT INTO stats (session_id, total_reads, cache_hits, tokens_saved, updated_at)
+     VALUES (?, ?, ?, ?, unixepoch())
+     ON CONFLICT(session_id) DO UPDATE SET
+       total_reads = stats.total_reads + excluded.total_reads,
+       cache_hits = stats.cache_hits + excluded.cache_hits,
+       tokens_saved = stats.tokens_saved + excluded.tokens_saved,
+       updated_at = excluded.updated_at`, [sessionId, fields.totalReads ?? 0, fields.cacheHits ?? 0, fields.tokensSaved ?? 0]);
+}
+function getSessionStats(db, sessionId) {
+  const row = db.query("SELECT * FROM stats WHERE session_id = ?").get(sessionId);
+  if (!row)
+    return null;
+  return {
+    sessionId: row.session_id,
+    totalReads: row.total_reads,
+    cacheHits: row.cache_hits,
+    tokensSaved: row.tokens_saved
+  };
+}
+function getAllStats(db) {
+  const rows = db.query("SELECT * FROM stats ORDER BY updated_at DESC").all();
+  return rows.map((r) => ({
+    sessionId: r.session_id,
+    totalReads: r.total_reads,
+    cacheHits: r.cache_hits,
+    tokensSaved: r.tokens_saved
+  }));
+}
+function pruneOldSessions(db, days = 7) {
+  const cutoff = Math.floor(Date.now() / 1000) - days * 86400;
+  const readsResult = db.run("DELETE FROM session_reads WHERE read_at < ?", [cutoff]);
+  const statsResult = db.run("DELETE FROM stats WHERE updated_at < ?", [cutoff]);
+  return (readsResult.changes ?? 0) + (statsResult.changes ?? 0);
+}
+
+// src/context/session.ts
+import { createHash } from "crypto";
+import { readFileSync, statSync } from "fs";
+function hashFile(filePath) {
+  try {
+    const content = readFileSync(filePath);
+    return createHash("sha256").update(content).digest("hex");
+  } catch {
+    return null;
+  }
+}
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+var SUPPORTED_EXTENSIONS = new Set([".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx", ".py"]);
+function isSupportedExtension(filePath) {
+  const lastDot = filePath.lastIndexOf(".");
+  if (lastDot === -1)
+    return false;
+  return SUPPORTED_EXTENSIONS.has(filePath.slice(lastDot));
+}
+var MAX_FILE_SIZE = 500000;
+function isFileEligible(filePath) {
+  try {
+    const stat = statSync(filePath);
+    return stat.isFile() && stat.size <= MAX_FILE_SIZE;
+  } catch {
+    return false;
+  }
+}
+
+// src/context/skeleton.ts
+import { parse, Lang as SgLang, registerDynamicLanguage } from "@ast-grep/napi";
+import { createRequire } from "module";
+
+// src/ast-utils.ts
+function findImports(root, language) {
+  if (language === "python")
+    return findPythonImports(root);
+  return findJsImports(root);
+}
+function findJsImports(root) {
+  const results = [];
+  const nodes = root.findAll({ rule: { kind: "import_statement" } });
+  for (const node of nodes) {
+    const sourceNode = node.children().find((ch) => ch.kind() === "string");
+    if (!sourceNode)
+      continue;
+    const source = sourceNode.text().slice(1, -1);
+    results.push({ node, source, text: node.text() });
+  }
+  return results;
+}
+function findPythonImports(root) {
+  const results = [];
+  for (const node of root.findAll({ rule: { kind: "import_statement" } })) {
+    const nameNode = node.children().find((ch) => ch.kind() === "dotted_name" || ch.kind() === "aliased_import");
+    if (!nameNode)
+      continue;
+    let source;
+    if (nameNode.kind() === "aliased_import") {
+      const dotted = nameNode.children().find((ch) => ch.kind() === "dotted_name");
+      source = dotted ? dotted.text() : nameNode.text();
+    } else {
+      source = nameNode.text();
+    }
+    results.push({ node, source, text: node.text() });
+  }
+  for (const node of root.findAll({ rule: { kind: "import_from_statement" } })) {
+    const nameNode = node.children().find((ch) => ch.kind() === "dotted_name");
+    if (!nameNode)
+      continue;
+    results.push({ node, source: nameNode.text(), text: node.text() });
+  }
+  return results;
+}
+function findFunctions(root, language) {
+  if (language === "python")
+    return findPythonFunctions(root);
+  return findJsFunctions(root);
+}
+function findJsFunctions(root) {
+  const results = [];
+  for (const kind of ["function_declaration", "method_definition", "arrow_function"]) {
+    for (const node of root.findAll({ rule: { kind } })) {
+      const name = getJsFunctionName(node);
+      const params = countJsParams(node);
+      const body = node.children().find((c) => c.kind() === "statement_block") ?? null;
+      results.push({ node, name, params, body, kind });
+    }
+  }
+  return results;
+}
+function getJsFunctionName(node) {
+  const kind = node.kind();
+  if (kind === "function_declaration") {
+    return node.children().find((ch) => ch.kind() === "identifier")?.text() ?? "<anonymous>";
+  }
+  if (kind === "method_definition") {
+    const nameNode = node.children().find((ch) => ch.kind() === "property_identifier" || ch.kind() === "identifier");
+    return nameNode?.text() ?? "<anonymous>";
+  }
+  if (kind === "arrow_function") {
+    const parent = node.parent();
+    if (parent?.kind() === "variable_declarator") {
+      return parent.children().find((ch) => ch.kind() === "identifier")?.text() ?? "<anonymous>";
+    }
+    if (parent?.kind() === "pair") {
+      const nameNode = parent.children().find((ch) => ch.kind() === "property_identifier" || ch.kind() === "string");
+      return nameNode?.text() ?? "<anonymous>";
+    }
+    return "<anonymous>";
+  }
+  return "<anonymous>";
+}
+function countJsParams(node) {
+  const params = node.children().find((ch) => ch.kind() === "formal_parameters");
+  if (!params)
+    return 0;
+  return params.children().filter((ch) => {
+    const k = ch.kind();
+    return k !== "(" && k !== ")" && k !== ",";
+  }).length;
+}
+function findPythonFunctions(root) {
+  const results = [];
+  for (const node of root.findAll({ rule: { kind: "function_definition" } })) {
+    const nameNode = node.children().find((ch) => ch.kind() === "identifier");
+    const name = nameNode?.text() ?? "<anonymous>";
+    const body = node.children().find((ch) => ch.kind() === "block") ?? null;
+    const params = countPyParams(node);
+    results.push({ node, name, params, body, kind: "function_definition" });
+  }
+  return results;
+}
+function countPyParams(node) {
+  const params = node.children().find((ch) => ch.kind() === "parameters");
+  if (!params)
+    return 0;
+  return params.children().filter((ch) => {
+    const k = ch.kind();
+    if (k === "(" || k === ")" || k === ",")
+      return false;
+    const text = ch.text().split(":")[0].split("=")[0].trim();
+    return text !== "self" && text !== "cls";
+  }).length;
+}
+function findClasses(root, language) {
+  if (language === "python")
+    return findPythonClasses(root);
+  return findJsClasses(root);
+}
+function findJsClasses(root) {
+  const results = [];
+  for (const node of root.findAll({ rule: { kind: "class_declaration" } })) {
+    const nameNode = node.children().find((ch) => ch.kind() === "type_identifier" || ch.kind() === "identifier");
+    const name = nameNode?.text() ?? "<anonymous>";
+    const methods = [];
+    const classBody = node.children().find((ch) => ch.kind() === "class_body");
+    if (classBody) {
+      for (const member of classBody.findAll({ rule: { kind: "method_definition" } })) {
+        const methodName = member.children().find((ch) => ch.kind() === "property_identifier" || ch.kind() === "identifier");
+        if (methodName)
+          methods.push(methodName.text());
+      }
+    }
+    results.push({ node, name, methods });
+  }
+  return results;
+}
+function findPythonClasses(root) {
+  const results = [];
+  for (const node of root.findAll({ rule: { kind: "class_definition" } })) {
+    const nameNode = node.children().find((ch) => ch.kind() === "identifier");
+    const name = nameNode?.text() ?? "<anonymous>";
+    const methods = [];
+    for (const method of node.findAll({ rule: { kind: "function_definition" } })) {
+      const methodName = method.children().find((ch) => ch.kind() === "identifier");
+      if (methodName)
+        methods.push(methodName.text());
+    }
+    results.push({ node, name, methods });
+  }
+  return results;
+}
+function findExports(root, language) {
+  if (language === "python")
+    return [];
+  const results = [];
+  for (const node of root.findAll({ rule: { kind: "export_statement" } })) {
+    const children = node.children();
+    const hasDefault = children.some((ch) => ch.kind() === "default");
+    if (hasDefault) {
+      results.push({ node, name: "default", kind: "default" });
+      continue;
+    }
+    const funcDecl = children.find((ch) => ch.kind() === "function_declaration");
+    if (funcDecl) {
+      const name = funcDecl.children().find((ch) => ch.kind() === "identifier")?.text() ?? "<unknown>";
+      results.push({ node, name, kind: "function" });
+      continue;
+    }
+    const classDecl = children.find((ch) => ch.kind() === "class_declaration");
+    if (classDecl) {
+      const nameNode = classDecl.children().find((ch) => ch.kind() === "type_identifier" || ch.kind() === "identifier");
+      results.push({ node, name: nameNode?.text() ?? "<unknown>", kind: "class" });
+      continue;
+    }
+    const typeDecl = children.find((ch) => ch.kind() === "type_alias_declaration" || ch.kind() === "interface_declaration");
+    if (typeDecl) {
+      const name = typeDecl.children().find((ch) => ch.kind() === "type_identifier")?.text() ?? "<unknown>";
+      results.push({ node, name, kind: "type" });
+      continue;
+    }
+    const lexDecl = children.find((ch) => ch.kind() === "lexical_declaration");
+    if (lexDecl) {
+      const declarator = lexDecl.children().find((ch) => ch.kind() === "variable_declarator");
+      const name = declarator?.children().find((ch) => ch.kind() === "identifier")?.text() ?? "<unknown>";
+      results.push({ node, name, kind: "variable" });
+      continue;
+    }
+    results.push({ node, name: "<unknown>", kind: "variable" });
+  }
+  return results;
+}
+
+// src/context/skeleton.ts
+var EXTENSION_TO_LANG = {
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".ts": "typescript",
+  ".tsx": "tsx",
+  ".py": "python"
+};
+var LANG_TO_SG = {
+  javascript: SgLang.JavaScript,
+  typescript: SgLang.TypeScript,
+  tsx: SgLang.Tsx,
+  python: "python"
+};
+var pythonRegistered = false;
+function ensurePython() {
+  if (pythonRegistered)
+    return;
+  try {
+    const req = createRequire(import.meta.url);
+    const pythonLang = req("@ast-grep/lang-python");
+    registerDynamicLanguage({ python: pythonLang });
+    pythonRegistered = true;
+  } catch {}
+}
+function languageForExtension(ext) {
+  return EXTENSION_TO_LANG[ext] ?? null;
+}
+function extractSkeleton(source, language) {
+  if (language === "python")
+    ensurePython();
+  const sgLang = LANG_TO_SG[language];
+  let root;
+  try {
+    root = parse(sgLang, source).root();
+  } catch {
+    return fallbackSkeleton(source);
+  }
+  const lines = [];
+  const imports = findImports(root, language);
+  if (imports.length > 0) {
+    for (const imp of imports) {
+      lines.push(imp.text);
+    }
+    lines.push("");
+  }
+  const classes = findClasses(root, language);
+  for (const cls of classes) {
+    if (language === "python") {
+      lines.push(`class ${cls.name}:`);
+    } else {
+      lines.push(`class ${cls.name} {`);
+    }
+    for (const method of cls.methods) {
+      lines.push(`  ${method}(...)`);
+    }
+    if (language !== "python")
+      lines.push("}");
+    lines.push("");
+  }
+  const functions = findFunctions(root, language);
+  const classMethodNodes = new Set(classes.flatMap((cls) => cls.node.findAll({ rule: { kind: language === "python" ? "function_definition" : "method_definition" } })).map((n) => n.range().start.line));
+  for (const fn of functions) {
+    if (classMethodNodes.has(fn.node.range().start.line))
+      continue;
+    const range = fn.node.range();
+    const sig = source.split(`
+`).slice(range.start.line, range.start.line + 1)[0]?.trim() ?? "";
+    if (sig)
+      lines.push(sig.replace(/\{[\s\S]*$/, "{ ... }"));
+  }
+  if (functions.length > 0 && classes.length === 0)
+    lines.push("");
+  const exports = findExports(root, language);
+  for (const exp of exports) {
+    if (exp.kind === "function" || exp.kind === "class")
+      continue;
+    lines.push(`export ${exp.kind === "default" ? "default" : ""} ${exp.name}`.trim());
+  }
+  const skeleton = lines.join(`
+`).trim();
+  return skeleton || fallbackSkeleton(source);
+}
+function fallbackSkeleton(source) {
+  const lines = source.split(`
+`);
+  const skeleton = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("import ") || trimmed.startsWith("from ") || trimmed.startsWith("export ") || trimmed.startsWith("class ") || /^(async\s+)?function\s/.test(trimmed) || /^(const|let|var)\s+\w+\s*=\s*(async\s+)?\(/.test(trimmed) || /^def\s/.test(trimmed)) {
+      skeleton.push(trimmed);
+    }
+  }
+  return skeleton.join(`
+`);
+}
+
+// src/context/benchmark.ts
+import { readdirSync, readFileSync as readFileSync2, statSync as statSync2 } from "fs";
+import { extname, join as join2, relative, resolve } from "path";
+function walkSupported(dir, root, results) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.name.startsWith("."))
+      continue;
+    if (entry.name === "node_modules" || entry.name === "dist" || entry.name === "build")
+      continue;
+    const fullPath = join2(dir, entry.name);
+    if (entry.isDirectory()) {
+      walkSupported(fullPath, root, results);
+    } else if (entry.isFile() && isSupportedExtension(fullPath)) {
+      try {
+        const stat = statSync2(fullPath);
+        if (stat.size > 500000 || stat.size === 0)
+          continue;
+        const source = readFileSync2(fullPath, "utf-8");
+        const lang = languageForExtension(extname(fullPath));
+        if (!lang)
+          continue;
+        const fullTokens = estimateTokens(source);
+        const skeleton = extractSkeleton(source, lang);
+        const skeletonTokens = estimateTokens(skeleton);
+        const reductionPercent = fullTokens > 0 ? Math.round((1 - (skeletonTokens + 128) / fullTokens) * 100) : 0;
+        results.push({
+          path: relative(root, fullPath),
+          fullTokens,
+          skeletonTokens,
+          reductionPercent: Math.max(0, reductionPercent)
+        });
+      } catch {}
+    }
+  }
+}
+function benchmark(projectRoot) {
+  const root = resolve(projectRoot);
+  const files = [];
+  walkSupported(root, root, files);
+  const totalTokens = files.reduce((sum, f) => sum + f.fullTokens, 0);
+  const sorted = [...files].sort((a, b) => b.fullTokens - a.fullTokens);
+  const projections = [20, 40, 60].map((rereadPercent) => {
+    const rereadCount = Math.round(files.length * rereadPercent / 100);
+    const rereadFiles = sorted.slice(0, rereadCount);
+    const tokensSaved = rereadFiles.reduce((sum, f) => {
+      const limited = 128 + f.skeletonTokens;
+      return sum + Math.max(0, f.fullTokens - limited);
+    }, 0);
+    return {
+      rereadPercent,
+      tokensSaved,
+      percentOfTotal: totalTokens > 0 ? Math.round(tokensSaved / totalTokens * 100) : 0
+    };
+  });
+  return { files: sorted, totalFiles: files.length, totalTokens, projections };
+}
+function formatBenchmark(result) {
+  if (result.totalFiles === 0) {
+    return "No supported files found (.js, .ts, .tsx, .py).";
+  }
+  const lines = [];
+  lines.push("vibecop context benchmark");
+  lines.push("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  lines.push("");
+  lines.push(`Files:        ${result.totalFiles} supported`);
+  lines.push(`Total tokens: ~${result.totalTokens.toLocaleString()}`);
+  lines.push("");
+  const top = result.files.slice(0, 10);
+  lines.push("Largest files (most savings potential):");
+  const maxPath = Math.max(...top.map((f) => f.path.length), 10);
+  for (const f of top) {
+    const pathPad = f.path.padEnd(maxPath);
+    lines.push(`  ${pathPad}  ${f.fullTokens.toLocaleString().padStart(6)} tokens \u2192 skeleton: ${f.skeletonTokens.toLocaleString().padStart(5)} (${f.reductionPercent}% reduction)`);
+  }
+  lines.push("");
+  lines.push("Projected savings per session:");
+  for (const p of result.projections) {
+    lines.push(`  ${p.rereadPercent}% re-read rate:  ~${p.tokensSaved.toLocaleString()} tokens saved (${p.percentOfTotal}% of total Read usage)`);
+  }
+  lines.push("");
+  lines.push("To enable: vibecop init --context");
+  return lines.join(`
+`);
+}
+
+// src/context/stats.ts
+function formatStats(stats) {
+  if (stats.length === 0)
+    return "No context optimization data recorded yet.\nRun `vibecop context benchmark` to see projected savings for this project.";
+  const lines = [];
+  let totalReads = 0;
+  let totalHits = 0;
+  let totalSaved = 0;
+  for (const s of stats) {
+    totalReads += s.totalReads;
+    totalHits += s.cacheHits;
+    totalSaved += s.tokensSaved;
+  }
+  const hitRate = totalReads > 0 ? (totalHits / totalReads * 100).toFixed(1) : "0.0";
+  lines.push("vibecop context optimization");
+  lines.push("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  lines.push("");
+  lines.push(`Sessions:     ${stats.length}`);
+  lines.push(`Total reads:  ${totalReads}`);
+  lines.push(`Cache hits:   ${totalHits} (${hitRate}% of reads)`);
+  lines.push(`Tokens saved: ~${totalSaved.toLocaleString()}`);
+  if (totalSaved > 0 && totalHits > 0) {
+    const avgSavedPerHit = Math.round(totalSaved / totalHits);
+    lines.push(`Avg savings:  ~${avgSavedPerHit.toLocaleString()} tokens per re-read`);
+  }
+  lines.push("");
+  if (stats.length <= 10 && stats.length > 0) {
+    lines.push("Per-session:");
+    for (const s of stats) {
+      const rate = s.totalReads > 0 ? (s.cacheHits / s.totalReads * 100).toFixed(0) : "0";
+      lines.push(`  ${s.sessionId.slice(0, 8)}\u2026  ${s.totalReads} reads, ${s.cacheHits} hits (${rate}%), ~${s.tokensSaved.toLocaleString()} saved`);
+    }
+  }
+  return lines.join(`
+`);
+}
+function printStats(db, sessionId) {
+  if (sessionId) {
+    const stats = getSessionStats(db, sessionId);
+    if (stats) {
+      console.log(formatStats([stats]));
+    } else {
+      console.log(`No stats found for session ${sessionId}`);
+    }
+  } else {
+    console.log(formatStats(getAllStats(db)));
+  }
+}
+
+// src/context.ts
+function findProjectRoot() {
+  let dir = process.cwd();
+  while (true) {
+    try {
+      const entries = new Set(readdirSync2(dir));
+      if (entries.has(".vibecop.yml") || entries.has(".git"))
+        return dir;
+    } catch {}
+    const parent = dirname2(dir);
+    if (parent === dir)
+      return process.cwd();
+    dir = parent;
+  }
+}
+function handlePre(input) {
+  const filePath = input.tool_input?.file_path;
+  if (!filePath) {
+    console.log("{}");
+    return;
+  }
+  if (!isSupportedExtension(filePath)) {
+    console.log("{}");
+    return;
+  }
+  if (input.tool_input.offset !== undefined && input.tool_input.offset > 0) {
+    console.log("{}");
+    return;
+  }
+  const sessionId = input.session_id;
+  if (!sessionId) {
+    console.log("{}");
+    return;
+  }
+  const projectRoot = findProjectRoot();
+  try {
+    const db = openDb(projectRoot);
+    try {
+      const resolvedPath = resolve2(filePath);
+      const currentHash = hashFile(resolvedPath);
+      if (!currentHash) {
+        console.log("{}");
+        return;
+      }
+      const previousRead = hasSessionRead(db, sessionId, resolvedPath);
+      if (!previousRead) {
+        const cached = getSkeleton(db, resolvedPath, currentHash);
+        if (cached) {
+          const response = {
+            additionalContext: `[vibecop] File structure:
+${cached.skeleton}`
+          };
+          console.log(JSON.stringify(response));
+        } else {
+          console.log("{}");
+        }
+        return;
+      }
+      if (previousRead.hash === currentHash) {
+        const cached = getSkeleton(db, resolvedPath, currentHash);
+        const response = {
+          updatedInput: {
+            file_path: filePath,
+            limit: 30
+          }
+        };
+        if (cached) {
+          response.additionalContext = `[vibecop] File unchanged since last read. Structure:
+${cached.skeleton}`;
+          const limitedTokens = 128 + cached.skeletonTokens;
+          const saved = Math.max(0, cached.fullTokens - limitedTokens);
+          incrementStats(db, sessionId, { cacheHits: 1, tokensSaved: saved });
+        } else {
+          incrementStats(db, sessionId, { cacheHits: 1 });
+        }
+        console.log(JSON.stringify(response));
+      } else {
+        const response = {
+          additionalContext: "[vibecop] File has changed since last read."
+        };
+        console.log(JSON.stringify(response));
+      }
+    } finally {
+      db.close();
+    }
+  } catch {
+    console.log("{}");
+  }
+}
+function handlePost(input) {
+  const filePath = input.tool_input?.file_path;
+  if (!filePath)
+    return;
+  if (!isSupportedExtension(filePath))
+    return;
+  const sessionId = input.session_id;
+  if (!sessionId)
+    return;
+  const projectRoot = findProjectRoot();
+  try {
+    const db = openDb(projectRoot);
+    try {
+      const resolvedPath = resolve2(filePath);
+      if (!isFileEligible(resolvedPath))
+        return;
+      const currentHash = hashFile(resolvedPath);
+      if (!currentHash)
+        return;
+      recordSessionRead(db, sessionId, resolvedPath, currentHash);
+      incrementStats(db, sessionId, { totalReads: 1 });
+      const existing = getSkeleton(db, resolvedPath, currentHash);
+      if (!existing) {
+        const ext = extname2(resolvedPath);
+        const lang = languageForExtension(ext);
+        if (!lang)
+          return;
+        const source = readFileSync3(resolvedPath, "utf-8");
+        const skeleton = extractSkeleton(source, lang);
+        if (skeleton) {
+          const fullTokens = estimateTokens(source);
+          const skeletonTokens = estimateTokens(skeleton);
+          upsertSkeleton(db, resolvedPath, currentHash, skeleton, lang, fullTokens, skeletonTokens);
+        }
+      }
+    } finally {
+      db.close();
+    }
+  } catch {}
+}
+function handleCompact(input) {
+  const sessionId = input.session_id;
+  if (!sessionId)
+    return;
+  const projectRoot = findProjectRoot();
+  try {
+    const db = openDb(projectRoot);
+    try {
+      pruneOldSessions(db, 7);
+    } finally {
+      db.close();
+    }
+  } catch {}
+}
+function handleStats(sessionId) {
+  const projectRoot = findProjectRoot();
+  try {
+    const db = openDb(projectRoot);
+    try {
+      printStats(db, sessionId);
+    } finally {
+      db.close();
+    }
+  } catch (err) {
+    console.error(`Failed to read stats: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}
+var args = process.argv.slice(2);
+var command = args[0];
+if (command === "stats") {
+  handleStats(args[1]);
+} else if (command === "benchmark") {
+  console.log(formatBenchmark(benchmark(findProjectRoot())));
+} else if (command === "--pre" || command === "--post" || command === "--compact") {
+  try {
+    const stdin = readFileSync3("/dev/stdin", "utf-8");
+    const input = JSON.parse(stdin);
+    switch (command) {
+      case "--pre":
+        handlePre(input);
+        break;
+      case "--post":
+        handlePost(input);
+        break;
+      case "--compact":
+        handleCompact(input);
+        break;
+    }
+  } catch {
+    if (command === "--pre")
+      console.log("{}");
+  }
+} else {
+  console.error("Usage: vibecop context [--pre|--post|--compact|stats]");
+  process.exit(1);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibecop",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "AI code quality toolkit — deterministic linter for the AI coding era",
   "type": "module",
   "bin": {
@@ -14,7 +14,7 @@
     "lint": "bunx biome check",
     "typecheck": "bunx tsc --noEmit",
     "test:install": "bash scripts/test-install.sh",
-    "prepublishOnly": "bun run lint && bun run typecheck && bun test && bun run build && bun run test:install"
+    "prepublishOnly": "bun run lint && bun run typecheck && bun test && bun run build && bun run build:context && bun run test:install"
   },
   "files": [
     "dist/cli.js",