composto-ai 0.1.0 → 0.1.2

package/dist/index.js

@@ -170,12 +170,24 @@ function extractStructure(code) {
 
 // src/ir/fingerprint.ts
 var PATTERNS = [
+  // import type { x, y } from "module"
+  {
+    match: /^import\s+type\s+\{([^}]+)\}\s+from\s+["']([^"']+)["'];?\s*$/,
+    transform: (m) => `USE:${m[2]}{${m[1].replace(/\s/g, "")}}`,
+    confidence: 0.95
+  },
   // import { x, y } from "module"
   {
     match: /^import\s+\{([^}]+)\}\s+from\s+["']([^"']+)["'];?\s*$/,
     transform: (m) => `USE:${m[2]}{${m[1].replace(/\s/g, "")}}`,
     confidence: 0.95
   },
+  // import type x from "module"
+  {
+    match: /^import\s+type\s+(\w+)\s+from\s+["']([^"']+)["'];?\s*$/,
+    transform: (m) => `USE:${m[2]}{${m[1]}}`,
+    confidence: 0.95
+  },
   // import x from "module"
   {
     match: /^import\s+(\w+)\s+from\s+["']([^"']+)["'];?\s*$/,
@@ -254,11 +266,110 @@ var PATTERNS = [
     transform: (m) => `CATCH:${m[1]}`,
     confidence: 0.9
   },
+  // switch (expr) {
+  {
+    match: /^switch\s*\(([^)]+)\)\s*\{?\s*$/,
+    transform: (m) => `SWITCH:${m[1].trim()}`,
+    confidence: 0.9
+  },
+  // case "value":  /  case value:
+  {
+    match: /^case\s+(.+)\s*:\s*$/,
+    transform: (m) => `CASE:${m[1].trim()}`,
+    confidence: 0.9
+  },
+  // default:
+  {
+    match: /^default\s*:\s*$/,
+    transform: () => "DEFAULT:",
+    confidence: 0.9
+  },
+  // export type Name = ...
+  {
+    match: /^export\s+type\s+(\w+)(?:<[^>]+>)?\s*=\s*(.+);?\s*$/,
+    transform: (m) => `OUT TYPE:${m[1]}`,
+    confidence: 0.9
+  },
+  // if (cond) expr;  (inline if with method call)
+  {
+    match: /^if\s*\(([^)]+)\)\s+(\w+.+);?\s*$/,
+    transform: (m) => `IF:${m[1].trim()} -> ${m[2].replace(/;$/, "").trim().slice(0, 50)}`,
+    confidence: 0.9
+  },
+  // export async function name(  (multiline signature)
+  {
+    match: /^export\s+(?:default\s+)?(?:async\s+)?function\s+(\w+)\s*\(\s*$/,
+    transform: (m) => `OUT FN:${m[1]}(`,
+    confidence: 0.95
+  },
+  // interface/type property — name: type;
+  {
+    match: /^\s*(\w+)\??\s*:\s*(.+);?\s*$/,
+    transform: (m) => `PROP:${m[1]}: ${m[2].replace(/;$/, "").trim()}`,
+    confidence: 0.75
+  },
+  // const x = await expr;
+  {
+    match: /^(?:export\s+)?(?:const|let|var)\s+(\w+)(?:\s*:\s*[^=]+)?\s*=\s*await\s+(.+);?\s*$/,
+    transform: (m) => {
+      const prefix = m[0].startsWith("export") ? "OUT " : "";
+      return `${prefix}AWAIT:VAR:${m[1]} = ${m[2].replace(/;$/, "").trim()}`;
+    },
+    confidence: 0.85
+  },
+  // export const name = async (params) => {  OR  export const name = (params) => expr;
+  {
+    match: /^export\s+(?:const|let|var)\s+(\w+)\s*=\s*(async\s+)?\(([^)]*)\)\s*=>\s*(.*)$/,
+    transform: (m) => {
+      const asyncPrefix = m[2] ? "ASYNC " : "";
+      const body = m[4].replace(/[{;]\s*$/, "").trim();
+      return `OUT ${asyncPrefix}FN:${m[1]} = (${m[3].trim()}) => ${body || "{"}`;
+    },
+    confidence: 0.9
+  },
+  // const name = async (params) => {  OR  const name = (params) => expr;
+  {
+    match: /^(?:const|let|var)\s+(\w+)\s*=\s*(async\s+)?\(([^)]*)\)\s*=>\s*(.*)$/,
+    transform: (m) => {
+      const asyncPrefix = m[2] ? "ASYNC " : "";
+      const body = m[4].replace(/[{;]\s*$/, "").trim();
+      return `${asyncPrefix}FN:${m[1]} = (${m[3].trim()}) => ${body || "{"}`;
+    },
+    confidence: 0.9
+  },
+  // get name() {
+  {
+    match: /^\s*get\s+(\w+)\s*\(\)\s*(?::\s*\S+\s*)?\{?\s*$/,
+    transform: (m) => `GET:${m[1]}()`,
+    confidence: 0.9
+  },
+  // set name(value) {
+  {
+    match: /^\s*set\s+(\w+)\s*\(([^)]*)\)\s*\{?\s*$/,
+    transform: (m) => `SET:${m[1]}(${m[2].replace(/\s/g, "")})`,
+    confidence: 0.9
+  },
+  // methodName(params) {  (inside class body, indented)
+  {
+    match: /^\s*(?:async\s+)?(\w+)\s*\(([^)]*)\)\s*(?::\s*\S+\s*)?\{\s*$/,
+    transform: (m) => {
+      const name = m[1];
+      if (["if", "for", "while", "switch", "catch", "function"].includes(name)) return `${name}`;
+      return `METHOD:${name}(${m[2].replace(/\s/g, "")})`;
+    },
+    confidence: 0.9
+  },
+  // const { a, b } = expr (object destructuring — before regular assignment)
+  {
+    match: /^(?:const|let|var)\s+\{([^}]+)\}\s*=\s*(.+);?\s*$/,
+    transform: (m) => `VAR:{${m[1].replace(/\s/g, "")}} = ${m[2].replace(/;$/, "").trim()}`,
+    confidence: 0.9
+  },
   // const [a, b] = expr (destructuring — before regular assignment)
   {
     match: /^(?:const|let|var)\s+\[([^\]]+)\]\s*=\s*(.+);?\s*$/,
     transform: (m) => `VAR:[${m[1].replace(/\s/g, "")}] = ${m[2].replace(/;$/, "").trim()}`,
-    confidence: 0.65
+    confidence: 0.9
   },
   // const name = value;
   {
@@ -267,7 +378,7 @@ var PATTERNS = [
       const prefix = m[0].startsWith("export") ? "OUT " : "";
       return `${prefix}VAR:${m[1]} = ${m[2].replace(/;$/, "").trim()}`;
     },
-    confidence: 0.7
+    confidence: 0.85
   }
 ];
 function fingerprintLine(line) {
@@ -293,7 +404,7 @@ function fingerprintLine(line) {
       };
     }
   }
