@sdsrs/code-graph 0.19.0 → 0.20.0

package/claude-plugin/.claude-plugin/plugin.json

@@ -4,7 +4,7 @@
   "author": {
     "name": "sdsrs"
   },
-  "version": "0.19.0",
+  "version": "0.20.0",
   "keywords": [
     "code-graph",
     "ast",

package/claude-plugin/scripts/adopt.js

@@ -28,12 +28,234 @@ function readAdoptedBy(filePath) {
 // line is a structural fix, not a signal change. Decision table lives in the
 // linked plugin_code_graph_mcp.md; this line is the router. Tag syntax
 // `[tag1, tag2]` per spec for explicit keyword matching.
+//
+// Generic default — used when no project-type markers detected (e.g. /tmp,
+// scratch dirs, mixed repos). Per-type variants live in `buildIndexLine` and
+// are computed per-cwd at adopt + needsRefresh time. Adopted-project receives
+// the typed variant; everyone else falls back to this canonical line.
 const INDEX_LINE =
   '- [code-graph-mcp](plugin_code_graph_mcp.md) ' +
   '[impact, callgraph, refs, overview, semantic, ast-search, dead-code, similar, deps, trace] — ' +
   '改 X 影响面/谁调用 X/X 被谁用/看 X 源码/Y 模块长啥样/概念查询 优先于 Grep；字面匹配走 Grep。' +
   '核心 7（get_call_graph/module_overview/semantic_code_search/ast_search/find_references/get_ast_node/project_map）' +
   '+ 进阶 5（impact_analysis/trace_http_chain/dependency_graph/find_similar_code/find_dead_code），决策表见全文';
+
+// memdir L1 升格 (per sdscc 重构方案 §5.0): the INDEX_LINE that lands in
+// MEMORY.md is what Claude sees first on every keyword match. Tailoring it
+// per project type primes the right tools and demotes the irrelevant ones —
+// e.g. a Rust CLI never benefits from `trace_http_chain` priming, and a React
+// frontend cares more about `find_references` for rename audits than `impact`.
+//
+// Detection is cheap substring-on-marker (no AST, no graph): the cost is one
+// fs.readFileSync per cwd. Failure mode is silent fall-back to 'generic' —
+// false-negatives are strictly safer than false-positives that promote the
+// wrong tool.
+function readFileQuiet(p) {
+  try { return fs.readFileSync(p, 'utf8'); } catch { return ''; }
+}
+
+// Valid project type buckets — also serves as the allow-list for
+// `CODE_GRAPH_PROJECT_TYPE` env override. Anything not in this set falls back
+// to file-based detection (so a typo'd env var does not silently break).
+const PROJECT_TYPES = new Set([
+  'rust', 'web-rs', 'web-node', 'web-py', 'web-go',
+  'frontend', 'python', 'go', 'node', 'generic',
+]);
+
+// Cargo.toml: strip `# ...` comment lines (line-leading or trailing). Then
+// extract the contents of the [dependencies] section only — dev/build/target
+// deps don't characterize the project's runtime web-vs-cli posture.
+//
+// Why a state machine and not a TOML parser: we have zero deps and don't
+// want to add one for a coarse classification. This handles the >95% case
+// (well-formed [dependencies] block); pathological TOML (e.g. inline-table
+// dependencies) falls through to false-negative `rust` which is safer than
+// false-positive `web-rs`.
+function extractCargoRuntimeDeps(cargo) {
+  const lines = cargo.split(/\r?\n/);
+  const out = [];
+  let inDeps = false;
+  for (const raw of lines) {
+    // Strip `# comment` (line-leading or trailing). Inside string literals
+    // `#` is rare in Cargo dep specs; accept the false-strip risk.
+    const line = raw.replace(/(^|\s)#.*$/, '$1').trim();
+    if (line.startsWith('[')) {
+      // New section heading — only `[dependencies]` (canonical, exact match)
+      // gates web-framework detection. `[dev-dependencies]`,
+      // `[build-dependencies]`, `[target.'...'.dependencies]` deliberately
+      // skipped: a project that pulls in axum only for tests is not a web
+      // project for routing purposes.
+      inDeps = (line === '[dependencies]');
+      continue;
+    }
+    if (inDeps && line) out.push(line);
+  }
+  return out.join('\n');
+}
+
+// pyproject.toml: same pattern as Cargo.toml — strip comments, scan only
+// [tool.poetry.dependencies] (Poetry) or [project.dependencies] (PEP 621).
+function extractPyRuntimeDeps(pyproj) {
+  const lines = pyproj.split(/\r?\n/);
+  const out = [];
+  let inDeps = false;
+  for (const raw of lines) {
+    const line = raw.replace(/(^|\s)#.*$/, '$1').trim();
+    if (line.startsWith('[')) {
+      inDeps = (
+        line === '[tool.poetry.dependencies]' ||
+        line === '[project.dependencies]' ||
+        line === '[project]'  // PEP 621 inline `dependencies = [...]` lives here
+      );
+      continue;
+    }
+    if (inDeps && line) out.push(line);
+  }
+  return out.join('\n');
+}
+
+// go.mod: skip `// indirect` lines (transitive deps) and `// comment` lines.
+// Direct require blocks are what matter for "is this a web service?" — a
+// project that transitively pulls gin via a CLI dep is still a CLI.
+function extractGoDirectRequires(gomod) {
+  const lines = gomod.split(/\r?\n/);
+  const out = [];
+  let inRequire = false;
+  for (const raw of lines) {
+    const trimmed = raw.trim();
+    if (trimmed.startsWith('//')) continue;       // pure comment line
+    if (/\/\/\s*indirect\b/.test(raw)) continue;  // indirect dep marker
+    if (trimmed === 'require (') { inRequire = true; continue; }
+    if (inRequire && trimmed === ')') { inRequire = false; continue; }
+    if (trimmed.startsWith('require ')) out.push(trimmed.slice(8).trim());
+    else if (inRequire && trimmed) out.push(trimmed);
+  }
+  return out.join('\n');
+}
+
+function detectProjectType(cwd = process.cwd(), env = process.env) {
+  // 2D: env override beats file-based detection. Honors only valid bucket
+  // names; invalid override silently falls through to detection (avoids a
+  // typo'd env var silently classifying everything as 'generic'). Power
+  // users / CI can pin without touching the heuristics.
+  const override = env && env.CODE_GRAPH_PROJECT_TYPE;
+  if (override && PROJECT_TYPES.has(override)) {
+    return override;
+  }
+
+  const cargo = readFileQuiet(path.join(cwd, 'Cargo.toml'));
+  if (cargo) {
+    const deps = extractCargoRuntimeDeps(cargo);
+    // Web-framework detection: match on the dep name token (start-of-line
+    // or after whitespace/quote) to avoid hits inside path strings or
+    // unrelated metadata. `hyper` deliberately omitted from web-rs — it is
+    // also commonly used as a plain HTTP client in CLI tools (false-positive
+    // risk too high). axum/actix-web/etc. are unambiguous server stacks.
+    if (/^(actix-web|axum|rocket|warp|poem|tide|salvo)\s*=/m.test(deps)) {
+      return 'web-rs';
+    }
+    return 'rust';
+  }
+
+  const pkgRaw = readFileQuiet(path.join(cwd, 'package.json'));
+  if (pkgRaw) {
+    let pkg = null;
+    try { pkg = JSON.parse(pkgRaw); } catch { /* malformed → fall through */ }
+    if (pkg && typeof pkg === 'object') {
+      // Only `dependencies` matters — devDependencies are build/test only,
+      // and a project with `react` only in devDependencies is likely a
+      // component library, not a frontend app.
+      const deps = pkg.dependencies && typeof pkg.dependencies === 'object'
+        ? Object.keys(pkg.dependencies)
+        : [];
+      const has = (name) => deps.includes(name);
+      if (has('next') || has('react') || has('vue') || has('svelte') ||
+          has('@angular/core') || has('nuxt') || has('astro') ||
+          has('remix') || has('solid-js')) {
+        return 'frontend';
+      }
+      if (has('express') || has('fastify') || has('koa') || has('hono') ||
+          has('@nestjs/core') || has('@hapi/hapi')) {
+        return 'web-node';
+      }
+    }
+    return 'node';
+  }
+
+  const pyproj = readFileQuiet(path.join(cwd, 'pyproject.toml'));
+  if (pyproj) {
+    const deps = extractPyRuntimeDeps(pyproj);
+    if (/\b(django|flask|fastapi|starlette|sanic|tornado|quart)\b/i.test(deps)) {
+      return 'web-py';
+    }
+    return 'python';
+  }
+  // requirements.txt fallback: line-format `pkg==ver` / `pkg>=ver`. Strip
+  // `#` comment lines; scan remaining as a flat list (no section headers
+  // in this format).
+  const reqs = readFileQuiet(path.join(cwd, 'requirements.txt'));
+  if (reqs) {
+    const cleaned = reqs.split(/\r?\n/)
+      .map(l => l.replace(/(^|\s)#.*$/, '$1').trim())
+      .filter(Boolean)
+      .join('\n');
+    if (/^(django|flask|fastapi|starlette|sanic|tornado|quart)\b/im.test(cleaned)) {
+      return 'web-py';
+    }
+    return 'python';
+  }
+
+  const gomod = readFileQuiet(path.join(cwd, 'go.mod'));
+  if (gomod) {
+    const direct = extractGoDirectRequires(gomod);
+    if (/\b(gin-gonic|labstack\/echo|gofiber|go-chi|gorilla\/mux)\b/.test(direct)) {
+      return 'web-go';
+    }
+    return 'go';
+  }
+  return 'generic';
+}
+
+// Build the MEMORY.md index line for a project type. The 'generic' bucket
+// returns the canonical INDEX_LINE so untyped projects (and the existing
+// adopt.test.js fixtures, which use empty tmp dirs) stay byte-identical.
+//
+// For typed projects, the difference from generic is the tag set + the lead
+// sentence — body of plugin_code_graph_mcp.md is unchanged. Decision table
+// stays one source of truth; the index line just primes which subset matters
+// most for THIS project.
+function buildIndexLine(projectType = 'generic') {
+  const prefix = '- [code-graph-mcp](plugin_code_graph_mcp.md) ';
+  const coreSuffix =
+    '核心 7（get_call_graph/module_overview/semantic_code_search/ast_search/find_references/get_ast_node/project_map）' +
+    '+ 进阶 5（impact_analysis/trace_http_chain/dependency_graph/find_similar_code/find_dead_code），决策表见全文';
+  switch (projectType) {
+    case 'web-rs':
+    case 'web-node':
+    case 'web-py':
+    case 'web-go':
+      return prefix +
+        '[trace, route, callgraph, impact, refs, overview, semantic, deps] — ' +
+        'HTTP 路由→handler 链路用 trace_http_chain（或 get_call_graph route_path=）；改 handler 影响面用 impact；' +
+        '其他结构化查询同上 优先于 Grep。' + coreSuffix;
+    case 'frontend':
+      return prefix +
+        '[refs, overview, semantic, callgraph, impact, ast-search] — ' +
+        '组件重命名/重构用 find_references（含 imports/inherits）；模块层级用 module_overview；' +
+        '改 props/接口前用 impact 看下游；HTTP route 通常不适用。' + coreSuffix;
+    case 'rust':
+    case 'go':
+    case 'python':
+    case 'node':
+      return prefix +
+        '[callgraph, impact, refs, overview, semantic, ast-search, dead-code, deps] — ' +
+        '改 X 影响面/谁调用 X/Y 模块 优先于 Grep；HTTP route 追踪通常不适用（无 web 框架）；' +
+        '字面匹配走 Grep。' + coreSuffix;
+    case 'generic':
+    default:
+      return INDEX_LINE;
+  }
+}
 const TEMPLATE_PATH = path.resolve(__dirname, '..', 'templates', 'plugin_code_graph_mcp.md');
 const TARGET_NAME = 'plugin_code_graph_mcp.md';
 
@@ -126,7 +348,11 @@ function adopt({ cwd, home, templatePath } = {}) {
 
   const indexPath = path.join(dir, 'MEMORY.md');
   const index = fs.existsSync(indexPath) ? fs.readFileSync(indexPath, 'utf8') : '# Memory Index\n';
-  const desiredBlock = `${SENTINEL_BEGIN}\n${INDEX_LINE}\n${SENTINEL_END}`;
+  // Per-project index line: tagged tools + lead sentence tailored to the
+  // detected project type. Falls back to the canonical INDEX_LINE for
+  // generic / untyped cwds (preserves byte-identity with prior versions).
+  const indexLine = buildIndexLine(detectProjectType(effectiveCwd));
+  const desiredBlock = `${SENTINEL_BEGIN}\n${indexLine}\n${SENTINEL_END}`;
 
   // Already-adopted-and-well-formed: skip the write entirely.
   if (index.includes(desiredBlock)) {
@@ -175,7 +401,13 @@ function needsRefresh({ cwd, home, templatePath } = {}) {
   }
   if (!shipped.equals(body)) return true;
   const index = fs.readFileSync(indexPath, 'utf8');
-  const desiredBlock = `${SENTINEL_BEGIN}\n${INDEX_LINE}\n${SENTINEL_END}`;
+  // Compare against the typed INDEX_LINE for this project. Detection is
+  // deterministic (file-existence + substring scan) so adopt and needsRefresh
+  // always agree on the variant. Drift triggers refresh — including when a
+  // project gains a web framework dep and switches type bucket.
+  const effectiveCwd = cwd || process.cwd();
+  const indexLine = buildIndexLine(detectProjectType(effectiveCwd));
+  const desiredBlock = `${SENTINEL_BEGIN}\n${indexLine}\n${SENTINEL_END}`;
   return !index.includes(desiredBlock);
 }
 
@@ -294,6 +526,8 @@ if (require.main === module) {
 module.exports = {
   adopt, unadopt, memoryDir, formatResult, stripSentinelBlock,
   isAdopted, isPluginModeInstall, maybeAutoAdopt, needsRefresh, isProjectRoot,
+  detectProjectType, buildIndexLine,
+  extractCargoRuntimeDeps, extractPyRuntimeDeps, extractGoDirectRequires,
   SENTINEL_BEGIN, SENTINEL_END, INDEX_LINE, TEMPLATE_PATH, TARGET_NAME,
-  PROJECT_MARKERS,
+  PROJECT_MARKERS, PROJECT_TYPES,
 };

package/claude-plugin/scripts/adopt.test.js

@@ -7,6 +7,7 @@ const os = require('os');
 const {
   adopt, unadopt, memoryDir, stripSentinelBlock,
   isAdopted, isPluginModeInstall, maybeAutoAdopt, needsRefresh, isProjectRoot,
+  detectProjectType, buildIndexLine,
   SENTINEL_BEGIN, SENTINEL_END, INDEX_LINE, TEMPLATE_PATH, TARGET_NAME,
   PROJECT_MARKERS,
 } = require('./adopt');
@@ -585,3 +586,234 @@ test('needsRefresh ignores the adopted-by marker when bytewise comparing', () =>
       'needsRefresh should be false right after adopt — marker must not trigger drift');
   } finally { sb.cleanup(); }
 });
+
+// memdir L1 升格 — project-typed INDEX_LINE coverage.
+
+test('detectProjectType returns generic for an empty cwd', () => {
+  const sb = makeSandbox();
+  try {
+    assert.strictEqual(detectProjectType(sb.cwd), 'generic');
+  } finally { sb.cleanup(); }
+});
+
+test('detectProjectType returns rust for a Cargo.toml without web framework', () => {
+  const sb = makeSandbox();
+  try {
+    fs.writeFileSync(path.join(sb.cwd, 'Cargo.toml'), '[package]\nname="x"\n[dependencies]\nserde="1"\n');
+    assert.strictEqual(detectProjectType(sb.cwd), 'rust');
+  } finally { sb.cleanup(); }
+});
+
+test('detectProjectType returns web-rs when Cargo.toml has axum/actix/etc', () => {
+  const sb = makeSandbox();
+  try {
+    fs.writeFileSync(path.join(sb.cwd, 'Cargo.toml'), '[dependencies]\naxum = "0.7"\n');
+    assert.strictEqual(detectProjectType(sb.cwd), 'web-rs');
+  } finally { sb.cleanup(); }
+});
+
+test('detectProjectType returns frontend for package.json with React/Next/Vue', () => {
+  const sb = makeSandbox();
+  try {
+    fs.writeFileSync(path.join(sb.cwd, 'package.json'),
+      '{"dependencies":{"next":"^14","react":"^18"}}');
+    assert.strictEqual(detectProjectType(sb.cwd), 'frontend');
+  } finally { sb.cleanup(); }
+});
+
+test('detectProjectType returns web-node for package.json with express/fastify', () => {
+  const sb = makeSandbox();
+  try {
+    fs.writeFileSync(path.join(sb.cwd, 'package.json'),
+      '{"dependencies":{"express":"^4"}}');
+    assert.strictEqual(detectProjectType(sb.cwd), 'web-node');
+  } finally { sb.cleanup(); }
+});
+
+test('detectProjectType returns web-py for FastAPI in pyproject.toml', () => {
+  const sb = makeSandbox();
+  try {
+    fs.writeFileSync(path.join(sb.cwd, 'pyproject.toml'),
+      '[tool.poetry.dependencies]\nfastapi = "^0.115"\n');
+    assert.strictEqual(detectProjectType(sb.cwd), 'web-py');
+  } finally { sb.cleanup(); }
+});
+
+test('buildIndexLine generic returns the canonical INDEX_LINE byte-for-byte', () => {
+  // Critical: keeps backward compatibility with adopted projects that have no
+  // markers. Any drift here invalidates needsRefresh's idempotency assumption.
+  assert.strictEqual(buildIndexLine('generic'), INDEX_LINE);
+  assert.strictEqual(buildIndexLine(undefined), INDEX_LINE);
+});
+
+test('buildIndexLine web-rs prepends route/trace tags + handler-focused lead', () => {
+  const line = buildIndexLine('web-rs');
+  assert.match(line, /\[trace, route,/, 'web-rs index line should lead with trace/route tags');
+  assert.match(line, /HTTP 路由/, 'lead sentence should mention HTTP routes');
+});
+
+test('buildIndexLine frontend emphasizes refs/overview, drops HTTP route priming', () => {
+  const line = buildIndexLine('frontend');
+  assert.match(line, /组件重命名|find_references/, 'frontend should mention rename audit / refs');
+  assert.match(line, /HTTP route 通常不适用/, 'frontend should explicitly demote HTTP route tracing');
+});
+
+test('adopt + needsRefresh agree on typed INDEX_LINE — no spurious refresh in a Rust project', () => {
+  // The detection function is deterministic + adopt and needsRefresh both call
+  // it; together they must produce a consistent indexLine, otherwise every
+  // SessionStart triggers a rewrite.
+  const sb = makeSandbox();
+  try {
+    fs.writeFileSync(path.join(sb.cwd, 'Cargo.toml'), '[package]\nname="x"\n');
+    adopt({ cwd: sb.cwd, home: sb.home });
+    assert.strictEqual(needsRefresh({ cwd: sb.cwd, home: sb.home }), false,
+      'needsRefresh must be false right after adopt for a Rust project');
+    const indexPath = path.join(sb.dir, 'MEMORY.md');
+    const index = fs.readFileSync(indexPath, 'utf8');
+    assert.ok(index.includes('优先于 Grep'),
+      'MEMORY.md should contain the rust-typed index line');
+  } finally { sb.cleanup(); }
+});
+
+// 2A — false-positive hardening: comment-strip + section-aware scan.
+
+test('detectProjectType ignores commented-out web-framework deps in Cargo.toml', () => {
+  // Pre-fix: `# axum = "0.7"` substring-matched and falsely promoted to web-rs.
+  // Post-fix: comment stripping happens before section scan.
+  const sb = makeSandbox();
+  try {
+    fs.writeFileSync(path.join(sb.cwd, 'Cargo.toml'),
+      '[package]\nname="x"\n[dependencies]\n# axum = "0.7"  # disabled, was for prototype\nserde = "1"\n');
+    assert.strictEqual(detectProjectType(sb.cwd), 'rust',
+      'commented dep must not promote to web-rs');
+  } finally { sb.cleanup(); }
+});
+
+test('detectProjectType ignores axum in [dev-dependencies] only', () => {
+  // axum used solely for tests does not make this a web project.
+  const sb = makeSandbox();
+  try {
+    fs.writeFileSync(path.join(sb.cwd, 'Cargo.toml'),
+      '[package]\nname="x"\n[dependencies]\nserde = "1"\n[dev-dependencies]\naxum = "0.7"\n');
+    assert.strictEqual(detectProjectType(sb.cwd), 'rust',
+      'axum in dev-dependencies must not promote to web-rs');
+  } finally { sb.cleanup(); }
+});
+
+test('detectProjectType ignores axum in [build-dependencies] only', () => {
+  const sb = makeSandbox();
+  try {
+    fs.writeFileSync(path.join(sb.cwd, 'Cargo.toml'),
+      '[package]\nname="x"\n[dependencies]\nserde = "1"\n[build-dependencies]\naxum = "0.7"\n');
+    assert.strictEqual(detectProjectType(sb.cwd), 'rust',
+      'axum in build-dependencies must not promote to web-rs');
+  } finally { sb.cleanup(); }
+});
+
+test('detectProjectType ignores react in devDependencies of package.json', () => {
+  // A library that lists react in devDependencies for testing should not
+  // be classified as a frontend app.
+  const sb = makeSandbox();
+  try {
+    fs.writeFileSync(path.join(sb.cwd, 'package.json'),
+      JSON.stringify({
+        dependencies: { lodash: '^4' },
+        devDependencies: { react: '^18', 'react-dom': '^18' },
+      }));
+    assert.strictEqual(detectProjectType(sb.cwd), 'node',
+      'react in devDependencies must not promote to frontend');
+  } finally { sb.cleanup(); }
+});
+
+test('detectProjectType ignores // indirect deps in go.mod', () => {
+  const sb = makeSandbox();
+  try {
+    fs.writeFileSync(path.join(sb.cwd, 'go.mod'),
+      'module example.com/x\n\nrequire (\n\tgithub.com/some/cli v1.0.0\n\tgithub.com/gin-gonic/gin v1.9.0 // indirect\n)\n');
+    assert.strictEqual(detectProjectType(sb.cwd), 'go',
+      'indirect gin must not promote to web-go');
+  } finally { sb.cleanup(); }
+});
+
+test('detectProjectType handles malformed package.json without throwing', () => {
+  // JSON.parse failure must not crash detection; falls back to 'node' since
+  // package.json exists but is unreadable.
+  const sb = makeSandbox();
+  try {
+    fs.writeFileSync(path.join(sb.cwd, 'package.json'), '{not valid json');
+    assert.strictEqual(detectProjectType(sb.cwd), 'node',
+      'malformed package.json should fall back to node bucket');
+  } finally { sb.cleanup(); }
+});
+
+test('detectProjectType detects PEP 621 [project] dependencies block', () => {
+  // PEP 621 puts `dependencies = [...]` inside [project], not a separate
+  // [project.dependencies] section — our state machine accepts both.
+  const sb = makeSandbox();
+  try {
+    fs.writeFileSync(path.join(sb.cwd, 'pyproject.toml'),
+      '[project]\nname = "x"\ndependencies = ["fastapi>=0.115", "uvicorn"]\n');
+    assert.strictEqual(detectProjectType(sb.cwd), 'web-py');
+  } finally { sb.cleanup(); }
+});
+
+test('detectProjectType reads requirements.txt as fallback', () => {
+  const sb = makeSandbox();
+  try {
+    fs.writeFileSync(path.join(sb.cwd, 'requirements.txt'),
+      '# web stack\nflask>=3.0\ngunicorn\n');
+    assert.strictEqual(detectProjectType(sb.cwd), 'web-py');
+  } finally { sb.cleanup(); }
+});
+
+// 2D — env override.
+
+test('CODE_GRAPH_PROJECT_TYPE env override beats file-based detection', () => {
+  const sb = makeSandbox();
+  try {
+    // Cargo.toml says rust — env says web-rs. Env wins.
+    fs.writeFileSync(path.join(sb.cwd, 'Cargo.toml'), '[package]\nname="x"\n');
+    assert.strictEqual(
+      detectProjectType(sb.cwd, { CODE_GRAPH_PROJECT_TYPE: 'web-rs' }),
+      'web-rs',
+    );
+  } finally { sb.cleanup(); }
+});
+
+test('CODE_GRAPH_PROJECT_TYPE env override falls through on invalid value', () => {
+  // Typo'd / unknown bucket name should not silently classify everything as
+  // 'generic' — fall through to file-based detection so the project still
+  // gets a meaningful index line.
+  const sb = makeSandbox();
+  try {
+    fs.writeFileSync(path.join(sb.cwd, 'Cargo.toml'), '[package]\nname="x"\n');
+    assert.strictEqual(
+      detectProjectType(sb.cwd, { CODE_GRAPH_PROJECT_TYPE: 'web-rust' /* typo */ }),
+      'rust',
+      'invalid override must fall through to file detection',
+    );
+  } finally { sb.cleanup(); }
+});
+
+test('CODE_GRAPH_PROJECT_TYPE env override unset uses file detection', () => {
+  // Empty env reaches file-based detection unchanged.
+  const sb = makeSandbox();
+  try {
+    fs.writeFileSync(path.join(sb.cwd, 'Cargo.toml'), '[package]\nname="x"\n');
+    assert.strictEqual(detectProjectType(sb.cwd, {}), 'rust');
+  } finally { sb.cleanup(); }
+});
+
+test('CODE_GRAPH_PROJECT_TYPE env override forces generic in a Rust project', () => {
+  // Power-user case: explicit opt-out of typed routing for a project that
+  // would otherwise be auto-classified.
+  const sb = makeSandbox();
+  try {
+    fs.writeFileSync(path.join(sb.cwd, 'Cargo.toml'),
+      '[package]\nname="x"\n[dependencies]\naxum = "0.7"\n');
+    assert.strictEqual(
+      detectProjectType(sb.cwd, { CODE_GRAPH_PROJECT_TYPE: 'generic' }),
+      'generic',
+    );
+  } finally { sb.cleanup(); }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdsrs/code-graph",
-  "version": "0.19.0",
+  "version": "0.20.0",
   "description": "MCP server that indexes codebases into an AST knowledge graph with semantic search, call graph traversal, and HTTP route tracing",
   "license": "MIT",
   "repository": {
@@ -35,10 +35,10 @@
     "node": ">=16"
   },
   "optionalDependencies": {
-    "@sdsrs/code-graph-linux-x64": "0.19.0",
-    "@sdsrs/code-graph-linux-arm64": "0.19.0",
-    "@sdsrs/code-graph-darwin-x64": "0.19.0",
-    "@sdsrs/code-graph-darwin-arm64": "0.19.0",
-    "@sdsrs/code-graph-win32-x64": "0.19.0"
+    "@sdsrs/code-graph-linux-x64": "0.20.0",
+    "@sdsrs/code-graph-linux-arm64": "0.20.0",
+    "@sdsrs/code-graph-darwin-x64": "0.20.0",
+    "@sdsrs/code-graph-darwin-arm64": "0.20.0",
+    "@sdsrs/code-graph-win32-x64": "0.20.0"
   }
 }