codeimpact 0.3.0 → 0.3.1

package/dist/index.js

@@ -11109,7 +11109,7 @@ var init_token_budget = __esm({
 });
 
 // src/core/agents/generator.ts
-import { mkdirSync as mkdirSync17 } from "fs";
+import { existsSync as existsSync32, readFileSync as readFileSync26, mkdirSync as mkdirSync17 } from "fs";
 import { join as join33 } from "path";
 function generateProjectFiles(input) {
   const { projectPath, intelligence, technologies, features, index } = input;
@@ -11118,7 +11118,7 @@ function generateProjectFiles(input) {
   const result = { filesWritten: [], filesSkipped: [] };
   mkdirSync17(paths.projectDir, { recursive: true });
   const skillPath = join33(paths.projectDir, "SKILL.md");
-  writeMarkedFile2(skillPath, renderProjectSkill(intelligence, technologies, config2), config2, result, "project_skill");
+  writeMarkedFile2(skillPath, renderProjectSkill(intelligence, technologies, config2, projectPath), config2, result, "project_skill");
   const convPath = join33(paths.projectDir, "CONVENTIONS.md");
   writeMarkedFile2(convPath, renderConventions(intelligence, config2), config2, result, "project_conventions");
   const archPath = join33(paths.projectDir, "ARCHITECTURE.md");
@@ -11139,7 +11139,7 @@ function generateFeatureFiles(input) {
   }
   return result;
 }
-function renderProjectSkill(intel, technologies, config2) {
+function renderProjectSkill(intel, technologies, config2, projectPath) {
   const frontmatter = [
     "---",
     "name: project-overview",
@@ -11156,9 +11156,13 @@ function renderProjectSkill(intel, technologies, config2) {
   const lines = [];
   lines.push("## Tech Stack");
   if (technologies.length > 0) {
-    const topTechs = technologies.slice(0, 15);
-    for (const tech of topTechs) {
-      lines.push(`- ${tech.name} ${tech.version} (from ${tech.source})`);
+    const directDeps = filterDirectDependencies(technologies, projectPath);
+    if (directDeps.length > 0) {
+      for (const tech of directDeps.slice(0, 20)) {
+        lines.push(`- ${tech.name} ${tech.version}`);
+      }
+    } else {
+      lines.push(`- Languages: ${intel.codebase.languages.join(", ")}`);
     }
   } else {
     lines.push(`- Languages: ${intel.codebase.languages.join(", ")}`);
@@ -11186,7 +11190,9 @@ function renderProjectSkill(intel, technologies, config2) {
     }
   } else {
     for (const dir of intel.codebase.keyDirectories) {
-      lines.push(`| ${dir}/ | Source code |`);
+      const dirName = dir.split("/").pop() || dir;
+      const purpose = inferDirPurpose(dirName);
+      lines.push(`| ${dir}/ | ${purpose} |`);
     }
   }
   lines.push("");
@@ -11335,46 +11341,15 @@ function renderFeatureSkill(feature, technologies, config2) {
     lines.push("");
   }
   lines.push("## Rules");
-  if (technologies.length > 0) {
-    for (const tech of technologies) {
-      if (tech.name === "express") {
-        lines.push("- Use Router() for modular route definitions");
-        lines.push("- Always register error handler middleware last");
-      } else if (tech.name === "better-sqlite3") {
-        lines.push("- Use db.prepare().all() for SELECT, db.prepare().run() for INSERT/UPDATE/DELETE");
-        lines.push("- better-sqlite3 is synchronous \u2014 do NOT use async/await");
-      } else if (tech.name === "stripe") {
-        lines.push("- Always verify webhook signatures before processing events");
-        lines.push("- Use idempotency keys for payment creation");
-      } else if (tech.name === "jsonwebtoken") {
-        lines.push("- Always verify tokens before trusting decoded data");
-        lines.push("- Set explicit expiration times on all tokens");
-      } else {
-        lines.push(`- Follow ${tech.name} v${tech.version} API conventions`);
-      }
-    }
-  } else {
-    lines.push("- Follow project coding conventions for this feature");
+  const rules = deriveRules(feature, technologies);
+  for (const rule of rules) {
+    lines.push(`- ${rule}`);
   }
   lines.push("");
   lines.push("## Pitfalls");
-  if (technologies.length > 0) {
-    for (const tech of technologies) {
-      if (tech.name === "express") {
-        lines.push("- Forgetting to call next() in middleware causes request to hang");
-      } else if (tech.name === "better-sqlite3") {
-        lines.push("- db.exec() returns nothing \u2014 using it for SELECT gives undefined");
-      } else if (tech.name === "stripe") {
-        lines.push("- Stripe webhook events may arrive out of order \u2014 handle idempotently");
-      } else if (tech.name === "jsonwebtoken") {
-        lines.push("- Using jwt.decode() without verify() is a security vulnerability");
-      }
-    }
-    if (technologies.every((t) => !["express", "better-sqlite3", "stripe", "jsonwebtoken"].includes(t.name))) {
-      lines.push("- Check research docs for version-specific breaking changes");
-    }
-  } else {
-    lines.push("- Check for null/undefined before property access on external data");
+  const pitfalls = derivePitfalls(feature, technologies);
+  for (const pitfall of pitfalls) {
+    lines.push(`- ${pitfall}`);
   }
   lines.push("");
   return { frontmatter, autoContent: lines.join("\n") };
@@ -11424,15 +11399,296 @@ function parseAutoContentSections(autoContent) {
   }
   return sections;
 }
+function inferDirPurpose(dirName) {
+  const purposes = {
+    core: "Core business logic and domain modules",
+    server: "Server, transports, and request handling",
+    storage: "Database access and persistence",
+    indexing: "Code indexing and symbol extraction",
+    api: "API routes and handlers",
+    auth: "Authentication and authorization",
+    billing: "Payment processing",
+    test: "Tests and evaluation harness",
+    doc: "Documentation",
+    knowledge: "AI knowledge system",
+    cli: "Command-line interface",
+    base: "Base configuration and fixtures",
+    src: "Application source code",
+    lib: "Shared utilities"
+  };
+  return purposes[dirName.toLowerCase()] || `${dirName} module`;
+}
+function deriveRules(feature, technologies) {
+  const rules = [];
+  for (const tech of technologies) {
+    const knowledge = TECH_KNOWLEDGE[tech.name];
+    if (knowledge) {
+      rules.push(...knowledge.rules);
+    }
+  }
+  if (rules.length === 0) {
+    const featureRules = getFeatureNameRules(feature.name);
+    rules.push(...featureRules);
+  }
+  if (feature.paths.length > 0) {
+    const scope = feature.paths[0]?.replace("/**", "") || "";
+    rules.push(`Changes here should not import from other feature directories \u2014 keep ${scope} self-contained`);
+  }
+  return rules;
+}
+function derivePitfalls(feature, technologies) {
+  const pitfalls = [];
+  for (const tech of technologies) {
+    const knowledge = TECH_KNOWLEDGE[tech.name];
+    if (knowledge) {
+      pitfalls.push(...knowledge.pitfalls);
+    }
+  }
+  if (pitfalls.length === 0) {
+    const featurePitfalls = getFeatureNamePitfalls(feature.name);
+    pitfalls.push(...featurePitfalls);
+  }
+  return pitfalls;
+}
+function getFeatureNameRules(name) {
+  const rules = {
+    server: [
+      "All tool/resource handlers must validate inputs before processing",
+      "Return structured error responses \u2014 never throw raw errors to clients"
+    ],
+    storage: [
+      "All database access should go through this module \u2014 no direct imports elsewhere",
+      "Use transactions for multi-step operations to ensure consistency"
+    ],
+    indexing: [
+      "Index operations should be idempotent \u2014 reindexing same file produces same result",
+      "Handle parse errors gracefully \u2014 a broken file should not crash the indexer"
+    ],
+    core: [
+      "Core modules should have no side effects on import",
+      "Export types alongside functions for downstream consumers"
+    ],
+    test: [
+      "Tests should be deterministic \u2014 no reliance on external services or timing",
+      "Clean up temporary files and directories in afterEach/afterAll hooks"
+    ],
+    knowledge: [
+      "Skill files must follow the agentskills.io SKILL.md format",
+      "Generated content must use marker comments to preserve manual edits"
+    ],
+    doc: [
+      "Generated docs must be kept in sync with source code changes",
+      "Use relative paths for internal links"
+    ],
+    auth: [
+      "Never store plain-text passwords \u2014 use bcrypt or argon2",
+      "Validate and sanitize all user inputs before processing"
+    ],
+    api: [
+      "All endpoints must validate request bodies/params before processing",
+      "Return consistent error response shapes across all endpoints"
+    ]
+  };
+  return rules[name] || [
+    "Follow existing patterns in this module for consistency",
+    "Export public API from index.ts \u2014 keep internal helpers unexported"
+  ];
+}
+function getFeatureNamePitfalls(name) {
+  const pitfalls = {
+    server: [
+      "Unhandled promise rejections in handlers crash the process \u2014 always catch async errors",
+      "Adding middleware order matters \u2014 auth before route handlers"
+    ],
+    storage: [
+      "Forgetting to close database connections leaks file handles",
+      "Concurrent writes without transactions may cause data corruption"
+    ],
+    indexing: [
+      "Large files can cause out-of-memory \u2014 set size limits on parsed content",
+      "File paths must be normalized (forward slashes) for cross-platform compatibility"
+    ],
+    core: [
+      "Circular imports between core modules cause runtime errors \u2014 check dependency direction",
+      "Changing public API signatures breaks downstream consumers"
+    ],
+    test: [
+      "Tests sharing mutable state between runs cause flaky failures",
+      "Temp directories not cleaned up fill disk over repeated test runs"
+    ]
+  };
+  return pitfalls[name] || [
+    "Check for null/undefined before property access on external data",
+    "Changing exports may break other modules that depend on this feature"
+  ];
+}
 function capitalize(str) {
   return str.charAt(0).toUpperCase() + str.slice(1).replace(/-/g, " ");
 }
+function filterDirectDependencies(technologies, projectPath) {
+  const directNames = /* @__PURE__ */ new Set();
+  for (const tech of technologies) {
+    if (tech.source === "package.json") {
+      directNames.add(tech.name);
+    }
+  }
+  if (directNames.size === 0) {
+    const searchPaths = [
+      projectPath ? join33(projectPath, "package.json") : "",
+      join33(process.cwd(), "package.json")
+    ].filter(Boolean);
+    for (const p of searchPaths) {
+      try {
+        if (existsSync32(p)) {
+          const pkg = JSON.parse(readFileSync26(p, "utf-8"));
+          for (const d of Object.keys(pkg.dependencies || {})) directNames.add(d);
+          for (const d of Object.keys(pkg.devDependencies || {})) directNames.add(d);
+          break;
+        }
+      } catch {
+      }
+    }
+  }
+  const skipPatterns = [
+    /^@types\//,
+    /^@esbuild\//,
+    /^@rollup\//,
+    /^@swc\//,
+    /^@parcel\//,
+    /^@biomejs\//
+  ];
+  if (directNames.size > 0) {
+    return technologies.filter((t) => directNames.has(t.name)).filter((t) => !skipPatterns.some((p) => p.test(t.name)));
+  }
+  return technologies.filter((t) => !skipPatterns.some((p) => p.test(t.name))).slice(0, 20);
+}
+var TECH_KNOWLEDGE;
 var init_generator = __esm({
   "src/core/agents/generator.ts"() {
     "use strict";
     init_workspace2();
     init_marker_writer();
     init_token_budget();
+    TECH_KNOWLEDGE = {
+      "express": {
+        rules: [
+          "Use Router() for modular route definitions",
+          "Always register error handler middleware last (4 args: err, req, res, next)"
+        ],
+        pitfalls: [
+          "Forgetting to call next() in middleware causes request to hang",
+          "Async errors in handlers need explicit try/catch or express-async-errors"
+        ]
+      },
+      "hono": {
+        rules: [
+          "Use app.route() for modular route grouping",
+          "Return c.json() or c.text() \u2014 do not use res.send()"
+        ],
+        pitfalls: [
+          "Hono middleware must call next() or return a Response \u2014 skipping both hangs the request"
+        ]
+      },
+      "better-sqlite3": {
+        rules: [
+          "Use db.prepare().all() for SELECT, db.prepare().run() for INSERT/UPDATE/DELETE",
+          "better-sqlite3 is synchronous \u2014 do NOT use async/await with db calls",
+          "All database access should go through a single module"
+        ],
+        pitfalls: [
+          "db.exec() returns nothing \u2014 using it for SELECT gives undefined",
+          'WAL mode must be set once after opening: db.pragma("journal_mode = WAL")'
+        ]
+      },
+      "stripe": {
+        rules: [
+          "Always verify webhook signatures before processing events",
+          "Use idempotency keys for payment creation to prevent double-charges"
+        ],
+        pitfalls: [
+          "Stripe webhook events may arrive out of order \u2014 handle idempotently",
+          "stripe.webhooks.constructEvent() throws on invalid signature \u2014 wrap in try/catch"
+        ]
+      },
+      "jsonwebtoken": {
+        rules: [
+          "Always use jwt.verify() \u2014 never trust jwt.decode() alone",
+          "Set explicit expiration (expiresIn) on all tokens"
+        ],
+        pitfalls: [
+          "Using jwt.decode() without verify() is a security vulnerability",
+          'The "none" algorithm attack \u2014 always specify algorithms: ["HS256"]'
+        ]
+      },
+      "@modelcontextprotocol/sdk": {
+        rules: [
+          "Use server.tool() to register MCP tools with zod schema validation",
+          "All tool handlers must return { content: [...] } response objects"
+        ],
+        pitfalls: [
+          "Tool names must be unique across the server \u2014 duplicates silently overwrite",
+          "Forgetting to call server.connect(transport) means no requests are handled"
+        ]
+      },
+      "prisma": {
+        rules: [
+          "Run npx prisma generate after schema changes",
+          "Use transactions for multi-table operations: prisma.$transaction()"
+        ],
+        pitfalls: [
+          "Forgetting prisma generate after schema change causes type mismatches at runtime",
+          "N+1 queries \u2014 use include/select to eagerly load relations"
+        ]
+      },
+      "zod": {
+        rules: [
+          "Define schemas once, derive TypeScript types with z.infer<typeof schema>",
+          "Use .safeParse() in handlers for graceful error handling"
+        ],
+        pitfalls: [
+          ".parse() throws on invalid data \u2014 use .safeParse() in request handlers"
+        ]
+      },
+      "vitest": {
+        rules: [
+          "Use describe/it/expect patterns for test organization",
+          "Use vi.mock() for module mocking, vi.fn() for function stubs"
+        ],
+        pitfalls: [
+          "vi.mock() is hoisted to top of file \u2014 cannot access variables from outer scope"
+        ]
+      },
+      "web-tree-sitter": {
+        rules: [
+          "Initialize Parser with await Parser.init() before use",
+          "Load language WASM files with Parser.Language.load()"
+        ],
+        pitfalls: [
+          "Parser.init() must complete before any parsing \u2014 race condition if not awaited",
+          "WASM files must be bundled/copied to dist \u2014 not resolved from node_modules at runtime"
+        ]
+      },
+      "@xenova/transformers": {
+        rules: [
+          "Use pipeline() for high-level tasks, AutoModel for custom inference",
+          "Cache downloaded models by setting env.cacheDir"
+        ],
+        pitfalls: [
+          "First model load downloads weights (~100MB+) \u2014 cache for subsequent runs",
+          "ONNX runtime may fail on some architectures \u2014 test on target platform"
+        ]
+      },
+      "chokidar": {
+        rules: [
+          "Use chokidar.watch() with ignored patterns to skip node_modules",
+          'Handle both "add" and "change" events for file watching'
+        ],
+        pitfalls: [
+          "Not closing watcher on process exit leaks file handles",
+          "Rapid file changes may fire multiple events \u2014 debounce handlers"
+        ]
+      }
+    };
   }
 });
 
@@ -11842,7 +12098,7 @@ var init_lifecycle = __esm({
 });
 
 // src/core/agents/orchestrator.ts
-import { existsSync as existsSync34, readdirSync as readdirSync12 } from "fs";
+import { existsSync as existsSync34, readFileSync as readFileSync27, readdirSync as readdirSync12 } from "fs";
 import { join as join35, relative as relative9 } from "path";
 function agentsInit(projectPath) {
   const paths = initAgentWorkspace(projectPath);
@@ -11877,11 +12133,13 @@ async function agentsGenerate(options) {
   result.technologies = technologies.length;
   const importGraph = options.importGraph || /* @__PURE__ */ new Map();
   const indexedFiles = options.indexedFiles || getIndexedFilesFromFS(projectPath);
+  const fileTechMap = buildFileTechMap(projectPath, indexedFiles, technologies);
   const featureInput = {
     projectPath,
     config: config2.feature_detection,
     importGraph,
-    indexedFiles
+    indexedFiles,
+    fileTechMap
   };
   const features = detectFeatures(featureInput);
   result.features = features.length;
@@ -12099,30 +12357,55 @@ function filterTopTechnologies(technologies) {
   return technologies.filter((t) => !skipPatterns.some((p) => p.test(t.name))).filter((t) => t.source.includes("lock") || t.source === "package.json").slice(0, 20);
 }
 function createMinimalIntelligence(projectPath, technologies, features) {
+  const sourceFiles = getIndexedFilesFromFS(projectPath);
+  const codeFiles = sourceFiles.filter(
+    (f) => /\.(ts|tsx|js|jsx|py|go|rs|java|rb|php|cs|cpp|c|h)$/.test(f) && !f.includes("node_modules") && !f.includes("dist")
+  );
+  let totalLines = 0;
+  for (const f of codeFiles.slice(0, 500)) {
+    try {
+      const content = readFileSync27(join35(projectPath, f), "utf-8");
+      totalLines += content.split("\n").length;
+    } catch {
+    }
+  }
+  const extCounts = /* @__PURE__ */ new Map();
+  for (const f of codeFiles) {
+    const ext = f.split(".").pop() || "";
+    const lang = extToLanguage(ext);
+    if (lang) extCounts.set(lang, (extCounts.get(lang) || 0) + 1);
+  }
+  const languages = [...extCounts.entries()].sort((a, b) => b[1] - a[1]).map(([lang]) => lang);
+  const layers = features.map((f) => ({
+    name: f.name.charAt(0).toUpperCase() + f.name.slice(1),
+    directory: f.paths[0]?.replace("/**", "") || f.name,
+    purpose: inferLayerPurpose(f.name),
+    fileCount: f.fileCount
+  }));
+  const testFramework = detectTestFramework(projectPath);
   return {
     collectedAt: (/* @__PURE__ */ new Date()).toISOString(),
     codebase: {
-      fileCount: 0,
-      totalLines: 0,
-      languages: [...new Set(technologies.map((t) => {
-        if (t.source.includes("package")) return "typescript";
-        if (t.source.includes("Cargo")) return "rust";
-        if (t.source.includes("go.")) return "go";
-        if (t.source.includes("requirements") || t.source.includes("pyproject")) return "python";
-        return "unknown";
-      }))],
+      fileCount: codeFiles.length,
+      totalLines,
+      languages: languages.length > 0 ? languages : ["typescript"],
       keyDirectories: features.map((f) => f.paths[0]?.replace("/**", "") || ""),
       symbolCount: 0,
       description: "",
       architectureNotes: ""
     },
-    architecture: null,
+    architecture: {
+      layers,
+      dataFlow: inferDataFlow(features),
+      keyComponents: [],
+      functionStats: { total: 0, exported: 0 }
+    },
     dependencyHotspots: [],
     patterns: [],
     decisions: [],
     riskFiles: [],
     deadCode: null,
-    tests: { framework: "unknown", testCount: 0, coverageGaps: [], uncoveredFunctions: [] },
+    tests: { framework: testFramework, testCount: 0, coverageGaps: [], uncoveredFunctions: [] },
     recentBugs: [],
     changeHotspots: [],
     activeFeature: null,
@@ -12134,6 +12417,96 @@ function createMinimalIntelligence(projectPath, technologies, features) {
     }))
   };
 }
+function buildFileTechMap(projectPath, indexedFiles, technologies) {
+  const techNames = new Set(technologies.map((t) => t.name));
+  const fileTechMap = /* @__PURE__ */ new Map();
+  const sourceFiles = indexedFiles.filter(
+    (f) => /\.(ts|tsx|js|jsx)$/.test(f) && !f.includes("node_modules") && !f.includes("dist")
+  );
+  for (const file2 of sourceFiles.slice(0, 300)) {
+    try {
+      const content = readFileSync27(join35(projectPath, file2), "utf-8");
+      const techs = /* @__PURE__ */ new Set();
+      const importRegex = /(?:from\s+['"]|require\s*\(\s*['"])([^./'"@][^'"]*|@[^/'"]+\/[^'"]+)/g;
+      let match;
+      while ((match = importRegex.exec(content)) !== null) {
+        const pkg = match[1] || "";
+        const normalized = pkg.startsWith("@") ? pkg.split("/").slice(0, 2).join("/") : pkg.split("/")[0] || "";
+        if (normalized && techNames.has(normalized)) {
+          techs.add(normalized);
+        }
+      }
+      if (techs.size > 0) {
+        fileTechMap.set(file2, [...techs]);
+      }
+    } catch {
+    }
+  }
+  return fileTechMap;
+}
+function extToLanguage(ext) {
+  const map2 = {
+    ts: "typescript",
+    tsx: "typescript",
+    js: "javascript",
+    jsx: "javascript",
+    py: "python",
+    go: "go",
+    rs: "rust",
+    java: "java",
+    rb: "ruby",
+    php: "php",
+    cs: "c#",
+    cpp: "c++",
+    c: "c",
+    h: "c"
+  };
+  return map2[ext] || null;
+}
+function inferLayerPurpose(featureName) {
+  const purposes = {
+    core: "Core business logic and domain modules",
+    server: "MCP server, transports, and request handling",
+    storage: "Database access and persistence layer",
+    indexing: "Code indexing, parsing, and symbol extraction",
+    api: "API routes, handlers, and middleware",
+    auth: "Authentication and authorization",
+    billing: "Payment processing and subscription management",
+    test: "Test fixtures, harness, and evaluation scenarios",
+    doc: "Documentation generation and management",
+    knowledge: "AI knowledge system and skill management",
+    cli: "Command-line interface",
+    base: "Base configuration and shared utilities"
+  };
+  return purposes[featureName] || `${featureName} module`;
+}
+function inferDataFlow(features) {
+  const names = features.map((f) => f.name);
+  const flow = [];
+  if (names.includes("server") || names.includes("api")) flow.push("Request");
+  if (names.includes("server")) flow.push("Server");
+  if (names.includes("api")) flow.push("API");
+  if (names.includes("core")) flow.push("Core");
+  if (names.includes("storage")) flow.push("Storage");
+  if (names.includes("indexing")) flow.push("Indexer");
+  return flow.length >= 2 ? flow : [];
+}
+function detectTestFramework(projectPath) {
+  const pkgPath = join35(projectPath, "package.json");
+  if (existsSync34(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync27(pkgPath, "utf-8"));
+      const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (allDeps["vitest"]) return "vitest";
+      if (allDeps["jest"]) return "jest";
+      if (allDeps["mocha"]) return "mocha";
+      if (allDeps["tap"]) return "tap";
+      if (pkg.scripts?.test?.includes("--test")) return "node:test";
+    } catch {
+    }
+  }
+  return "unknown";
+}
 var init_orchestrator = __esm({
   "src/core/agents/orchestrator.ts"() {
     "use strict";
@@ -12153,7 +12526,7 @@ var init_orchestrator = __esm({
 
 // src/core/agents/migration.ts
 import { existsSync as existsSync35, readFileSync as readFileSync28, writeFileSync as writeFileSync20, mkdirSync as mkdirSync18, cpSync, readdirSync as readdirSync13 } from "fs";
-import { join as join36, relative as relative10, dirname as dirname14 } from "path";
+import { join as join36, relative as relative10, dirname as dirname15 } from "path";
 function migrateKnowledge(options) {
   const { projectPath, dryRun = false, backup = false } = options;
   const result = {
@@ -12195,7 +12568,7 @@ function migrateKnowledge(options) {
       continue;
     }
     if (!dryRun) {
-      mkdirSync18(dirname14(targetPath), { recursive: true });
+      mkdirSync18(dirname15(targetPath), { recursive: true });
       cpSync(skillFile, targetPath);
     }
     result.migrated.push({