-  return { type: "raw", ir: trimmed, confidence: 0.3 };
+  return { type: "raw", ir: trimmed, confidence: 0.1 };
 }
 function fingerprintFile(code, confidenceThreshold = 0.6) {
   const lines = code.split("\n");
@@ -305,8 +416,6 @@ function fingerprintFile(code, confidenceThreshold = 0.6) {
     if (result.ir === "") continue;
     if (result.confidence >= confidenceThreshold) {
       irLines.push(`${indentStr}${result.ir}`);
-    } else {
-      irLines.push(`${indentStr}${result.ir}`);
     }
   }
   return irLines.join("\n");
@@ -344,6 +453,419 @@ function computeHealthFromTrends(file, trends) {
   };
 }
 
+// src/parser/init.ts
+import { Parser, Language } from "web-tree-sitter";
+import { resolve, dirname } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { fileURLToPath } from "url";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var initialized = false;
+var cache = /* @__PURE__ */ new Map();
+function grammarPath(lang) {
+  const distPath = resolve(__dirname, "grammars", `tree-sitter-${lang}.wasm`);
+  if (existsSync2(distPath)) return distPath;
+  const devPath = resolve(__dirname, "../../grammars", `tree-sitter-${lang}.wasm`);
+  if (existsSync2(devPath)) return devPath;
+  throw new Error(`Grammar not found for ${lang}`);
+}
+async function getParser(lang) {
+  if (!initialized) {
+    await Parser.init();
+    initialized = true;
+  }
+  const cached = cache.get(lang);
+  if (cached) return cached;
+  const parser = new Parser();
+  const language = await Language.load(grammarPath(lang));
+  parser.setLanguage(language);
+  const result = { parser, language };
+  cache.set(lang, result);
+  return result;
+}
+
+// src/parser/languages.ts
+import { extname } from "path";
+var EXT_MAP = {
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".mjs": "javascript",
+  ".py": "python",
+  ".go": "go",
+  ".rs": "rust"
+};
+var SUPPORTED_EXTENSIONS = Object.keys(EXT_MAP);
+function detectLanguage(filePath) {
+  const ext = extname(filePath);
+  return EXT_MAP[ext] ?? null;
+}
+
+// src/ir/ast-walker.ts
+var TIER_MAP = {
+  // Tier 1 — structural declarations
+  import_statement: "T1_KEEP",
+  function_declaration: "T1_KEEP",
+  class_declaration: "T1_KEEP",
+  interface_declaration: "T1_KEEP",
+  type_alias_declaration: "T1_KEEP",
+  enum_declaration: "T1_KEEP",
+  // Tier 2 — control flow
+  if_statement: "T2_CONTROL",
+  else_clause: "WALK_ONLY",
+  for_statement: "T2_CONTROL",
+  for_in_statement: "T2_CONTROL",
+  while_statement: "T2_CONTROL",
+  do_statement: "T2_CONTROL",
+  switch_statement: "T2_CONTROL",
+  switch_case: "T2_CONTROL",
+  switch_default: "T2_CONTROL",
+  return_statement: "T2_CONTROL",
+  throw_statement: "T2_CONTROL",
+  try_statement: "T2_CONTROL",
+  catch_clause: "T2_CONTROL",
+  // Tier 3 — compressible expressions
+  lexical_declaration: "T3_COMPRESS",
+  expression_statement: "T3_COMPRESS",
+  // Walk-only — containers that need traversal but no emission
+  program: "WALK_ONLY",
+  statement_block: "WALK_ONLY",
+  class_body: "WALK_ONLY",
+  switch_body: "WALK_ONLY",
+  export_statement: "WALK_ONLY"
+};
+function tierOf(nodeType) {
+  return TIER_MAP[nodeType] ?? "T4_DROP";
+}
+function collapseText(text, maxLen) {
+  const collapsed = text.replace(/\s*\n\s*/g, " ").replace(/\s{2,}/g, " ").trim();
+  if (collapsed.length <= maxLen) return collapsed;
+  return collapsed.slice(0, maxLen - 3) + "...";
+}
+function getTypeParams(node) {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child.type === "type_parameters") {
+      return child.text;
+    }
+  }
+  return "";
+}
+function isExported(node) {
+  return node.parent?.type === "export_statement";
+}
+function isAsync(node) {
+  return node.text.trimStart().startsWith("async");
+}
+function extractCondition(node) {
+  const condNode = node.childForFieldName("condition") ?? (() => {
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (c.type === "parenthesized_expression") return c;
+    }
+    return null;
+  })();
+  if (!condNode) return "...";
+  const text = condNode.text.replace(/^\(/, "").replace(/\)$/, "").trim();
+  return text.length > 60 ? text.slice(0, 57) + "..." : text;
+}
+function emitTier2(node) {
+  switch (node.type) {
+    case "if_statement": {
+      const cond = extractCondition(node);
+      return `IF:${cond}`;
+    }
+    case "else_clause":
+      return "ELSE:";
+    case "for_statement":
+    case "for_in_statement":
+      return "LOOP";
+    case "while_statement": {
+      const cond = extractCondition(node);
+      return `WHILE:${cond}`;
+    }
+    case "do_statement": {
+      const cond = extractCondition(node);
+      return `WHILE:${cond}`;
+    }
+    case "switch_statement": {
+      const expr = node.childForFieldName("value") ?? node.childForFieldName("condition") ?? (() => {
+        for (let i = 0; i < node.childCount; i++) {
+          const c = node.child(i);
+          if (c.type === "parenthesized_expression") return c;
+        }
+        return null;
+      })();
+      const text = expr ? expr.text.replace(/^\(/, "").replace(/\)$/, "").trim() : "...";
+      return `SWITCH:${text.length > 60 ? text.slice(0, 57) + "..." : text}`;
+    }
+    case "switch_case": {
+      let value = null;
+      const valNode = node.childForFieldName("value");
+      if (valNode) {
+        value = valNode.text;
+      } else {
+        for (let i = 0; i < node.childCount; i++) {
+          const c = node.child(i);
+          if (c.type !== "case" && c.type !== ":" && c.childCount === 0 && c.text === "case") continue;
+          if (c.type !== "case" && c.text !== "case" && c.text !== ":") {
+            value = c.text;
+            break;
+          }
+        }
+      }
+      return `CASE:${value ?? "..."}`;
+    }
+    case "switch_default":
+      return "DEFAULT:";
+    case "return_statement": {
+      let retText = "";
+      for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (c.text !== "return" && c.text !== ";") {
+          retText += (retText ? " " : "") + c.text;
+        }
+      }
+      retText = retText.replace(/\s*\n\s*/g, " ").replace(/\s{2,}/g, " ").trim();
+      if (!retText) return "RET";
+      return `RET ${retText.length > 60 ? retText.slice(0, 57) + "..." : retText}`;
+    }
+    case "throw_statement": {
+      let throwText = "";
+      for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (c.text !== "throw" && c.text !== ";") {
+          throwText += (throwText ? " " : "") + c.text;
+        }
+      }
+      throwText = throwText.trim();
+      return `THROW:${throwText.length > 60 ? throwText.slice(0, 57) + "..." : throwText}`;
+    }
+    case "try_statement":
+      return "TRY";
+    case "catch_clause": {
+      const param = node.childForFieldName("parameter");
+      const paramText = param ? param.text : "...";
+      return `CATCH:${paramText}`;
+    }
+    default:
+      return null;
+  }
+}
+function emitTier1(node) {
+  const exported = isExported(node);
+  const outPrefix = exported ? "OUT " : "";
+  switch (node.type) {
+    case "import_statement": {
+      const text = collapseText(node.text, 80);
+      return `USE:${text}`;
+    }
+    case "function_declaration": {
+      const name = node.childForFieldName("name")?.text ?? "anonymous";
+      const rawParams = node.childForFieldName("parameters")?.text ?? "()";
+      const params = collapseText(rawParams, 60);
+      const asyncPrefix = isAsync(node) ? "ASYNC " : "";
+      return `${outPrefix}${asyncPrefix}FN:${name}${params}`;
+    }
+    case "class_declaration": {
+      const name = node.childForFieldName("name")?.text ?? "Anonymous";
+      const typeParams = getTypeParams(node);
+      return `${outPrefix}CLASS:${name}${typeParams}`;
+    }
+    case "interface_declaration": {
+      const name = node.childForFieldName("name")?.text ?? "Anonymous";
+      const typeParams = getTypeParams(node);
+      return `${outPrefix}INTERFACE:${name}${typeParams}`;
+    }
+    case "type_alias_declaration": {
+      const name = node.childForFieldName("name")?.text ?? "Anonymous";
+      return `${outPrefix}TYPE:${name}`;
+    }
+    case "enum_declaration": {
+      const name = node.childForFieldName("name")?.text ?? "Anonymous";
+      return `${outPrefix}ENUM:${name}`;
+    }
+    default:
+      return null;
+  }
+}
+function emitTier3(node) {
+  switch (node.type) {
+    case "lexical_declaration": {
+      let declarator = null;
+      for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (c.type === "variable_declarator") {
+          declarator = c;
+          break;
+        }
+      }
+      if (!declarator) return null;
+      const name = declarator.childForFieldName("name")?.text ?? "?";
+      const value = declarator.childForFieldName("value");
+      if (value) {
+        if (value.type === "arrow_function") {
+          const asyncPrefix = isAsync(value) ? "ASYNC " : "";
+          const params = value.childForFieldName("parameters")?.text ?? "()";
+          return `${asyncPrefix}FN:${name}${collapseText(params, 60)} => ...`;
+        }
+        if (value.type === "await_expression") {
+          const callee = value.childCount > 1 ? value.child(1).text : "...";
+          return `AWAIT:${name}=${collapseText(callee, 40)}`;
+        }
+        if (node.parent?.type === "statement_block") return null;
+        const vt = value.type;
+        if (vt === "number" || vt === "true" || vt === "false") return null;
+        if (vt === "object" || vt === "array") return null;
+        if (vt === "new_expression" || vt === "call_expression") return null;
+        const valText = value.text.replace(/"[^"]*"/g, '""').replace(/'[^']*'/g, "''").replace(/`[^`]*`/g, "``");
+        return `VAR:${name} = ${collapseText(valText, 50)}`;
+      }
+      return null;
+    }
+    case "expression_statement": {
+      const expr = node.child(0);
+      if (!expr) return null;
+      if (expr.type === "await_expression") {
+        return null;
+      }
+      if (expr.type === "call_expression") {
+        return null;
+      }
+      return null;
+    }
+    default:
+      return null;
+  }
+}
+function walkNode(node, depth, lines) {
+  const tier = tierOf(node.type);
+  switch (tier) {
+    case "T1_KEEP": {
+      const ir = emitTier1(node);
+      if (ir) lines.push(ir);
+      for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        const childType = child.type;
+        if (childType === "statement_block" || childType === "class_body") {
+          walkNode(child, depth + 1, lines);
+        }
+      }
+      break;
+    }
+    case "T2_CONTROL": {
+      if (depth > 4 && node.type !== "return_statement" && node.type !== "throw_statement" && node.type !== "switch_case" && node.type !== "switch_default") break;
+      if (node.type === "if_statement") {
+        let hasElse = false;
+        for (let i = 0; i < node.childCount; i++) {
+          if (node.child(i).type === "else_clause") {
+            hasElse = true;
+            break;
+          }
+        }
+        if (!hasElse) {
+          const body = node.childForFieldName("consequence") ?? (() => {
+            for (let i = 0; i < node.childCount; i++) {
+              const c = node.child(i);
+              if (c.type === "statement_block") return c;
+            }
+            return null;
+          })();
+          if (body) {
+            let singleStmt = null;
+            if (body.type === "statement_block") {
+              const stmts = [];
+              for (let i = 0; i < body.childCount; i++) {
+                const c = body.child(i);
+                if (c.type !== "{" && c.type !== "}") stmts.push(c);
+              }
+              if (stmts.length === 1) singleStmt = stmts[0];
+            } else if (body.type === "return_statement" || body.type === "throw_statement") {
+              singleStmt = body;
+            }
+            if (singleStmt && (singleStmt.type === "return_statement" || singleStmt.type === "throw_statement")) {
+              const cond = extractCondition(node);
+              const retLine = emitTier2(singleStmt);
+              if (retLine) {
+                const indent2 = "  ".repeat(depth);
+                lines.push(`${indent2}IF:${cond} \u2192 ${retLine}`);
+                break;
+              }
+            }
+          }
+        }
+      }
+      const line = emitTier2(node);
+      const indent = "  ".repeat(depth);
+      if (line) lines.push(indent + line);
+      for (let i = 0; i < node.childCount; i++) {
+        walkNode(node.child(i), depth + 1, lines);
+      }
+      break;
+    }
+    case "T3_COMPRESS": {
+      if (depth > 4) break;
+      const line = emitTier3(node);
+      const indent = "  ".repeat(depth);
+      if (line) lines.push(indent + line);
+      break;
+    }
+    case "WALK_ONLY": {
+      for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (node.type === "export_statement") {
+          if (child.type === "export" || child.type === "default" || child.text === "export" || child.text === "default") {
+            if (child.childCount === 0 && (child.text === "export" || child.text === "default")) {
+              continue;
+            }
+          }
+        }
+        walkNode(child, depth + 1, lines);
+      }
+      break;
+    }
+    case "T4_DROP":
+    default:
+      break;
+  }
+}
+async function astWalkIR(code, filePath) {
+  const lang = detectLanguage(filePath);
+  if (!lang) return null;
+  const { parser } = await getParser(lang);
+  const tree = parser.parse(code);
+  const root = tree.rootNode;
+  const lines = [];
+  walkNode(root, 0, lines);
+  if (lines.length === 0) return null;
+  const merged = [];
+  let useBlock = [];
+  for (const line of lines) {
+    if (line.startsWith("USE:")) {
+      const m = line.match(/from\s+["']([^"']+)["']/);
+      useBlock.push(m ? m[1] : line.slice(4));
+    } else {
+      if (useBlock.length > 0) {
+        if (useBlock.length <= 3) {
+          for (const mod of useBlock) merged.push(`USE:${mod}`);
+        } else {
+          merged.push(`USE:[${useBlock.join(", ")}]`);
+        }
+        useBlock = [];
+      }
+      merged.push(line);
+    }
+  }
+  if (useBlock.length > 0) {
+    if (useBlock.length <= 3) {
+      for (const mod of useBlock) merged.push(`USE:${mod}`);
+    } else {
+      merged.push(`USE:[${useBlock.join(", ")}]`);
+    }
+  }
+  return merged.join("\n");
+}
+
 // src/ir/layers.ts
 function generateL0(code, filePath) {
   const structure = extractStructure(code);
@@ -359,8 +881,8 @@ function generateL0(code, filePath) {
   return `${filePath}
 ${declarations.join("\n")}`;
 }
-function generateL1(code, health) {
-  const ir = fingerprintFile(code, 0.6);
+async function generateL1(code, filePath, health) {
+  const ir = await astWalkIR(code, filePath) ?? fingerprintFile(code, 0.75);
   if (health) {
     return annotateIR(ir, health);
   }
@@ -384,14 +906,14 @@ function generateL3(code, startLine, endLine) {
   const lines = code.split("\n");
   return lines.slice(startLine - 1, endLine).join("\n");
 }
-function generateLayer(layer, options) {
+async function generateLayer(layer, options) {
   switch (layer) {
     case "L0":
       return generateL0(options.code, options.filePath);
     case "L1":
-      return generateL1(options.code, options.health);
+      return generateL1(options.code, options.filePath, options.health);
     case "L2":
-      if (!options.delta) return generateL1(options.code, options.health);
+      if (!options.delta) return generateL1(options.code, options.filePath, options.health);
       return generateL2(options.delta, options.health);
     case "L3":
       if (options.lineRange) {
@@ -654,33 +1176,141 @@ function estimateTokens(text) {
 }
 
 // src/benchmark/runner.ts
-function benchmarkFile(code, filePath) {
+async function benchmarkFile(code, filePath) {
   const rawTokens = estimateTokens(code);
-  const irL0 = generateLayer("L0", { code, filePath, health: null });
-  const irL1 = generateLayer("L1", { code, filePath, health: null });
+  const irL0 = await generateLayer("L0", { code, filePath, health: null });
+  const irL1 = await generateLayer("L1", { code, filePath, health: null });
   const irL0Tokens = estimateTokens(irL0);
   const irL1Tokens = estimateTokens(irL1);
-  const lines = code.split("\n");
-  let totalConf = 0;
-  let count = 0;
-  for (const line of lines) {
-    const result = fingerprintLine(line);
-    if (result.ir !== "") {
-      totalConf += result.confidence;
-      count++;
-    }
-  }
+  const astResult = await astWalkIR(code, filePath);
+  const engine = astResult !== null ? "AST" : "FP";
   const savedPercent = rawTokens > 0 ? (rawTokens - irL1Tokens) / rawTokens * 100 : 0;
-  const avgConfidence = count > 0 ? totalConf / count : 0;
-  return { file: filePath, rawTokens, irL0Tokens, irL1Tokens, savedPercent, avgConfidence };
+  return { file: filePath, rawTokens, irL0Tokens, irL1Tokens, savedPercent, engine };
 }
 function summarize(results) {
   const totalRaw = results.reduce((s, r) => s + r.rawTokens, 0);
   const totalIRL0 = results.reduce((s, r) => s + r.irL0Tokens, 0);
   const totalIRL1 = results.reduce((s, r) => s + r.irL1Tokens, 0);
   const totalSavedPercent = totalRaw > 0 ? (totalRaw - totalIRL1) / totalRaw * 100 : 0;
-  const avgConfidence = results.length > 0 ? results.reduce((s, r) => s + r.avgConfidence, 0) / results.length : 0;
-  return { fileCount: results.length, totalRaw, totalIRL0, totalIRL1, totalSavedPercent, avgConfidence };
+  const astCount = results.filter((r) => r.engine === "AST").length;
+  const fpCount = results.filter((r) => r.engine === "FP").length;
+  return { fileCount: results.length, totalRaw, totalIRL0, totalIRL1, totalSavedPercent, astCount, fpCount };
+}
+
+// src/benchmark/quality.ts
+var BENCHMARK_PROMPTS = [
+  {
+    id: "understand",
+    label: "Comprehension",
+    template: "What does this code do? List the main functions/classes and briefly describe each one's purpose and dependencies.\n\n{code}"
+  },
+  {
+    id: "fix-bug",
+    label: "Bug Detection",
+    template: "Review this code for potential bugs, edge cases, or error handling issues. List any problems you find.\n\n{code}"
+  },
+  {
+    id: "review",
+    label: "Code Review",
+    template: "Do a code review of this file. Comment on code quality, naming, structure, and any improvements you'd suggest.\n\n{code}"
+  },
+  {
+    id: "explain",
+    label: "Explanation",
+    template: "Explain this code to a developer who is new to the codebase. Focus on how the pieces fit together.\n\n{code}"
+  },
+  {
+    id: "refactor",
+    label: "Refactoring",
+    template: "How would you refactor this code for better maintainability and testability? Suggest specific changes.\n\n{code}"
+  }
+];
+async function askClaude(context, prompt, apiKey) {
+  const { default: Anthropic } = await import("@anthropic-ai/sdk");
+  const client = new Anthropic({ apiKey });
+  const userMessage = prompt.replace("{code}", context);
+  const estimatedInput = estimateTokens(userMessage);
+  const start = performance.now();
+  const response = await client.messages.create({
+    model: "claude-haiku-4-5-20251001",
+    max_tokens: 1024,
+    messages: [{ role: "user", content: userMessage }]
+  });
+  const elapsed = performance.now() - start;
+  const textBlock = response.content.find((b) => b.type === "text");
+  const text = textBlock?.text ?? "";
+  return {
+    label: "",
+    inputTokens: response.usage.input_tokens,
+    outputTokens: response.usage.output_tokens,
+    totalTokens: response.usage.input_tokens + response.usage.output_tokens,
+    responseTimeMs: elapsed,
+    response: text,
+    usageInput: response.usage.input_tokens,
+    usageOutput: response.usage.output_tokens
+  };
+}
+async function runQualityBenchmark(code, filePath, apiKey, promptId = "understand") {
+  const irL1 = await generateLayer("L1", { code, filePath, health: null });
+  const prompt = BENCHMARK_PROMPTS.find((p) => p.id === promptId) ?? BENCHMARK_PROMPTS[0];
+  const [rawResult, irResult] = await Promise.all([
+    askClaude(code, prompt.template, apiKey),
+    askClaude(irL1, prompt.template, apiKey)
+  ]);
+  rawResult.label = "Raw Code";
+  irResult.label = "IR (L1)";
+  const savedPercent = rawResult.totalTokens > 0 ? (rawResult.totalTokens - irResult.totalTokens) / rawResult.totalTokens * 100 : 0;
+  return { file: filePath, raw: rawResult, ir: irResult, savedPercent };
+}
+
+// src/context/packer.ts
+async function packContext(files, options) {
+  const { budget, hotspots } = options;
+  const hotspotSet = new Set(hotspots.map((h) => h.file));
+  const entries = [];
+  let totalTokens = 0;
+  for (const file of files) {
+    const l0 = await generateLayer("L0", { code: file.code, filePath: file.path, health: null });
+    const l0Tokens = estimateTokens(l0);
+    entries.push({ path: file.path, layer: "L0", ir: l0, tokens: l0Tokens });
+    totalTokens += l0Tokens;
+  }
+  if (totalTokens > budget) {
+    const truncated = [];
+    let used = 0;
+    for (const entry of entries) {
+      if (used + entry.tokens <= budget) {
+        truncated.push(entry);
+        used += entry.tokens;
+      }
+    }
+    return { entries: truncated, totalTokens: used, budget, filesAtL0: truncated.length, filesAtL1: 0 };
+  }
+  const upgradeOrder = entries.map((e, i) => ({ index: i, path: e.path, rawTokens: files[i].rawTokens, isHotspot: hotspotSet.has(e.path) })).sort((a, b) => {
+    if (a.isHotspot && !b.isHotspot) return -1;
+    if (!a.isHotspot && b.isHotspot) return 1;
+    return b.rawTokens - a.rawTokens;
+  });
+  let filesAtL1 = 0;
+  for (const item of upgradeOrder) {
+    const file = files[item.index];
+    const l1 = await generateLayer("L1", { code: file.code, filePath: file.path, health: null });
+    const l1Tokens = estimateTokens(l1);
+    const currentL0Tokens = entries[item.index].tokens;
+    const additionalTokens = l1Tokens - currentL0Tokens;
+    if (totalTokens + additionalTokens <= budget) {
+      entries[item.index] = { path: item.path, layer: "L1", ir: l1, tokens: l1Tokens };
+      totalTokens += additionalTokens;
+      filesAtL1++;
+    }
+  }
+  return {
+    entries,
+    totalTokens,
+    budget,
+    filesAtL0: entries.length - filesAtL1,
+    filesAtL1
+  };
 }
 
 // src/cli/commands.ts
@@ -749,7 +1379,7 @@ function runTrends(projectPath) {
   };
   adapter.notify({ type: "trend-report", data: trends });
 }
-function runIR(projectPath, filePath, layer) {
+async function runIR(projectPath, filePath, layer) {
   const config = loadConfig(projectPath);
   const code = readFileSync2(filePath, "utf-8");
   const relPath = relative(projectPath, filePath);
@@ -764,25 +1394,27 @@ function runIR(projectPath, filePath, layer) {
   };
   const health = computeHealthFromTrends(relPath, trends);
   const irLayer = layer || "L1";
-  const result = generateLayer(irLayer, {
+  const result = await generateLayer(irLayer, {
     code,
     filePath: relPath,
     health: health.churn > 0 ? health : null
   });
   console.log(result);
 }
-function runBenchmark(projectPath) {
+var ALL_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".py", ".go", ".rs"];
+async function runBenchmark(projectPath) {
   console.log("composto v0.1.0 \u2014 benchmark\n");
-  const files = collectFiles(projectPath, [".ts", ".tsx", ".js", ".jsx"]);
+  const files = collectFiles(projectPath, ALL_EXTENSIONS);
   console.log(`  ${files.length} files
 `);
-  const results = files.map((file) => {
+  const results = [];
+  for (const file of files) {
     const code = readFileSync2(file, "utf-8");
     const relPath = relative(projectPath, file);
-    return benchmarkFile(code, relPath);
-  });
+    results.push(await benchmarkFile(code, relPath));
+  }
   results.sort((a, b) => b.savedPercent - a.savedPercent);
-  const header = "  File                                  Raw      L0      L1   Saved   Conf";
+  const header = "  File                                  Raw      L0      L1   Saved   Eng";
   const divider = "  " + "\u2500".repeat(header.length - 2);
   console.log(header);
   console.log(divider);
@@ -792,8 +1424,8 @@ function runBenchmark(projectPath) {
     const l0 = String(r.irL0Tokens).padStart(7);
     const l1 = String(r.irL1Tokens).padStart(7);
     const saved = (r.savedPercent.toFixed(1) + "%").padStart(7);
-    const conf = r.avgConfidence.toFixed(2).padStart(6);
-    console.log(`  ${file} ${raw} ${l0} ${l1} ${saved} ${conf}`);
+    const eng = r.engine.padStart(5);
+    console.log(`  ${file} ${raw} ${l0} ${l1} ${saved} ${eng}`);
   }
   const summary = summarize(results);
   console.log(divider);
@@ -802,28 +1434,107 @@ function runBenchmark(projectPath) {
   const totalL0 = String(summary.totalIRL0).padStart(7);
   const totalL1 = String(summary.totalIRL1).padStart(7);
   const totalSaved = (summary.totalSavedPercent.toFixed(1) + "%").padStart(7);
-  const totalConf = summary.avgConfidence.toFixed(2).padStart(6);
-  console.log(`  ${totalLabel} ${totalRaw} ${totalL0} ${totalL1} ${totalSaved} ${totalConf}`);
+  console.log(`  ${totalLabel} ${totalRaw} ${totalL0} ${totalL1} ${totalSaved}`);
   const l0Percent = summary.totalRaw > 0 ? (summary.totalRaw - summary.totalIRL0) / summary.totalRaw * 100 : 0;
   console.log(`
   L0 (structure map):  ${summary.totalRaw} \u2192 ${summary.totalIRL0} tokens (${l0Percent.toFixed(1)}% reduction)`);
   console.log(`  L1 (full IR):        ${summary.totalRaw} \u2192 ${summary.totalIRL1} tokens (${summary.totalSavedPercent.toFixed(1)}% reduction)`);
   console.log(`  Files analyzed: ${summary.fileCount}`);
-  console.log(`  Avg confidence: ${summary.avgConfidence.toFixed(2)}`);
+  console.log(`  Engine: ${summary.astCount} AST, ${summary.fpCount} FP`);
+}
+async function runBenchmarkQuality(projectPath, filePath) {
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    console.error("  Error: ANTHROPIC_API_KEY environment variable is required.");
+    process.exit(1);
+  }
+  const code = readFileSync2(filePath, "utf-8");
+  const relPath = relative(projectPath, filePath);
+  console.log("composto v0.1.0 \u2014 quality benchmark\n");
+  console.log(`  File: ${relPath}
+`);
+  console.log("  Sending to Claude Haiku...\n");
+  const result = await runQualityBenchmark(code, relPath, apiKey);
+  const col1 = 20;
+  const col2 = 12;
+  const col3 = 12;
+  const line = "  " + "\u2500".repeat(col1 + col2 + col3 + 4);
+  console.log(line);
+  console.log(`  ${"".padEnd(col1)} ${"Raw Code".padStart(col2)} ${"IR (L1)".padStart(col3)}`);
+  console.log(line);
+  console.log(`  ${"Input tokens".padEnd(col1)} ${String(result.raw.inputTokens).padStart(col2)} ${String(result.ir.inputTokens).padStart(col3)}`);
+  console.log(`  ${"Output tokens".padEnd(col1)} ${String(result.raw.outputTokens).padStart(col2)} ${String(result.ir.outputTokens).padStart(col3)}`);
+  console.log(`  ${"Total tokens".padEnd(col1)} ${String(result.raw.totalTokens).padStart(col2)} ${String(result.ir.totalTokens).padStart(col3)}`);
+  console.log(`  ${"Response time".padEnd(col1)} ${(result.raw.responseTimeMs / 1e3).toFixed(1).padStart(col2 - 1)}s ${(result.ir.responseTimeMs / 1e3).toFixed(1).padStart(col3 - 1)}s`);
+  console.log(`  ${"Saved".padEnd(col1)} ${"\u2014".padStart(col2)} ${(result.savedPercent.toFixed(1) + "%").padStart(col3)}`);
+  console.log(line);
+  console.log(`
+  --- Raw Code Response ---
+${result.raw.response}
+`);
+  console.log(`  --- IR Response ---
+${result.ir.response}
+`);
+  if (result.savedPercent > 0) {
+    console.log(`  Verdict: ${result.savedPercent.toFixed(1)}% fewer tokens with IR.`);
+  }
+}
+async function runContext(projectPath, budget) {
+  console.log(`composto v0.1.0 \u2014 context (budget: ${budget} tokens)
+`);
+  const files = collectFiles(projectPath, ALL_EXTENSIONS);
+  console.log(`  ${files.length} files
+`);
+  const config = loadConfig(projectPath);
+  const entries = getGitLog(projectPath, 100);
+  const hotspots = detectHotspots(entries, {
+    threshold: config.trends.hotspotThreshold,
+    fixRatioThreshold: config.trends.bugFixRatioThreshold
+  });
+  const fileInputs = files.map((file) => {
+    const code = readFileSync2(file, "utf-8");
+    const relPath = relative(projectPath, file);
+    return { path: relPath, code, rawTokens: estimateTokens(code) };
+  });
+  const result = await packContext(fileInputs, { budget, hotspots });
+  const l1Entries = result.entries.filter((e) => e.layer === "L1");
+  const l0Entries = result.entries.filter((e) => e.layer === "L0");
+  if (l1Entries.length > 0) {
+    console.log("  == L1 (detailed) ==\n");
+    for (const entry of l1Entries) {
+      const label = hotspots.some((h) => h.file === entry.path) ? "hotspot" : "detail";
+      console.log(`  [${label}] ${entry.path}`);
+      for (const line of entry.ir.split("\n")) {
+        console.log(`    ${line}`);
+      }
+      console.log();
+    }
+  }
+  if (l0Entries.length > 0) {
+    console.log("  == L0 (structure) ==\n");
+    for (const entry of l0Entries) {
+      for (const line of entry.ir.split("\n")) {
+        console.log(`    ${line}`);
+      }
+    }
+    console.log();
+  }
+  console.log(`  Budget: ${result.totalTokens}/${result.budget} tokens`);
+  console.log(`  Files: ${result.filesAtL1} at L1, ${result.filesAtL0} at L0`);
 }
 
 // src/index.ts
-import { resolve } from "path";
+import { resolve as resolve2 } from "path";
 var args = process.argv.slice(2);
 var command = args[0];
 switch (command) {
   case "scan": {
-    const projectPath = resolve(args[1] ?? ".");
+    const projectPath = resolve2(args[1] ?? ".");
     runScan(projectPath);
     break;
   }
   case "trends": {
-    const projectPath = resolve(args[1] ?? ".");
+    const projectPath = resolve2(args[1] ?? ".");
     runTrends(projectPath);
     break;
   }
@@ -834,12 +1545,28 @@ switch (command) {
       console.error("Usage: composto ir <file> [L0|L1|L2|L3]");
       process.exit(1);
     }
-    runIR(resolve("."), resolve(filePath), layer);
+    await runIR(resolve2("."), resolve2(filePath), layer);
     break;
   }
   case "benchmark": {
-    const projectPath = resolve(args[1] ?? ".");
-    runBenchmark(projectPath);
+    const projectPath = resolve2(args[1] ?? ".");
+    await runBenchmark(projectPath);
+    break;
+  }
+  case "benchmark-quality": {
+    const filePath = args[1];
+    if (!filePath) {
+      console.error("Usage: composto benchmark-quality <file>");
+      process.exit(1);
+    }
+    await runBenchmarkQuality(resolve2("."), resolve2(filePath));
+    break;
+  }
+  case "context": {
+    const projectPath = resolve2(args[1] ?? ".");
+    const budgetFlag = args.indexOf("--budget");
+    const budget = budgetFlag !== -1 && args[budgetFlag + 1] ? parseInt(args[budgetFlag + 1], 10) : 4e3;
+    await runContext(projectPath, budget);
     break;
   }
   case "version":
@@ -852,6 +1579,8 @@ switch (command) {
     console.log("  trends [path]        Analyze codebase health trends");
     console.log("  ir <file> [layer]    Generate IR for a file (L0|L1|L2|L3)");
     console.log("  benchmark [path]     Benchmark IR token savings");
+    console.log("  benchmark-quality <file>  Compare AI responses: raw vs IR");
+    console.log("  context [path] --budget N  Smart context within token budget");
     console.log("  version              Show version");
     break;
 }