@danielblomma/cortex-mcp 0.6.4 → 1.0.0

package/README.md

@@ -131,6 +131,59 @@ Codex (`~/.config/codex/mcp-config.json`):
 }
 ```
 
+## WSL Mode (Windows)
+
+If you run Node.js inside WSL but use Claude Desktop or another MCP client on Windows:
+
+1. Install Cortex inside WSL:
+
+```bash
+# In a WSL terminal
+npm i -g @danielblomma/cortex-mcp
+cd /mnt/c/Users/yourname/your-project
+cortex init --bootstrap
+```
+
+2. Configure Claude Desktop (`%APPDATA%\Claude\claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "cortex": {
+      "command": "wsl.exe",
+      "args": ["--distribution", "Ubuntu", "--exec", "cortex", "mcp"],
+      "env": {
+        "CORTEX_PROJECT_ROOT": "C:\\Users\\yourname\\your-project",
+        "CORTEX_AUTO_BOOTSTRAP_ON_MCP": "1"
+      }
+    }
+  }
+}
+```
+
+Cortex automatically converts Windows paths (e.g. `C:\Users\...`) to WSL paths (`/mnt/c/Users/...`).
+
+For projects on the WSL filesystem (e.g. `~/projects/myapp`), use the WSL path directly:
+
+```json
+{
+  "mcpServers": {
+    "cortex": {
+      "command": "wsl.exe",
+      "args": ["--distribution", "Ubuntu", "--exec", "cortex", "mcp"],
+      "env": {
+        "CORTEX_PROJECT_ROOT": "/home/yourname/projects/myapp",
+        "CORTEX_AUTO_BOOTSTRAP_ON_MCP": "1"
+      }
+    }
+  }
+}
+```
+
+**Notes:**
+- File watching on `/mnt/` paths (Windows filesystem) automatically uses poll mode since `inotify` is unreliable across filesystem boundaries.
+- For best performance, keep projects on the WSL filesystem (`~/...`) rather than `/mnt/c/...`.
+
 ## MCP Tools
 
 ### `context.search`
@@ -154,6 +207,40 @@ Input:
 - `depth` (int, 1-3, default `1`)
 - `include_edges` (bool, default `true`)
 
+### `context.find_callers`
+
+Return chunk callers for a chunk or file entity using the indexed call graph.
+
+Input:
+
+- `entity_id` (string, required)
+- `depth` (int, 1-4, default `1`)
+- `include_edges` (bool, default `true`)
+
+### `context.trace_calls`
+
+Trace call graph neighbors from a chunk or file entity in the requested direction.
+
+Input:
+
+- `entity_id` (string, required)
+- `depth` (int, 1-4, default `2`)
+- `direction` (`"outgoing"` | `"incoming"` | `"both"`, default `"outgoing"`)
+- `include_edges` (bool, default `true`)
+
+### `context.impact_analysis`
+
+Analyze likely impacted call-graph entities starting from an entity id or search query.
+
+Input:
+
+- `entity_id` (string, optional) — either `entity_id` or `query` is required
+- `query` (string, optional)
+- `depth` (int, 1-4, default `2`)
+- `top_k` (int, 1-20, default `8`)
+- `direction` (`"incoming"` | `"outgoing"` | `"both"`, default `"incoming"`)
+- `include_edges` (bool, default `true`)
+
 ### `context.get_rules`
 
 List indexed rules and optionally include inactive rules.

package/bin/cortex.mjs

@@ -3,6 +3,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { spawn } from "node:child_process";
+import { normalizeProjectRoot } from "./wsl.mjs";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -599,9 +600,9 @@ async function run() {
   }
 
   if (command === "mcp") {
-    const target = process.env.CORTEX_PROJECT_ROOT
-      ? path.resolve(process.env.CORTEX_PROJECT_ROOT)
-      : process.cwd();
+    const rawTarget = process.env.CORTEX_PROJECT_ROOT || process.cwd();
+    const target = path.resolve(normalizeProjectRoot(rawTarget));
+    process.env.CORTEX_PROJECT_ROOT = target;
     await ensureProjectInitializedForMcp(target);
     ensureProjectInitialized(target);
     const serverEntry = path.join(target, "mcp", "dist", "server.js");

package/bin/wsl.mjs

@@ -0,0 +1,30 @@
+import fs from "node:fs";
+
+let _isWSL = null;
+
+export function isWSL() {
+  if (_isWSL !== null) return _isWSL;
+  try {
+    const version = fs.readFileSync("/proc/version", "utf8");
+    _isWSL = /microsoft|wsl/i.test(version);
+  } catch {
+    _isWSL = false;
+  }
+  return _isWSL;
+}
+
+export function windowsToWslPath(winPath) {
+  const match = winPath.match(/^([A-Za-z]):[/\\](.*)/);
+  if (!match) return winPath;
+  const drive = match[1].toLowerCase();
+  const rest = match[2].replace(/\\/g, "/").replace(/\/+$/, "");
+  return `/mnt/${drive}/${rest}`;
+}
+
+export function normalizeProjectRoot(rawPath) {
+  if (!isWSL()) return rawPath;
+  if (/^[A-Za-z]:[/\\]/.test(rawPath)) {
+    return windowsToWslPath(rawPath);
+  }
+  return rawPath;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@danielblomma/cortex-mcp",
   "mcpName": "io.github.DanielBlomma/cortex",
-  "version": "0.6.4",
+  "version": "1.0.0",
   "description": "Local, repo-scoped context platform for coding assistants. Semantic search, graph relationships, and architectural rule context.",
   "type": "module",
   "author": "Daniel Blomma",

package/scaffold/mcp/package.json

@@ -20,7 +20,8 @@
   "overrides": {
     "cmake-js": "^8.0.0",
     "express-rate-limit": "^8.3.1",
-    "hono": "^4.12.7",
+    "hono": "^4.12.12",
+    "@hono/node-server": "^1.19.13",
     "tar": "^7.5.11"
   },
   "devDependencies": {

package/scaffold/mcp/src/paths.ts

@@ -1,3 +1,4 @@
+import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import type { RankingWeights } from "./types.js";
@@ -5,9 +6,23 @@ import type { RankingWeights } from "./types.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
+function normalizeForWsl(rawPath: string): string {
+  const winMatch = rawPath.match(/^([A-Za-z]):[/\\](.*)/);
+  if (!winMatch) return rawPath;
+  try {
+    const version = fs.readFileSync("/proc/version", "utf8");
+    if (!/microsoft|wsl/i.test(version)) return rawPath;
+  } catch {
+    return rawPath;
+  }
+  const drive = winMatch[1].toLowerCase();
+  const rest = winMatch[2].replace(/\\/g, "/").replace(/\/+$/, "");
+  return `/mnt/${drive}/${rest}`;
+}
+
 const PROJECT_ROOT_OVERRIDE = process.env.CORTEX_PROJECT_ROOT?.trim();
 export const REPO_ROOT = PROJECT_ROOT_OVERRIDE
-  ? path.resolve(PROJECT_ROOT_OVERRIDE)
+  ? path.resolve(normalizeForWsl(PROJECT_ROOT_OVERRIDE))
   : path.resolve(__dirname, "../..");
 export const CONTEXT_DIR = path.join(REPO_ROOT, ".context");
 export const CACHE_DIR = path.join(CONTEXT_DIR, "cache");

package/scaffold/scripts/ingest.mjs

@@ -16,6 +16,7 @@ import {
 import { parseCode as parseConfigCode } from "./parsers/config.mjs";
 import { parseCode as parseResourcesCode } from "./parsers/resources.mjs";
 import { parseCode as parseSqlCode } from "./parsers/sql.mjs";
+import { parseCode as parseRustCode } from "./parsers/rust.mjs";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -273,6 +274,13 @@ const CHUNK_PARSERS = new Map([
       parse: parseCppCode,
       isAvailable: isCppParserAvailable
     }
+  ],
+  [
+    ".rs",
+    {
+      language: "rust",
+      parse: parseRustCode
+    }
   ]
 ]);
 

package/scaffold/scripts/memory-compile.mjs

@@ -6,8 +6,17 @@ import { parseFrontmatter, parseStringList } from "../mcp/dist/frontmatter.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
+
+function normalizeForWsl(rawPath) {
+  const m = rawPath.match(/^([A-Za-z]):[/\\](.*)/);
+  if (!m) return rawPath;
+  try { if (!/microsoft|wsl/i.test(fs.readFileSync("/proc/version", "utf8"))) return rawPath; }
+  catch { return rawPath; }
+  return `/mnt/${m[1].toLowerCase()}/${m[2].replace(/\\/g, "/").replace(/\/+$/, "")}`;
+}
+
 const REPO_ROOT = process.env.CORTEX_PROJECT_ROOT
-  ? path.resolve(process.env.CORTEX_PROJECT_ROOT)
+  ? path.resolve(normalizeForWsl(process.env.CORTEX_PROJECT_ROOT))
   : path.resolve(__dirname, "..");
 const CONTEXT_DIR = path.join(REPO_ROOT, ".context");
 const MEMORY_DIR = path.join(CONTEXT_DIR, "memory");

package/scaffold/scripts/memory-lint.mjs

@@ -6,8 +6,17 @@ import { parseFrontmatter, parseStringList } from "../mcp/dist/frontmatter.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
+
+function normalizeForWsl(rawPath) {
+  const m = rawPath.match(/^([A-Za-z]):[/\\](.*)/);
+  if (!m) return rawPath;
+  try { if (!/microsoft|wsl/i.test(fs.readFileSync("/proc/version", "utf8"))) return rawPath; }
+  catch { return rawPath; }
+  return `/mnt/${m[1].toLowerCase()}/${m[2].replace(/\\/g, "/").replace(/\/+$/, "")}`;
+}
+
 const REPO_ROOT = process.env.CORTEX_PROJECT_ROOT
-  ? path.resolve(process.env.CORTEX_PROJECT_ROOT)
+  ? path.resolve(normalizeForWsl(process.env.CORTEX_PROJECT_ROOT))
   : path.resolve(__dirname, "..");
 const CONTEXT_DIR = path.join(REPO_ROOT, ".context");
 const MEMORY_DIR = path.join(CONTEXT_DIR, "memory");

package/scaffold/scripts/parsers/rust.mjs

@@ -0,0 +1,515 @@
+#!/usr/bin/env node
+/**
+ * Regex-based Rust parser for Cortex.
+ *
+ * Extracts semantic chunks from Rust source files: functions, structs, enums,
+ * traits, impl blocks (with methods), inline modules, macro_rules! definitions,
+ * use imports, and call relationships.
+ *
+ * No external dependencies — pure regex, always available.
+ */
+
+const CALL_KEYWORDS = new Set([
+  "if", "for", "while", "loop", "match", "return",
+  "Some", "None", "Ok", "Err", "Box", "Vec", "String",
+  "println", "eprintln", "format", "write", "writeln",
+  "panic", "todo", "unimplemented", "unreachable",
+  "assert", "assert_eq", "assert_ne", "debug_assert",
+  "debug_assert_eq", "debug_assert_ne",
+  "cfg", "derive", "allow", "warn", "deny"
+]);
+
+const VIS_PREFIX = /(?:pub(?:\s*\([^)]*\))?\s+)?/;
+const VIS_PREFIX_SRC = VIS_PREFIX.source;
+const LINE_START = "^[^\\S\\n]*";
+
+const FN_PATTERN = new RegExp(
+  `${LINE_START}${VIS_PREFIX_SRC}(?:default\\s+)?(?:async\\s+)?(?:unsafe\\s+)?(?:const\\s+)?(?:extern\\s+"[^"]*"\\s+)?fn\\s+([A-Za-z_]\\w*)`,
+  "gm"
+);
+
+const STRUCT_PATTERN = new RegExp(
+  `${LINE_START}${VIS_PREFIX_SRC}struct\\s+([A-Za-z_]\\w*)`,
+  "gm"
+);
+
+const ENUM_PATTERN = new RegExp(
+  `${LINE_START}${VIS_PREFIX_SRC}enum\\s+([A-Za-z_]\\w*)`,
+  "gm"
+);
+
+const TRAIT_PATTERN = new RegExp(
+  `${LINE_START}${VIS_PREFIX_SRC}(?:unsafe\\s+)?trait\\s+([A-Za-z_]\\w*)`,
+  "gm"
+);
+
+const IMPL_PATTERN = /^[^\S\n]*(?:unsafe\s+)?impl(?:<[^>]*>)?\s+(?:([A-Za-z_]\w*(?:<[^>]*>)?)\s+for\s+)?([A-Za-z_]\w*)/gm;
+
+const MOD_PATTERN = new RegExp(
+  `${LINE_START}${VIS_PREFIX_SRC}mod\\s+([A-Za-z_]\\w*)`,
+  "gm"
+);
+
+const MACRO_PATTERN = new RegExp(
+  `${LINE_START}${VIS_PREFIX_SRC}macro_rules!\\s+([A-Za-z_]\\w*)`,
+  "gm"
+);
+
+const USE_PATTERN = new RegExp(
+  `^\\s*${VIS_PREFIX_SRC}use\\s+(.+?)\\s*;`,
+  "gm"
+);
+
+function countLinesBefore(text, index) {
+  let line = 1;
+  for (let i = 0; i < index; i += 1) {
+    if (text[i] === "\n") {
+      line += 1;
+    }
+  }
+  return line;
+}
+
+function normalizeWhitespace(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+
+function findMatchingBrace(text, openBraceIndex) {
+  if (openBraceIndex < 0 || text[openBraceIndex] !== "{") {
+    return -1;
+  }
+
+  let depth = 0;
+  let inSingleLineComment = false;
+  let inBlockComment = false;
+  let inString = false;
+  let stringChar = "";
+  let inRawString = false;
+  let rawHashCount = 0;
+
+  for (let index = openBraceIndex; index < text.length; index += 1) {
+    const current = text[index];
+    const next = text[index + 1];
+
+    if (inSingleLineComment) {
+      if (current === "\n") {
+        inSingleLineComment = false;
+      }
+      continue;
+    }
+
+    if (inBlockComment) {
+      if (current === "*" && next === "/") {
+        inBlockComment = false;
+        index += 1;
+      }
+      continue;
+    }
+
+    if (inRawString) {
+      if (current === '"') {
+        let hashes = 0;
+        while (hashes < rawHashCount && text[index + 1 + hashes] === "#") {
+          hashes += 1;
+        }
+        if (hashes === rawHashCount) {
+          inRawString = false;
+          index += hashes;
+        }
+      }
+      continue;
+    }
+
+    if (inString) {
+      if (current === "\\" && next) {
+        index += 1;
+        continue;
+      }
+      if (current === stringChar) {
+        inString = false;
+        stringChar = "";
+      }
+      continue;
+    }
+
+    if (current === "/" && next === "/") {
+      inSingleLineComment = true;
+      index += 1;
+      continue;
+    }
+
+    if (current === "/" && next === "*") {
+      inBlockComment = true;
+      index += 1;
+      continue;
+    }
+
+    // Rust raw strings: r#"..."#, r##"..."##, etc.
+    if (current === "r" && (next === '"' || next === "#")) {
+      let hashes = 0;
+      let pos = index + 1;
+      while (text[pos] === "#") {
+        hashes += 1;
+        pos += 1;
+      }
+      if (text[pos] === '"') {
+        inRawString = true;
+        rawHashCount = hashes;
+        index = pos;
+        continue;
+      }
+    }
+
+    if (current === '"' || current === "'") {
+      // Rust lifetime annotations ('a) should not trigger string mode
+      if (current === "'" && next && /[a-zA-Z_]/.test(next)) {
+        // Check if this is a lifetime like 'a or a char like 'x'
+        const afterIdent = text.indexOf("'", index + 2);
+        const nextNewline = text.indexOf("\n", index + 1);
+        if (afterIdent === -1 || (nextNewline !== -1 && afterIdent > nextNewline) || afterIdent > index + 4) {
+          // Lifetime — skip the tick and identifier
+          continue;
+        }
+      }
+      inString = true;
+      stringChar = current;
+      continue;
+    }
+
+    if (current === "{") {
+      depth += 1;
+      continue;
+    }
+
+    if (current === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return index;
+      }
+    }
+  }
+
+  return -1;
+}
+
+function findOpenBraceAfterMatch(code, matchEnd) {
+  let inLineComment = false;
+  let inBlockComment = false;
+  let inString = false;
+  let stringChar = "";
+
+  for (let i = matchEnd; i < code.length; i += 1) {
+    const ch = code[i];
+    const next = code[i + 1];
+
+    if (inLineComment) {
+      if (ch === "\n") inLineComment = false;
+      continue;
+    }
+    if (inBlockComment) {
+      if (ch === "*" && next === "/") { inBlockComment = false; i += 1; }
+      continue;
+    }
+    if (inString) {
+      if (ch === "\\" && next) { i += 1; continue; }
+      if (ch === stringChar) { inString = false; stringChar = ""; }
+      continue;
+    }
+    if (ch === "/" && next === "/") { inLineComment = true; i += 1; continue; }
+    if (ch === "/" && next === "*") { inBlockComment = true; i += 1; continue; }
+    if (ch === '"' || ch === "'") { inString = true; stringChar = ch; continue; }
+
+    if (ch === "{") return i;
+    if (ch === ";") return -1; // Declaration without body
+  }
+  return -1;
+}
+
+function buildSignature(source) {
+  const snippet = normalizeWhitespace(source);
+  const braceIndex = snippet.indexOf("{");
+  return (braceIndex === -1 ? snippet : snippet.slice(0, braceIndex)).trim();
+}
+
+function extractUseImports(code) {
+  const imports = [];
+  let match;
+  USE_PATTERN.lastIndex = 0;
+  while ((match = USE_PATTERN.exec(code)) !== null) {
+    imports.push(match[1].trim());
+  }
+  return [...new Set(imports)];
+}
+
+function collectCallNames(body, chunkName) {
+  const refs = new Set();
+  const ownTailName = chunkName.split("::").pop() || chunkName;
+  const pattern = /\b([A-Za-z_]\w*(?:::\w+)*)\s*[!(]\s*/g;
+  let match;
+  while ((match = pattern.exec(body)) !== null) {
+    let name = match[1];
+    const tailName = name.split("::").pop() || name;
+    if (CALL_KEYWORDS.has(tailName) || tailName === ownTailName) {
+      continue;
+    }
+    // Skip if it matched a macro invocation keyword
+    if (CALL_KEYWORDS.has(name)) {
+      continue;
+    }
+    refs.add(tailName);
+  }
+  return [...refs];
+}
+
+function extractBlockChunks(code, pattern, kind, language) {
+  const chunks = [];
+  pattern.lastIndex = 0;
+  let match;
+  while ((match = pattern.exec(code)) !== null) {
+    const name = match[1];
+    const openBraceIndex = findOpenBraceAfterMatch(code, match.index + match[0].length);
+    if (openBraceIndex === -1) {
+      // Could be a unit struct like `struct Foo;` — extract as single-line chunk
+      if (kind === "struct") {
+        const lineEnd = code.indexOf("\n", match.index);
+        const endIdx = lineEnd === -1 ? code.length : lineEnd;
+        const body = code.slice(match.index, endIdx).trimEnd();
+        if (body.includes(";")) {
+          const startLine = countLinesBefore(code, match.index);
+          chunks.push({
+            name,
+            kind,
+            signature: normalizeWhitespace(body),
+            body,
+            startLine,
+            endLine: startLine,
+            language,
+            calls: [],
+            imports: []
+          });
+        }
+      }
+      continue;
+    }
+    const closeBraceIndex = findMatchingBrace(code, openBraceIndex);
+    if (closeBraceIndex === -1) continue;
+
+    const bodyEndIndex = closeBraceIndex + 1;
+    const body = code.slice(match.index, bodyEndIndex);
+    const startLine = countLinesBefore(code, match.index);
+    const endLine = countLinesBefore(code, Math.max(match.index, bodyEndIndex - 1));
+
+    chunks.push({
+      name,
+      kind,
+      signature: buildSignature(body),
+      body,
+      startLine,
+      endLine,
+      language,
+      calls: kind === "function" ? collectCallNames(body, name) : [],
+      imports: []
+    });
+  }
+  return chunks;
+}
+
+function extractImplBlocks(code, language, imports) {
+  const chunks = [];
+  IMPL_PATTERN.lastIndex = 0;
+  let match;
+  while ((match = IMPL_PATTERN.exec(code)) !== null) {
+    const traitName = match[1] || null;
+    const typeName = match[2];
+    const openBraceIndex = findOpenBraceAfterMatch(code, match.index + match[0].length);
+    if (openBraceIndex === -1) continue;
+    const closeBraceIndex = findMatchingBrace(code, openBraceIndex);
+    if (closeBraceIndex === -1) continue;
+
+    const implBody = code.slice(match.index, closeBraceIndex + 1);
+    const implStartLine = countLinesBefore(code, match.index);
+    const implEndLine = countLinesBefore(code, closeBraceIndex);
+    const implName = traitName ? `${traitName} for ${typeName}` : typeName;
+
+    // Add the impl block itself
+    chunks.push({
+      name: implName,
+      kind: "impl",
+      signature: buildSignature(implBody),
+      body: implBody,
+      startLine: implStartLine,
+      endLine: implEndLine,
+      language,
+      calls: [],
+      imports: []
+    });
+
+    // Extract methods within the impl block
+    const innerCode = code.slice(openBraceIndex + 1, closeBraceIndex);
+    const innerOffset = openBraceIndex + 1;
+    FN_PATTERN.lastIndex = 0;
+    let fnMatch;
+    while ((fnMatch = FN_PATTERN.exec(innerCode)) !== null) {
+      const fnName = fnMatch[1];
+      const qualifiedName = `${typeName}::${fnName}`;
+      const fnOpenBrace = findOpenBraceAfterMatch(innerCode, fnMatch.index + fnMatch[0].length);
+      if (fnOpenBrace === -1) continue;
+      const fnCloseBrace = findMatchingBrace(innerCode, fnOpenBrace);
+      if (fnCloseBrace === -1) continue;
+
+      const fnBodyEndIndex = fnCloseBrace + 1;
+      const fnBody = innerCode.slice(fnMatch.index, fnBodyEndIndex);
+      const fnStartLine = countLinesBefore(code, innerOffset + fnMatch.index);
+      const fnEndLine = countLinesBefore(code, innerOffset + Math.max(fnMatch.index, fnBodyEndIndex - 1));
+
+      chunks.push({
+        name: qualifiedName,
+        kind: "method",
+        signature: buildSignature(fnBody),
+        body: fnBody,
+        startLine: fnStartLine,
+        endLine: fnEndLine,
+        language,
+        calls: collectCallNames(fnBody, qualifiedName),
+        imports
+      });
+    }
+  }
+  return chunks;
+}
+
+function extractMacroChunks(code, language) {
+  const chunks = [];
+  MACRO_PATTERN.lastIndex = 0;
+  let match;
+  while ((match = MACRO_PATTERN.exec(code)) !== null) {
+    const name = match[1];
+    // macro_rules! uses { } or ( ) or [ ] as delimiters
+    const afterMatch = code.slice(match.index + match[0].length).trimStart();
+    let openChar, closeChar;
+    if (afterMatch[0] === "{") {
+      openChar = "{";
+    } else if (afterMatch[0] === "(") {
+      openChar = "(";
+    } else if (afterMatch[0] === "[") {
+      openChar = "[";
+    } else {
+      continue;
+    }
+
+    // For braces, use findMatchingBrace; for parens/brackets, do simple depth counting
+    let endIndex;
+    if (openChar === "{") {
+      const openBraceIndex = code.indexOf("{", match.index + match[0].length);
+      const closeBraceIndex = findMatchingBrace(code, openBraceIndex);
+      if (closeBraceIndex === -1) continue;
+      endIndex = closeBraceIndex + 1;
+    } else {
+      closeChar = openChar === "(" ? ")" : "]";
+      const startSearch = match.index + match[0].length + afterMatch.indexOf(openChar);
+      let depth = 0;
+      endIndex = -1;
+      for (let i = startSearch; i < code.length; i += 1) {
+        if (code[i] === openChar) depth += 1;
+        else if (code[i] === closeChar) {
+          depth -= 1;
+          if (depth === 0) {
+            endIndex = i + 1;
+            break;
+          }
+        }
+      }
+      if (endIndex === -1) continue;
+    }
+
+    const body = code.slice(match.index, endIndex);
+    const startLine = countLinesBefore(code, match.index);
+    const endLine = countLinesBefore(code, Math.max(match.index, endIndex - 1));
+
+    chunks.push({
+      name,
+      kind: "macro",
+      signature: `macro_rules! ${name}`,
+      body,
+      startLine,
+      endLine,
+      language,
+      calls: [],
+      imports: []
+    });
+  }
+  return chunks;
+}
+
+function extractTopLevelFunctions(code, language, implChunks, imports) {
+  const chunks = [];
+  FN_PATTERN.lastIndex = 0;
+  let match;
+  while ((match = FN_PATTERN.exec(code)) !== null) {
+    const name = match[1];
+    const openBraceIndex = findOpenBraceAfterMatch(code, match.index + match[0].length);
+    if (openBraceIndex === -1) continue;
+    const closeBraceIndex = findMatchingBrace(code, openBraceIndex);
+    if (closeBraceIndex === -1) continue;
+
+    const startLine = countLinesBefore(code, match.index);
+    const endLine = countLinesBefore(code, closeBraceIndex);
+
+    // Skip functions that are inside impl blocks (already extracted as methods)
+    const insideImpl = implChunks.some(
+      (impl) => impl.kind === "impl" && startLine >= impl.startLine && endLine <= impl.endLine
+    );
+    if (insideImpl) continue;
+
+    const bodyEndIndex = closeBraceIndex + 1;
+    const body = code.slice(match.index, bodyEndIndex);
+
+    chunks.push({
+      name,
+      kind: "function",
+      signature: buildSignature(body),
+      body,
+      startLine,
+      endLine,
+      language,
+      calls: collectCallNames(body, name),
+      imports
+    });
+  }
+  return chunks;
+}
+
+export function parseCode(code, filePath, language = "rust") {
+  const imports = extractUseImports(code);
+  const implChunks = extractImplBlocks(code, language, imports);
+  const structChunks = extractBlockChunks(code, STRUCT_PATTERN, "struct", language);
+  const enumChunks = extractBlockChunks(code, ENUM_PATTERN, "enum", language);
+  const traitChunks = extractBlockChunks(code, TRAIT_PATTERN, "trait", language);
+  const modChunks = extractBlockChunks(code, MOD_PATTERN, "module", language);
+  const macroChunks = extractMacroChunks(code, language);
+  const fnChunks = extractTopLevelFunctions(code, language, implChunks, imports);
+
+  const seen = new Set();
+  const chunks = [...structChunks, ...enumChunks, ...traitChunks, ...implChunks, ...modChunks, ...macroChunks, ...fnChunks].filter((chunk) => {
+    const key = `${chunk.kind}|${chunk.name}|${chunk.startLine}|${chunk.endLine}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+
+  return { chunks, errors: [] };
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const fs = await import("node:fs");
+  const filePath = process.argv[2];
+
+  if (!filePath) {
+    console.error("Usage: rust.mjs <file.rs>");
+    process.exit(1);
+  }
+
+  const code = fs.readFileSync(filePath, "utf8");
+  const result = parseCode(code, filePath, "rust");
+  console.log(JSON.stringify(result, null, 2));
+}

package/scaffold/scripts/watch.sh

@@ -84,10 +84,18 @@ detect_event_backend() {
   return 1
 }
 
+is_wsl_mnt_path() {
+  grep -qi microsoft /proc/version 2>/dev/null && [[ "$REPO_ROOT" == /mnt/* ]]
+}
+
 resolve_mode() {
   case "$WATCH_MODE" in
     auto)
-      if EVENT_BACKEND="$(detect_event_backend)"; then
+      if is_wsl_mnt_path; then
+        echo "[watch] WSL detected with /mnt/ path, using poll mode (inotify unreliable on Windows mounts)"
+        WATCH_MODE="poll"
+        EVENT_BACKEND=""
+      elif EVENT_BACKEND="$(detect_event_backend)"; then
         WATCH_MODE="event"
       else
         WATCH_MODE="poll"