composto-ai 0.2.0 → 0.3.0

package/dist/{chunk-MFNGSHTZ.js → chunk-AARGW2GV.js}

@@ -499,36 +499,94 @@ function detectLanguage(filePath) {
 
 // src/ir/ast-walker.ts
 var TIER_MAP = {
-  // Tier 1 — structural declarations
+  // Tier 1 — structural declarations (JS/TS)
   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
+  // Tier 1 — Python
+  function_definition: "T1_KEEP",
+  class_definition: "T1_KEEP",
+  import_from_statement: "T1_KEEP",
+  decorated_definition: "T1_KEEP",
+  // Tier 1 — class members (qualified methods)
+  method_definition: "T1_KEEP",
+  // JS/TS class method
+  public_field_definition: "T1_KEEP",
+  // TS class property
+  // Tier 1 — Go
+  function_item: "T1_KEEP",
+  // Rust
+  method_declaration: "T1_KEEP",
+  // Go
+  type_declaration: "T1_KEEP",
+  // Go
+  import_declaration: "T1_KEEP",
+  // Go
+  use_declaration: "T1_KEEP",
+  // Rust
+  struct_item: "T1_KEEP",
+  // Rust
+  enum_item: "T1_KEEP",
+  // Rust
+  trait_item: "T1_KEEP",
+  // Rust
+  impl_item: "T1_KEEP",
+  // Rust
+  // Tier 2 — control flow (universal)
   if_statement: "T2_CONTROL",
+  if_expression: "T2_CONTROL",
+  // Rust
   else_clause: "WALK_ONLY",
+  elif_clause: "T2_CONTROL",
+  // Python
   for_statement: "T2_CONTROL",
   for_in_statement: "T2_CONTROL",
+  for_expression: "T2_CONTROL",
+  // Rust
   while_statement: "T2_CONTROL",
   do_statement: "T2_CONTROL",
   switch_statement: "T2_CONTROL",
   switch_case: "T2_CONTROL",
   switch_default: "T2_CONTROL",
+  match_expression: "T2_CONTROL",
+  // Rust
   return_statement: "T2_CONTROL",
+  return_expression: "T2_CONTROL",
+  // Rust
   throw_statement: "T2_CONTROL",
+  raise_statement: "T2_CONTROL",
+  // Python
   try_statement: "T2_CONTROL",
   catch_clause: "T2_CONTROL",
+  except_clause: "T2_CONTROL",
+  // Python
+  with_statement: "T2_CONTROL",
+  // Python
+  defer_statement: "T2_CONTROL",
+  // Go
   // Tier 3 — compressible expressions
   lexical_declaration: "T3_COMPRESS",
   expression_statement: "T3_COMPRESS",
-  // Walk-only — containers that need traversal but no emission
+  assignment: "T3_COMPRESS",
+  // Python
+  short_var_declaration: "T3_COMPRESS",
+  // Go
+  // Walk-only — containers
   program: "WALK_ONLY",
+  module: "WALK_ONLY",
+  // Python
   statement_block: "WALK_ONLY",
+  block: "WALK_ONLY",
+  // Python/Go/Rust
   class_body: "WALK_ONLY",
+  // JS/TS
   switch_body: "WALK_ONLY",
-  export_statement: "WALK_ONLY"
+  export_statement: "WALK_ONLY",
+  source_file: "WALK_ONLY"
+  // Go/Rust
 };
 function tierOf(nodeType) {
   return TIER_MAP[nodeType] ?? "T4_DROP";
@@ -553,6 +611,49 @@ function isExported(node) {
 function isAsync(node) {
   return node.text.trimStart().startsWith("async");
 }
+function extractDocComment(node) {
+  let prev = node.previousNamedSibling;
+  if (!prev && node.parent?.type === "export_statement") {
+    prev = node.parent.previousNamedSibling;
+  }
+  if (!prev || prev.type !== "comment") return null;
+  const text = prev.text;
+  if (!text.startsWith("/**")) return null;
+  const body = text.replace(/^\/\*\*|\*\/$/g, "").replace(/^\s*\*\s?/gm, "").trim();
+  const tags = [];
+  const tagMatches = body.matchAll(/@(\w+)(?:\s+([^\n@]+))?/g);
+  for (const m of tagMatches) {
+    const tag = m[1];
+    const val = (m[2] ?? "").trim();
+    if (tag === "deprecated") tags.push("@deprecated");
+    else if (tag === "internal") tags.push("@internal");
+    else if (tag === "throws" && val) tags.push(`@throws:${val.length > 30 ? val.slice(0, 27) + "..." : val}`);
+  }
+  const beforeTags = body.split(/@\w+/)[0].trim();
+  const desc = beforeTags.split(/[.\n]/)[0].trim();
+  const parts = [];
+  if (tags.length > 0) parts.push(tags.join(" "));
+  if (desc && desc.length > 3) {
+    parts.push(`"${desc.length > 50 ? desc.slice(0, 47) + "..." : desc}"`);
+  }
+  return parts.length > 0 ? parts.join(" ") : null;
+}
+function extractPythonDocstring(bodyNode) {
+  if (!bodyNode) return null;
+  for (let i = 0; i < bodyNode.childCount; i++) {
+    const child = bodyNode.child(i);
+    if (child.type === "expression_statement" && child.childCount > 0) {
+      const expr = child.child(0);
+      if (expr.type === "string") {
+        const text = expr.text.replace(/^(['"]{3}|['"])|(['"]{3}|['"])$/g, "").trim();
+        const firstLine = text.split("\n")[0].trim();
+        return firstLine.length > 3 ? `"${firstLine.length > 50 ? firstLine.slice(0, 47) + "..." : firstLine}"` : null;
+      }
+      break;
+    }
+  }
+  return null;
+}
 function extractCondition(node) {
   const condNode = node.childForFieldName("condition") ?? (() => {
     for (let i = 0; i < node.childCount; i++) {
@@ -644,6 +745,35 @@ function emitTier2(node) {
       const paramText = param ? param.text : "...";
       return `CATCH:${paramText}`;
     }
+    // Python
+    case "raise_statement": {
+      const val = node.childCount > 1 ? node.child(1)?.text ?? "" : "";
+      return `RAISE:${val.length > 50 ? val.slice(0, 47) + "..." : val}`;
+    }
+    case "except_clause":
+      return "EXCEPT";
+    case "elif_clause": {
+      const cond = extractCondition(node);
+      return `ELIF:${cond}`;
+    }
+    case "with_statement":
+      return "WITH";
+    // Rust
+    case "if_expression": {
+      const cond = extractCondition(node);
+      return `IF:${cond}`;
+    }
+    case "for_expression":
+      return "LOOP";
+    case "match_expression":
+      return "MATCH";
+    case "return_expression": {
+      const val = node.childCount > 1 ? node.child(1)?.text ?? "" : "";
+      return `RET ${val.length > 60 ? val.slice(0, 57) + "..." : val}`.trimEnd();
+    }
+    // Go
+    case "defer_statement":
+      return "DEFER";
     default:
       return null;
   }
@@ -661,25 +791,103 @@ function emitTier1(node) {
       const rawParams = node.childForFieldName("parameters")?.text ?? "()";
       const params = collapseText(rawParams, 60);
       const asyncPrefix = isAsync(node) ? "ASYNC " : "";
-      return `${outPrefix}${asyncPrefix}FN:${name}${params}`;
+      const doc = extractDocComment(node);
+      const docPrefix = doc ? `${doc} ` : "";
+      return `${docPrefix}${outPrefix}${asyncPrefix}FN:${name}${params}`;
     }
     case "class_declaration": {
       const name = node.childForFieldName("name")?.text ?? "Anonymous";
       const typeParams = getTypeParams(node);
-      return `${outPrefix}CLASS:${name}${typeParams}`;
+      const doc = extractDocComment(node);
+      const docPrefix = doc ? `${doc} ` : "";
+      return `${docPrefix}${outPrefix}CLASS:${name}${typeParams}`;
     }
     case "interface_declaration": {
       const name = node.childForFieldName("name")?.text ?? "Anonymous";
       const typeParams = getTypeParams(node);
-      return `${outPrefix}INTERFACE:${name}${typeParams}`;
+      const doc = extractDocComment(node);
+      const docPrefix = doc ? `${doc} ` : "";
+      return `${docPrefix}${outPrefix}INTERFACE:${name}${typeParams}`;
     }
     case "type_alias_declaration": {
       const name = node.childForFieldName("name")?.text ?? "Anonymous";
-      return `${outPrefix}TYPE:${name}`;
+      const doc = extractDocComment(node);
+      const docPrefix = doc ? `${doc} ` : "";
+      return `${docPrefix}${outPrefix}TYPE:${name}`;
     }
     case "enum_declaration": {
       const name = node.childForFieldName("name")?.text ?? "Anonymous";
-      return `${outPrefix}ENUM:${name}`;
+      const doc = extractDocComment(node);
+      const docPrefix = doc ? `${doc} ` : "";
+      return `${docPrefix}${outPrefix}ENUM:${name}`;
+    }
+    case "method_definition": {
+      let enclosingClass = null;
+      let parent = node.parent;
+      while (parent) {
+        if (parent.type === "class_declaration" || parent.type === "class_definition") {
+          enclosingClass = parent.childForFieldName("name")?.text ?? null;
+          break;
+        }
+        parent = parent.parent;
+      }
+      const name = node.childForFieldName("name")?.text ?? "anonymous";
+      const params = node.childForFieldName("parameters")?.text ?? "()";
+      const asyncPrefix = isAsync(node) ? "ASYNC " : "";
+      const doc = extractDocComment(node);
+      const docPrefix = doc ? `${doc} ` : "";
+      const qualifiedName = enclosingClass ? `${enclosingClass}.${name}` : name;
+      return `${docPrefix}${asyncPrefix}METHOD:${qualifiedName}${collapseText(params, 60)}`;
+    }
+    case "public_field_definition": {
+      const name = node.childForFieldName("name")?.text ?? "field";
+      return `FIELD:${name}`;
+    }
+    // Python
+    case "function_definition": {
+      const name = node.childForFieldName("name")?.text ?? "anonymous";
+      const params = node.childForFieldName("parameters")?.text ?? "()";
+      const returnType = node.childForFieldName("return_type")?.text ?? "";
+      const rt = returnType ? ` -> ${returnType}` : "";
+      const body = node.childForFieldName("body");
+      const doc = extractPythonDocstring(body);
+      const docPrefix = doc ? `${doc} ` : "";
+      return `${docPrefix}FN:${name}${collapseText(params, 60)}${rt}`;
+    }
+    case "class_definition": {
+      const name = node.childForFieldName("name")?.text ?? "Anonymous";
+      const superclass = node.childForFieldName("superclasses")?.text ?? "";
+      const sc = superclass ? `(${collapseText(superclass, 40)})` : "";
+      const body = node.childForFieldName("body");
+      const doc = extractPythonDocstring(body);
+      const docPrefix = doc ? `${doc} ` : "";
+      return `${docPrefix}CLASS:${name}${sc}`;
+    }
+    case "import_from_statement": {
+      return `USE:${collapseText(node.text, 80)}`;
+    }
+    case "decorated_definition": {
+      return null;
+    }
+    // Go
+    case "method_declaration":
+    case "type_declaration":
+    case "import_declaration": {
+      return `${collapseText(node.text, 80)}`;
+    }
+    // Rust
+    case "function_item": {
+      const name = node.childForFieldName("name")?.text ?? "anonymous";
+      const params = node.childForFieldName("parameters")?.text ?? "()";
+      return `FN:${name}${collapseText(params, 60)}`;
+    }
+    case "struct_item":
+    case "enum_item":
+    case "trait_item":
+    case "impl_item":
+    case "use_declaration": {
+      const firstLine = node.text.split("\n")[0];
+      return collapseText(firstLine, 80);
     }
     default:
       return null;
@@ -726,6 +934,17 @@ function emitTier3(node) {
         return null;
       }
       if (expr.type === "call_expression") {
+        const callee = expr.child(0)?.text ?? "";
+        if (callee === "ObjectSetPrototypeOf" || callee === "Object.setPrototypeOf") {
+          const args = expr.child(1);
+          if (args && args.childCount >= 4) {
+            const child = args.child(1)?.text ?? "?";
+            const parent = args.child(3)?.text ?? "?";
+            const shortChild = child.length > 30 ? child.slice(0, 27) + "..." : child;
+            const shortParent = parent.length > 30 ? parent.slice(0, 27) + "..." : parent;
+            return `EXTENDS:${shortChild} < ${shortParent}`;
+          }
+        }
         return null;
       }
       return null;
@@ -743,7 +962,9 @@ function walkNode(node, depth, lines) {
       for (let i = 0; i < node.childCount; i++) {
         const child = node.child(i);
         const childType = child.type;
-        if (childType === "statement_block" || childType === "class_body") {
+        if (childType === "statement_block" || childType === "class_body" || childType === "block" || // Python/Go/Rust
+        childType === "body" || // Python class/function body
+        childType === "declaration_list") {
           walkNode(child, depth + 1, lines);
         }
       }
@@ -834,7 +1055,7 @@ async function astWalkIR(code, filePath) {
   const lines = [];
   walkNode(root, 0, lines);
   if (lines.length === 0) return null;
-  const merged = [];
+  const pass1 = [];
   let useBlock = [];
   for (const line of lines) {
     if (line.startsWith("USE:")) {
@@ -843,20 +1064,45 @@ async function astWalkIR(code, filePath) {
     } else {
       if (useBlock.length > 0) {
         if (useBlock.length <= 3) {
-          for (const mod of useBlock) merged.push(`USE:${mod}`);
+          for (const mod of useBlock) pass1.push(`USE:${mod}`);
         } else {
-          merged.push(`USE:[${useBlock.join(", ")}]`);
+          pass1.push(`USE:[${useBlock.join(", ")}]`);
         }
         useBlock = [];
       }
-      merged.push(line);
+      pass1.push(line);
     }
   }
   if (useBlock.length > 0) {
     if (useBlock.length <= 3) {
-      for (const mod of useBlock) merged.push(`USE:${mod}`);
+      for (const mod of useBlock) pass1.push(`USE:${mod}`);
     } else {
-      merged.push(`USE:[${useBlock.join(", ")}]`);
+      pass1.push(`USE:[${useBlock.join(", ")}]`);
+    }
+  }
+  const merged = [];
+  let guardBlock = [];
+  for (const line of pass1) {
+    const guardMatch = line.match(/^(\s*)IF:(.+?) \u2192 RET/);
+    if (guardMatch) {
+      guardBlock.push(guardMatch[2].trim());
+      continue;
+    }
+    if (guardBlock.length > 0) {
+      if (guardBlock.length < 3) {
+        for (const g of guardBlock) merged.push(`  IF:${g} \u2192 RET`);
+      } else {
+        merged.push(`  GUARD:[${guardBlock.join(", ")}]`);
+      }
+      guardBlock = [];
+    }
+    merged.push(line);
+  }
+  if (guardBlock.length > 0) {
+    if (guardBlock.length < 3) {
+      for (const g of guardBlock) merged.push(`  IF:${g} \u2192 RET`);
+    } else {
+      merged.push(`  GUARD:[${guardBlock.join(", ")}]`);
     }
   }
   return merged.join("\n");
@@ -879,10 +1125,11 @@ ${declarations.join("\n")}`;
 }
 async function generateL1(code, filePath, health) {
   const ir = await astWalkIR(code, filePath) ?? fingerprintFile(code, 0.75);
+  const result = ir.length < code.length ? ir : code;
   if (health) {
-    return annotateIR(ir, health);
+    return annotateIR(result, health);
   }
-  return ir;
+  return result;
 }
 function generateL2(delta, health) {
   const parts = [`FILE: ${delta.file}`];
@@ -1098,43 +1345,161 @@ function summarize(results) {
 }
 
 // src/context/packer.ts
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function findTargetFile(files, target) {
+  const t = escapeRegex(target);
+  const declarationPatterns = [
+    // JS/TS declarations
+    new RegExp(`(?:export\\s+)?(?:async\\s+)?function\\s+${t}\\b`),
+    new RegExp(`(?:export\\s+)?class\\s+${t}\\b`),
+    new RegExp(`(?:export\\s+)?interface\\s+${t}\\b`),
+    new RegExp(`(?:export\\s+)?type\\s+${t}\\b`),
+    new RegExp(`(?:export\\s+)?enum\\s+${t}\\b`),
+    new RegExp(`(?:export\\s+)?(?:const|let|var)\\s+${t}\\b`),
+    // Python
+    new RegExp(`\\bdef\\s+${t}\\b`),
+    // Rust
+    new RegExp(`\\bfn\\s+${t}\\b`),
+    new RegExp(`\\bstruct\\s+${t}\\b`),
+    new RegExp(`\\btrait\\s+${t}\\b`),
+    // Go
+    new RegExp(`\\bfunc\\s+${t}\\b`),
+    new RegExp(`\\btype\\s+${t}\\b`),
+    // Object method shorthand
+    new RegExp(`\\b${t}\\s*:\\s*(?:async\\s+)?function\\b`),
+    new RegExp(`\\b${t}\\s*\\([^)]*\\)\\s*\\{`)
+  ];
+  for (const pattern of declarationPatterns) {
+    const match2 = files.find((f) => pattern.test(f.code));
+    if (match2) return match2.path;
+  }
+  const fallback = new RegExp(`\\b${t}\\s*\\(`);
+  const match = files.find((f) => fallback.test(f.code));
+  return match ? match.path : null;
+}
+function findRelatedFiles(files, targetPath) {
+  const related = /* @__PURE__ */ new Set();
+  const targetFile = files.find((f) => f.path === targetPath);
+  if (!targetFile) return related;
+  const importPattern = /(?:import|require)\s*(?:\([^)]*|\{[^}]*\}|\w+)?\s*(?:from)?\s*["']([^"']+)["']/g;
+  const imports = [...targetFile.code.matchAll(importPattern)].map((m) => m[1]);
+  for (const imp of imports) {
+    const match = files.find((f) => {
+      const basename = f.path.replace(/\.[^.]+$/, "");
+      return imp.includes(basename) || basename.endsWith(imp.replace(/^\.\.?\//, "").replace(/\.[^.]+$/, ""));
+    });
+    if (match) related.add(match.path);
+  }
+  const targetBasename = targetPath.replace(/\.[^.]+$/, "").split("/").pop() ?? "";
+  for (const file of files) {
+    if (file.path === targetPath) continue;
+    if (file.code.includes(targetBasename)) {
+      related.add(file.path);
+    }
+  }
+  return related;
+}
 async function packContext(files, options) {
-  const { budget, hotspots } = options;
+  const { budget, hotspots, target } = options;
   const hotspotSet = new Set(hotspots.map((h) => h.file));
+  let targetPath = null;
+  let relatedFiles = /* @__PURE__ */ new Set();
+  if (target) {
+    targetPath = findTargetFile(files, target);
+    if (targetPath) {
+      relatedFiles = findRelatedFiles(files, targetPath);
+    }
+  }
   const entries = [];
   let totalTokens = 0;
+  let filesAtL3 = 0;
+  let targetDowngraded = false;
+  if (targetPath) {
+    const targetFile = files.find((f) => f.path === targetPath);
+    const rawTokens = estimateTokens(targetFile.code);
+    if (rawTokens <= budget * 0.6) {
+      entries.push({
+        path: targetPath,
+        layer: "L3",
+        ir: targetFile.code,
+        tokens: rawTokens,
+        isTarget: true
+      });
+      totalTokens += rawTokens;
+      filesAtL3 = 1;
+    } else {
+      targetDowngraded = true;
+      const l1 = await generateLayer("L1", { code: targetFile.code, filePath: targetFile.path, health: null });
+      const l1Tokens = estimateTokens(l1);
+      entries.push({
+        path: targetPath,
+        layer: "L1",
+        ir: l1,
+        tokens: l1Tokens,
+        isTarget: true
+      });
+      totalTokens += l1Tokens;
+    }
+  }
   for (const file of files) {
+    if (file.path === targetPath) continue;
     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;
+    const truncated = entries.filter((e) => e.isTarget);
+    let used = truncated.reduce((s, e) => s + e.tokens, 0);
     for (const entry of entries) {
+      if (entry.isTarget) continue;
       if (used + entry.tokens <= budget) {
         truncated.push(entry);
         used += entry.tokens;
       }
     }
-    return { entries: truncated, totalTokens: used, budget, filesAtL0: truncated.length, filesAtL1: 0 };
+    return {
+      entries: truncated,
+      totalTokens: used,
+      budget,
+      filesAtL0: truncated.filter((e) => e.layer === "L0").length,
+      filesAtL1: truncated.filter((e) => e.layer === "L1").length,
+      filesAtL3,
+      targetFile: targetPath ?? void 0,
+      targetDowngraded
+    };
   }
-  const upgradeOrder = entries.map((e, i) => ({ index: i, path: e.path, rawTokens: files[i].rawTokens, isHotspot: hotspotSet.has(e.path) })).sort((a, b) => {
+  const upgradeOrder = entries.map((e, i) => ({
+    index: i,
+    path: e.path,
+    rawTokens: files.find((f) => f.path === e.path)?.rawTokens ?? 0,
+    isHotspot: hotspotSet.has(e.path),
+    isRelated: relatedFiles.has(e.path),
+    isTarget: e.isTarget ?? false
+  })).filter((x) => x.isTarget === false && entries[x.index].layer === "L0").sort((a, b) => {
+    if (a.isRelated && !b.isRelated) return -1;
+    if (!a.isRelated && b.isRelated) return 1;
     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 file = files.find((f) => f.path === item.path);
     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;
+    const currentTokens = entries[item.index].tokens;
+    const additional = l1Tokens - currentTokens;
+    if (totalTokens + additional <= budget) {
+      entries[item.index] = {
+        path: item.path,
+        layer: "L1",
+        ir: l1,
+        tokens: l1Tokens
+      };
+      totalTokens += additional;
       filesAtL1++;
     }
   }
@@ -1142,8 +1507,11 @@ async function packContext(files, options) {
     entries,
     totalTokens,
     budget,
-    filesAtL0: entries.length - filesAtL1,
-    filesAtL1
+    filesAtL0: entries.filter((e) => e.layer === "L0").length,
+    filesAtL1,
+    filesAtL3,
+    targetFile: targetPath ?? void 0,
+    targetDowngraded
   };
 }
 

package/dist/index.js

@@ -12,7 +12,7 @@ import {
   packContext,
   runDetector,
   summarize
-} from "./chunk-MFNGSHTZ.js";
+} from "./chunk-AARGW2GV.js";
 
 // src/cli/commands.ts
 import { readFileSync, readdirSync } from "fs";
@@ -201,7 +201,7 @@ function collectFiles(dir, extensions) {
 function runScan(projectPath) {
   const adapter = new CLIAdapter();
   const config = loadConfig(projectPath);
-  console.log("composto v0.1.0 \u2014 scanning...\n");
+  console.log("composto v0.2.3 \u2014 scanning...\n");
   const files = collectFiles(projectPath, [".ts", ".tsx", ".js", ".jsx"]);
   console.log(`  Found ${files.length} files
 `);
@@ -228,7 +228,7 @@ function runScan(projectPath) {
 function runTrends(projectPath) {
   const adapter = new CLIAdapter();
   const config = loadConfig(projectPath);
-  console.log("composto v0.1.0 \u2014 trend analysis...\n");
+  console.log("composto v0.2.3 \u2014 trend analysis...\n");
   const entries = getGitLog(projectPath, 100);
   if (entries.length === 0) {
     console.log("  No git history found.\n");
@@ -270,7 +270,7 @@ async function runIR(projectPath, filePath, layer) {
 }
 var ALL_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".py", ".go", ".rs"];
 async function runBenchmark(projectPath) {
-  console.log("composto v0.1.0 \u2014 benchmark\n");
+  console.log("composto v0.2.3 \u2014 benchmark\n");
   const files = collectFiles(projectPath, ALL_EXTENSIONS);
   console.log(`  ${files.length} files
 `);
@@ -317,7 +317,7 @@ async function runBenchmarkQuality(projectPath, filePath) {
   }
   const code = readFileSync(filePath, "utf-8");
   const relPath = relative(projectPath, filePath);
-  console.log("composto v0.1.0 \u2014 quality benchmark\n");
+  console.log("composto v0.2.3 \u2014 quality benchmark\n");
   console.log(`  File: ${relPath}
 `);
   console.log("  Sending to Claude Haiku...\n");
@@ -346,9 +346,11 @@ ${result.ir.response}
     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)
-`);
+async function runContext(projectPath, budget, target) {
+  const header = target ? `composto v0.2.3 \u2014 context (target: ${target}, budget: ${budget} tokens)
+` : `composto v0.2.3 \u2014 context (budget: ${budget} tokens)
+`;
+  console.log(header);
   const files = collectFiles(projectPath, ALL_EXTENSIONS);
   console.log(`  ${files.length} files
 `);
@@ -363,13 +365,34 @@ async function runContext(projectPath, budget) {
     const relPath = relative(projectPath, file);
     return { path: relPath, code, rawTokens: estimateTokens(code) };
   });
-  const result = await packContext(fileInputs, { budget, hotspots });
+  const result = await packContext(fileInputs, { budget, hotspots, target });
+  if (target && !result.targetFile) {
+    console.log(`  Warning: symbol "${target}" not found in any file. Showing general context.
+`);
+  } else if (result.targetFile) {
+    console.log(`  Target: ${result.targetFile} (contains ${target})`);
+    if (result.targetDowngraded) {
+      console.log(`  Note: target file too large for raw mode \u2014 using L1 IR instead. Increase --budget for L3.`);
+    }
+    console.log();
+  }
+  const l3Entries = result.entries.filter((e) => e.layer === "L3");
   const l1Entries = result.entries.filter((e) => e.layer === "L1");
   const l0Entries = result.entries.filter((e) => e.layer === "L0");
+  if (l3Entries.length > 0) {
+    console.log("  == L3 (raw \u2014 target file) ==\n");
+    for (const entry of l3Entries) {
+      console.log(`  [target] ${entry.path}`);
+      for (const line of entry.ir.split("\n")) {
+        console.log(`    ${line}`);
+      }
+      console.log();
+    }
+  }
   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";
+      const label = entry.isTarget ? "target" : 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}`);
@@ -386,8 +409,12 @@ async function runContext(projectPath, budget) {
     }
     console.log();
   }
+  const parts = [];
+  if (result.filesAtL3 > 0) parts.push(`${result.filesAtL3} at L3 (raw)`);
+  if (result.filesAtL1 > 0) parts.push(`${result.filesAtL1} at L1`);
+  if (result.filesAtL0 > 0) parts.push(`${result.filesAtL0} at L0`);
   console.log(`  Budget: ${result.totalTokens}/${result.budget} tokens`);
-  console.log(`  Files: ${result.filesAtL1} at L1, ${result.filesAtL0} at L0`);
+  console.log(`  Files: ${parts.join(", ")}`);
 }
 
 // src/index.ts
@@ -430,24 +457,35 @@ switch (command) {
     break;
   }
   case "context": {
-    const projectPath = resolve(args[1] ?? ".");
-    const budgetFlag = args.indexOf("--budget");
-    const budget = budgetFlag !== -1 && args[budgetFlag + 1] ? parseInt(args[budgetFlag + 1], 10) : 4e3;
-    await runContext(projectPath, budget);
+    let parseFlag = function(name) {
+      const equalsForm = args.find((a) => a.startsWith(`--${name}=`));
+      if (equalsForm) return equalsForm.slice(name.length + 3);
+      const idx = args.indexOf(`--${name}`);
+      if (idx !== -1 && args[idx + 1]) return args[idx + 1];
+      return void 0;
+    };
+    parseFlag2 = parseFlag;
+    const projectPath = resolve(args[1] && !args[1].startsWith("--") ? args[1] : ".");
+    const budgetStr = parseFlag("budget");
+    const budget = budgetStr ? parseInt(budgetStr, 10) : 4e3;
+    const target = parseFlag("target");
+    await runContext(projectPath, budget, target);
     break;
   }
   case "version":
-    console.log("composto v0.1.0");
+    console.log("composto v0.2.3");
     break;
   default:
-    console.log("composto v0.1.0 \u2014 less tokens, more insight\n");
+    console.log("composto v0.2.3 \u2014 less tokens, more insight\n");
     console.log("Commands:");
-    console.log("  scan [path]          Scan codebase for issues");
-    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");
+    console.log("  scan [path]                           Scan codebase for issues");
+    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("  context [path] --target <symbol>      Target file as raw, surrounding as IR");
+    console.log("  version                               Show version");
     break;
 }
+var parseFlag2;

package/dist/mcp/server.js

@@ -12,7 +12,7 @@ import {
   packContext,
   runDetector,
   summarize
-} from "../chunk-MFNGSHTZ.js";
+} from "../chunk-AARGW2GV.js";
 
 // src/mcp/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -40,7 +40,7 @@ function collectFiles(dir, extensions) {
 }
 var server = new McpServer({
   name: "composto",
-  version: "0.1.2"
+  version: "0.2.3"
 });
 server.tool(
   "composto_ir",
@@ -112,12 +112,13 @@ server.tool(
 );
 server.tool(
   "composto_context",
-  "Pack maximum code context into a token budget. Hotspot files get detailed IR (L1), remaining files get structure only (L0). Use this when you need to understand a large codebase without exceeding context limits.",
+  "Pack maximum code context into a token budget. When target symbol is provided, its file is included as raw code (L3) while surrounding files get compressed IR. Perfect for 'fix this bug in X' or 'why does X return wrong value' \u2014 LLM sees exact code of target plus compressed context. Without target, hotspot files get L1, rest get L0.",
   {
     path: z.string().default(".").describe("Directory to pack"),
-    budget: z.number().default(4e3).describe("Maximum tokens to use")
+    budget: z.number().default(4e3).describe("Maximum tokens to use"),
+    target: z.string().optional().describe("Target symbol (function/class/variable name). Its file will be included as raw code for implementation tasks.")
   },
-  async ({ path, budget }) => {
+  async ({ path, budget, target }) => {
     const projectPath = resolve(path);
     const files = collectFiles(projectPath, ALL_EXTENSIONS);
     const config = loadConfig(projectPath);
@@ -131,11 +132,21 @@ server.tool(
       const relPath = relative(projectPath, file);
       return { path: relPath, code, rawTokens: estimateTokens(code) };
     });
-    const result = await packContext(fileInputs, { budget, hotspots });
-    const lines = [`Composto Context \u2014 ${result.totalTokens}/${result.budget} tokens
-`];
+    const result = await packContext(fileInputs, { budget, hotspots, target });
+    const lines = [`Composto Context \u2014 ${result.totalTokens}/${result.budget} tokens`];
+    if (target && result.targetFile) lines.push(`Target: ${target} in ${result.targetFile}`);
+    lines.push("");
+    const l3 = result.entries.filter((e) => e.layer === "L3");
     const l1 = result.entries.filter((e) => e.layer === "L1");
     const l0 = result.entries.filter((e) => e.layer === "L0");
+    if (l3.length > 0) {
+      lines.push("== L3 (raw \u2014 target file) ==\n");
+      for (const entry of l3) {
+        lines.push(`[target] ${entry.path}`);
+        lines.push(entry.ir);
+        lines.push("");
+      }
+    }
     if (l1.length > 0) {
       lines.push("== L1 (detailed) ==\n");
       for (const entry of l1) {
@@ -151,8 +162,12 @@ server.tool(
         lines.push(entry.ir);
       }
     }
+    const parts = [];
+    if (result.filesAtL3 > 0) parts.push(`${result.filesAtL3} at L3`);
+    if (result.filesAtL1 > 0) parts.push(`${result.filesAtL1} at L1`);
+    if (result.filesAtL0 > 0) parts.push(`${result.filesAtL0} at L0`);
     lines.push(`
-Files: ${result.filesAtL1} at L1, ${result.filesAtL0} at L0`);
+Files: ${parts.join(", ")}`);
     return {
       content: [{ type: "text", text: lines.join("\n") }]
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "composto-ai",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Proactive AI team companion — less tokens, more insight",
   "type": "module",
   "bin": {