archtracker-mcp 0.2.0 → 0.3.0

package/dist/cli/index.js

@@ -1,10 +1,4 @@
 #!/usr/bin/env node
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
 
 // src/cli/index.ts
 import { Command } from "commander";
@@ -175,6 +169,514 @@ function detectCycles(edges) {
   return cycles;
 }
 
+// src/analyzer/engines/strip-comments.ts
+function stripComments(content, style) {
+  switch (style) {
+    case "c-style":
+      return stripCStyle(content);
+    case "hash":
+      return stripHash(content);
+    case "python":
+      return stripPython(content);
+    case "ruby":
+      return stripRuby(content);
+    case "php":
+      return stripPhp(content);
+    default: {
+      const _exhaustive = style;
+      throw new Error(`Unknown comment style: ${_exhaustive}`);
+    }
+  }
+}
+function stripCStyle(content) {
+  let result = "";
+  let i = 0;
+  while (i < content.length) {
+    if (content[i] === "r" && i + 1 < content.length) {
+      let hashes = 0;
+      let j = i + 1;
+      while (j < content.length && content[j] === "#") {
+        hashes++;
+        j++;
+      }
+      if (j < content.length && content[j] === '"') {
+        for (let k = i; k <= j; k++) {
+          result += " ";
+        }
+        i = j + 1;
+        while (i < content.length) {
+          if (content[i] === '"') {
+            let matchHashes = 0;
+            let m = i + 1;
+            while (m < content.length && content[m] === "#" && matchHashes < hashes) {
+              matchHashes++;
+              m++;
+            }
+            if (matchHashes === hashes) {
+              for (let k = i; k < m; k++) {
+                result += " ";
+              }
+              i = m;
+              break;
+            }
+          }
+          result += content[i] === "\n" ? "\n" : " ";
+          i++;
+        }
+        continue;
+      }
+    }
+    if (content[i] === "/" && content[i + 1] === "/") {
+      while (i < content.length && content[i] !== "\n") {
+        result += " ";
+        i++;
+      }
+    } else if (content[i] === "/" && content[i + 1] === "*") {
+      result += " ";
+      i++;
+      result += " ";
+      i++;
+      while (i < content.length) {
+        if (content[i] === "*" && content[i + 1] === "/") {
+          result += " ";
+          i++;
+          result += " ";
+          i++;
+          break;
+        }
+        result += content[i] === "\n" ? "\n" : " ";
+        i++;
+      }
+    } else if (content[i] === '"') {
+      result += content[i];
+      i++;
+      while (i < content.length && content[i] !== '"') {
+        if (content[i] === "\\" && i + 1 < content.length) {
+          result += content[i];
+          i++;
+          result += content[i];
+          i++;
+        } else if (content[i] === "\n") {
+          result += "\n";
+          i++;
+        } else {
+          result += content[i];
+          i++;
+        }
+      }
+      if (i < content.length) {
+        result += content[i];
+        i++;
+      }
+    } else if (content[i] === "'") {
+      result += content[i];
+      i++;
+      while (i < content.length && content[i] !== "'") {
+        if (content[i] === "\\" && i + 1 < content.length) {
+          result += content[i];
+          i++;
+          result += content[i];
+          i++;
+        } else {
+          result += content[i];
+          i++;
+        }
+      }
+      if (i < content.length) {
+        result += content[i];
+        i++;
+      }
+    } else if (content[i] === "`") {
+      result += " ";
+      i++;
+      while (i < content.length && content[i] !== "`") {
+        result += content[i] === "\n" ? "\n" : " ";
+        i++;
+      }
+      if (i < content.length) {
+        result += " ";
+        i++;
+      }
+    } else {
+      result += content[i];
+      i++;
+    }
+  }
+  return result;
+}
+function stripHash(content) {
+  let result = "";
+  let i = 0;
+  while (i < content.length) {
+    if (content[i] === "#") {
+      while (i < content.length && content[i] !== "\n") {
+        result += " ";
+        i++;
+      }
+    } else if (content[i] === '"') {
+      result += content[i];
+      i++;
+      while (i < content.length && content[i] !== '"') {
+        if (content[i] === "\\" && i + 1 < content.length) {
+          result += content[i++];
+          result += content[i++];
+        } else {
+          result += content[i++];
+        }
+      }
+      if (i < content.length) {
+        result += content[i];
+        i++;
+      }
+    } else if (content[i] === "'") {
+      result += content[i];
+      i++;
+      while (i < content.length && content[i] !== "'") {
+        if (content[i] === "\\" && i + 1 < content.length) {
+          result += content[i++];
+          result += content[i++];
+        } else {
+          result += content[i++];
+        }
+      }
+      if (i < content.length) {
+        result += content[i];
+        i++;
+      }
+    } else {
+      result += content[i];
+      i++;
+    }
+  }
+  return result;
+}
+function stripPython(content) {
+  let result = "";
+  let i = 0;
+  while (i < content.length) {
+    let prefixLen = 0;
+    let isRaw = false;
+    if (i < content.length) {
+      const c0 = content[i];
+      const c1 = i + 1 < content.length ? content[i + 1] : "";
+      const c2 = i + 2 < content.length ? content[i + 2] : "";
+      if ((c0 === "r" || c0 === "R" || c0 === "b" || c0 === "B" || c0 === "f" || c0 === "F") && (c1 === "r" || c1 === "R" || c1 === "b" || c1 === "B" || c1 === "f" || c1 === "F") && (c2 === '"' || c2 === "'")) {
+        const pair = (c0 + c1).toLowerCase();
+        if (pair === "rb" || pair === "br" || pair === "fr" || pair === "rf") {
+          prefixLen = 2;
+          isRaw = pair.includes("r");
+        }
+      }
+      if (prefixLen === 0 && (c0 === "r" || c0 === "R" || c0 === "b" || c0 === "B" || c0 === "f" || c0 === "F") && (c1 === '"' || c1 === "'")) {
+        prefixLen = 1;
+        isRaw = c0 === "r" || c0 === "R";
+      }
+    }
+    const quoteStart = i + prefixLen;
+    if (quoteStart + 2 < content.length && (content[quoteStart] === '"' || content[quoteStart] === "'") && content[quoteStart + 1] === content[quoteStart] && content[quoteStart + 2] === content[quoteStart]) {
+      const quote = content[quoteStart];
+      for (let k = 0; k < prefixLen; k++) {
+        result += " ";
+      }
+      result += "   ";
+      i = quoteStart + 3;
+      while (i < content.length) {
+        if (content[i] === quote && content[i + 1] === quote && content[i + 2] === quote) {
+          result += "   ";
+          i += 3;
+          break;
+        }
+        if (!isRaw && content[i] === "\\" && i + 1 < content.length) {
+          result += " ";
+          i++;
+          result += content[i] === "\n" ? "\n" : " ";
+          i++;
+        } else {
+          result += content[i] === "\n" ? "\n" : " ";
+          i++;
+        }
+      }
+    } else if (prefixLen === 0 && content[i] === "#") {
+      while (i < content.length && content[i] !== "\n") {
+        result += " ";
+        i++;
+      }
+    } else if (quoteStart < content.length && (content[quoteStart] === '"' || content[quoteStart] === "'") && (prefixLen > 0 || content[i] === '"' || content[i] === "'")) {
+      const quote = content[quoteStart];
+      for (let k = i; k < quoteStart; k++) {
+        result += content[k];
+      }
+      result += content[quoteStart];
+      i = quoteStart + 1;
+      while (i < content.length && content[i] !== quote) {
+        if (!isRaw && content[i] === "\\" && i + 1 < content.length) {
+          result += content[i++];
+          result += content[i++];
+        } else if (content[i] === "\n") {
+          result += "\n";
+          i++;
+          break;
+        } else {
+          result += content[i++];
+        }
+      }
+      if (i < content.length && content[i] === quote) {
+        result += content[i];
+        i++;
+      }
+    } else {
+      result += content[i];
+      i++;
+    }
+  }
+  return result;
+}
+function stripRuby(content) {
+  const lines = content.split("\n");
+  const result = [];
+  let inBlock = false;
+  for (const line of lines) {
+    if (!inBlock && /^=begin(\s|$)/.test(line)) {
+      inBlock = true;
+      result.push(" ".repeat(line.length));
+      continue;
+    }
+    if (inBlock) {
+      if (/^=end(\s|$)/.test(line)) {
+        inBlock = false;
+      }
+      result.push(" ".repeat(line.length));
+      continue;
+    }
+    let processed = "";
+    let i = 0;
+    while (i < line.length) {
+      if (line[i] === "#") {
+        processed += " ".repeat(line.length - i);
+        break;
+      } else if (line[i] === '"') {
+        processed += line[i];
+        i++;
+        processed = scanRubyDoubleQuotedString(line, i, processed);
+        i = scanRubyDoubleQuotedStringIndex(line, i);
+      } else if (line[i] === "'") {
+        processed += line[i];
+        i++;
+        while (i < line.length && line[i] !== "'") {
+          if (line[i] === "\\" && i + 1 < line.length) {
+            processed += line[i++];
+            processed += line[i++];
+          } else {
+            processed += line[i++];
+          }
+        }
+        if (i < line.length) {
+          processed += line[i];
+          i++;
+        }
+      } else {
+        processed += line[i];
+        i++;
+      }
+    }
+    result.push(processed);
+  }
+  return result.join("\n");
+}
+function scanRubyDoubleQuotedString(line, startI, processed) {
+  let i = startI;
+  while (i < line.length && line[i] !== '"') {
+    if (line[i] === "\\" && i + 1 < line.length) {
+      processed += line[i++];
+      processed += line[i++];
+    } else if (line[i] === "#" && i + 1 < line.length && line[i + 1] === "{") {
+      processed += line[i++];
+      processed += line[i++];
+      let depth = 1;
+      while (i < line.length && depth > 0) {
+        if (line[i] === "{") {
+          depth++;
+          processed += line[i++];
+        } else if (line[i] === "}") {
+          depth--;
+          processed += line[i++];
+        } else if (line[i] === "\\" && i + 1 < line.length) {
+          processed += line[i++];
+          processed += line[i++];
+        } else {
+          processed += line[i++];
+        }
+      }
+    } else {
+      processed += line[i++];
+    }
+  }
+  if (i < line.length) {
+    processed += line[i];
+  }
+  return processed;
+}
+function scanRubyDoubleQuotedStringIndex(line, startI) {
+  let i = startI;
+  while (i < line.length && line[i] !== '"') {
+    if (line[i] === "\\" && i + 1 < line.length) {
+      i += 2;
+    } else if (line[i] === "#" && i + 1 < line.length && line[i + 1] === "{") {
+      i += 2;
+      let depth = 1;
+      while (i < line.length && depth > 0) {
+        if (line[i] === "{") {
+          depth++;
+          i++;
+        } else if (line[i] === "}") {
+          depth--;
+          i++;
+        } else if (line[i] === "\\" && i + 1 < line.length) {
+          i += 2;
+        } else {
+          i++;
+        }
+      }
+    } else {
+      i++;
+    }
+  }
+  if (i < line.length) {
+    i++;
+  }
+  return i;
+}
+function stripPhp(content) {
+  let result = "";
+  let i = 0;
+  while (i < content.length) {
+    if (content[i] === "<" && content[i + 1] === "<" && content[i + 2] === "<") {
+      const heredocStart = i;
+      let j = i + 3;
+      let isNowdoc = false;
+      if (j < content.length && content[j] === "'") {
+        isNowdoc = true;
+        j++;
+      }
+      const identStart = j;
+      while (j < content.length && /[A-Za-z0-9_]/.test(content[j])) {
+        j++;
+      }
+      const identifier = content.slice(identStart, j);
+      if (identifier.length > 0) {
+        if (isNowdoc && j < content.length && content[j] === "'") {
+          j++;
+        }
+        let validHeredoc = false;
+        let lineEnd = j;
+        if (lineEnd < content.length && content[lineEnd] === "\n") {
+          validHeredoc = true;
+        }
+        if (validHeredoc) {
+          for (let k = heredocStart; k <= lineEnd; k++) {
+            if (content[k] === "\n") {
+              result += "\n";
+            } else {
+              result += content[k];
+            }
+          }
+          i = lineEnd + 1;
+          let found = false;
+          while (i < content.length && !found) {
+            const lineStart = i;
+            let lineEndIdx = i;
+            while (lineEndIdx < content.length && content[lineEndIdx] !== "\n") {
+              lineEndIdx++;
+            }
+            const currentLine = content.slice(lineStart, lineEndIdx);
+            const trimmedLine = currentLine.trimStart();
+            if (trimmedLine === identifier || trimmedLine === identifier + ";" || trimmedLine === identifier + "," || trimmedLine === identifier + ");" || trimmedLine === identifier + ")" || trimmedLine.startsWith(identifier + ";") || trimmedLine === identifier) {
+              for (let k = lineStart; k < lineEndIdx; k++) {
+                result += content[k];
+              }
+              i = lineEndIdx;
+              if (i < content.length && content[i] === "\n") {
+                result += "\n";
+                i++;
+              }
+              found = true;
+            } else {
+              for (let k = lineStart; k < lineEndIdx; k++) {
+                result += " ";
+              }
+              i = lineEndIdx;
+              if (i < content.length && content[i] === "\n") {
+                result += "\n";
+                i++;
+              }
+            }
+          }
+          continue;
+        }
+      }
+      result += content[i];
+      i++;
+      continue;
+    }
+    if (content[i] === "/" && content[i + 1] === "/" || content[i] === "#") {
+      while (i < content.length && content[i] !== "\n") {
+        result += " ";
+        i++;
+      }
+    } else if (content[i] === "/" && content[i + 1] === "*") {
+      result += " ";
+      i++;
+      result += " ";
+      i++;
+      while (i < content.length) {
+        if (content[i] === "*" && content[i + 1] === "/") {
+          result += " ";
+          i++;
+          result += " ";
+          i++;
+          break;
+        }
+        result += content[i] === "\n" ? "\n" : " ";
+        i++;
+      }
+    } else if (content[i] === '"') {
+      result += content[i];
+      i++;
+      while (i < content.length && content[i] !== '"') {
+        if (content[i] === "\\" && i + 1 < content.length) {
+          result += content[i++];
+          result += content[i++];
+        } else {
+          result += content[i++];
+        }
+      }
+      if (i < content.length) {
+        result += content[i];
+        i++;
+      }
+    } else if (content[i] === "'") {
+      result += content[i];
+      i++;
+      while (i < content.length && content[i] !== "'") {
+        if (content[i] === "\\" && i + 1 < content.length) {
+          result += content[i++];
+          result += content[i++];
+        } else {
+          result += content[i++];
+        }
+      }
+      if (i < content.length) {
+        result += content[i];
+        i++;
+      }
+    } else {
+      result += content[i];
+      i++;
+    }
+  }
+  return result;
+}
+
 // src/analyzer/engines/regex-engine.ts
 var RegexEngine = class {
   constructor(config) {
@@ -188,6 +690,7 @@ var RegexEngine = class {
       "\\.archtracker"
     ].map((p) => new RegExp(p));
     const projectFiles = await this.collectFiles(
+      absRootDir,
       absRootDir,
       excludePatterns,
       options.maxDepth ?? 0
@@ -195,6 +698,7 @@ var RegexEngine = class {
     const projectFileSet = new Set(projectFiles);
     const files = {};
     const edges = [];
+    const edgeSet = /* @__PURE__ */ new Set();
     for (const filePath of projectFiles) {
       const relPath = relative(absRootDir, filePath);
       files[relPath] = {
@@ -210,9 +714,11 @@ var RegexEngine = class {
       try {
         content = await readFile(filePath, "utf-8");
       } catch {
+        if (files[relSource]) files[relSource].exists = false;
         continue;
       }
-      const imports = this.extractImports(content);
+      const stripped = stripComments(content, this.config.commentStyle);
+      const imports = this.extractImports(stripped);
       for (const importPath of imports) {
         const resolved = this.config.resolveImport(
           importPath,
@@ -223,6 +729,10 @@ var RegexEngine = class {
         if (!resolved) continue;
         const relTarget = relative(absRootDir, resolved);
         if (!files[relTarget]) continue;
+        if (relSource === relTarget) continue;
+        const edgeKey = `${relSource}\0${relTarget}`;
+        if (edgeSet.has(edgeKey)) continue;
+        edgeSet.add(edgeKey);
         edges.push({
           source: relSource,
           target: relTarget,
@@ -243,9 +753,13 @@ var RegexEngine = class {
     };
   }
   extractImports(content) {
+    if (this.config.extractImports) {
+      return this.config.extractImports(content);
+    }
     const imports = [];
     for (const pattern of this.config.importPatterns) {
-      const regex = new RegExp(pattern.regex.source, pattern.regex.flags);
+      const flags = pattern.regex.flags.includes("g") ? pattern.regex.flags : pattern.regex.flags + "g";
+      const regex = new RegExp(pattern.regex.source, flags);
       let match;
       while ((match = regex.exec(content)) !== null) {
         if (match[1]) {
@@ -255,7 +769,7 @@ var RegexEngine = class {
     }
     return imports;
   }
-  async collectFiles(dir, excludePatterns, maxDepth, currentDepth = 0) {
+  async collectFiles(dir, absRootDir, excludePatterns, maxDepth, currentDepth = 0) {
     if (maxDepth > 0 && currentDepth >= maxDepth) return [];
     const results = [];
     let entries;
@@ -266,7 +780,7 @@ var RegexEngine = class {
     }
     for (const entry of entries) {
       const fullPath = join(dir, entry.name);
-      const relPath = relative(dir, fullPath);
+      const relPath = relative(absRootDir, fullPath);
       if (excludePatterns.some(
         (p) => p.test(entry.name) || p.test(relPath) || p.test(fullPath)
       )) {
@@ -276,6 +790,7 @@ var RegexEngine = class {
         if (entry.name.startsWith(".")) continue;
         const sub = await this.collectFiles(
           fullPath,
+          absRootDir,
           excludePatterns,
           maxDepth,
           currentDepth + 1
@@ -308,14 +823,21 @@ var MARKERS = [
   { file: "pom.xml", language: "java" },
   { file: "build.gradle", language: "java" },
   { file: "build.gradle.kts", language: "kotlin" },
+  { file: "build.sbt", language: "scala" },
+  { file: "build.sc", language: "scala" },
   { file: "Package.swift", language: "swift" },
   { file: "Gemfile", language: "ruby" },
   { file: "composer.json", language: "php" },
+  { file: "pubspec.yaml", language: "dart" },
   { file: "CMakeLists.txt", language: "c-cpp" },
   { file: "Makefile", language: "c-cpp" },
   { file: "package.json", language: "javascript" },
   { file: "tsconfig.json", language: "javascript" }
 ];
+var EXT_MARKERS = [
+  [".sln", "c-sharp"],
+  [".csproj", "c-sharp"]
+];
 var EXT_MAP = {
   ".ts": "javascript",
   ".tsx": "javascript",
@@ -337,7 +859,11 @@ var EXT_MAP = {
   ".php": "php",
   ".swift": "swift",
   ".kt": "kotlin",
-  ".kts": "kotlin"
+  ".kts": "kotlin",
+  ".cs": "c-sharp",
+  ".dart": "dart",
+  ".scala": "scala",
+  ".sc": "scala"
 };
 async function detectLanguage(rootDir) {
   for (const marker of MARKERS) {
@@ -349,6 +875,16 @@ async function detectLanguage(rootDir) {
     } catch {
     }
   }
+  try {
+    const topEntries = await readdir2(rootDir, { withFileTypes: true });
+    for (const entry of topEntries) {
+      if (!entry.isFile()) continue;
+      for (const [ext, lang] of EXT_MARKERS) {
+        if (entry.name.endsWith(ext)) return lang;
+      }
+    }
+  } catch {
+  }
   const counts = /* @__PURE__ */ new Map();
   try {
     await scanExtensions(rootDir, counts, 2, 0);
@@ -393,16 +929,35 @@ async function scanExtensions(dir, counts, maxDepth, currentDepth) {
 }
 
 // src/analyzer/engines/languages.ts
+import { readFileSync } from "fs";
 import { join as join3, dirname, resolve as resolve3 } from "path";
 var python = {
   id: "python",
   extensions: [".py"],
+  commentStyle: "python",
   importPatterns: [
     // from package.module import something
-    { regex: /^from\s+(\.[\w.]*|\w[\w.]*)\s+import\b/gm },
-    // import package.module
-    { regex: /^import\s+([\w.]+)/gm }
+    { regex: /^from\s+(\.[\w.]*|\w[\w.]*)\s+import\b/gm }
+    // import package.module (handled by extractImports for multi-module case)
   ],
+  // Bug #1 fix: custom extractImports to handle `import a, b, c`
+  extractImports(content) {
+    const imports = [];
+    const fromRegex = /^from\s+(\.[\w.]*|\w[\w.]*)\s+import\b/gm;
+    let match;
+    while ((match = fromRegex.exec(content)) !== null) {
+      imports.push(match[1]);
+    }
+    const importRegex = /^import\s+([\w.]+(?:\s*,\s*[\w.]+)*)/gm;
+    while ((match = importRegex.exec(content)) !== null) {
+      const modules = match[1].split(",");
+      for (const mod of modules) {
+        const trimmed = mod.trim();
+        if (trimmed) imports.push(trimmed);
+      }
+    }
+    return imports;
+  },
   resolveImport(importPath, sourceFile, rootDir, projectFiles) {
     if (importPath.startsWith(".")) {
       const dots = importPath.match(/^\.+/)?.[0].length ?? 1;
@@ -424,12 +979,33 @@ function tryPythonResolve(base, projectFiles) {
 var rust = {
   id: "rust",
   extensions: [".rs"],
-  importPatterns: [
-    // use crate::module::item;
-    { regex: /\buse\s+crate::(\w[\w:]*)/gm },
-    // mod child;
-    { regex: /\bmod\s+(\w+)\s*;/gm }
-  ],
+  commentStyle: "c-style",
+  importPatterns: [],
+  // handled by extractImports
+  extractImports(content) {
+    const imports = [];
+    const modRegex = /\bmod\s+(\w+)\s*;/gm;
+    let match;
+    while ((match = modRegex.exec(content)) !== null) {
+      imports.push(match[1]);
+    }
+    const useRegex = /\buse\s+crate::([\s\S]*?);/gm;
+    while ((match = useRegex.exec(content)) !== null) {
+      const body = match[1].trim();
+      extractRustUsePaths(body, "", imports);
+    }
+    const useSuperRegex = /\buse\s+super::([\s\S]*?);/gm;
+    while ((match = useSuperRegex.exec(content)) !== null) {
+      const body = match[1].trim();
+      extractRustUsePaths(body, "", imports, "super");
+    }
+    const useSelfRegex = /\buse\s+self::([\s\S]*?);/gm;
+    while ((match = useSelfRegex.exec(content)) !== null) {
+      const body = match[1].trim();
+      extractRustUsePaths(body, "", imports, "self");
+    }
+    return imports;
+  },
   resolveImport(importPath, sourceFile, rootDir, projectFiles) {
     const srcDir = join3(rootDir, "src");
     if (!importPath.includes("::")) {
@@ -440,6 +1016,30 @@ var rust = {
       if (projectFiles.has(asDir)) return asDir;
       return null;
     }
+    if (importPath.startsWith("super::")) {
+      const parentDir = dirname(dirname(sourceFile));
+      const segments2 = importPath.slice("super::".length).split("::");
+      for (let i = segments2.length; i > 0; i--) {
+        const path = segments2.slice(0, i).join("/");
+        const asFile = join3(parentDir, path + ".rs");
+        if (projectFiles.has(asFile)) return asFile;
+        const asDir = join3(parentDir, path, "mod.rs");
+        if (projectFiles.has(asDir)) return asDir;
+      }
+      return null;
+    }
+    if (importPath.startsWith("self::")) {
+      const selfDir = dirname(sourceFile);
+      const segments2 = importPath.slice("self::".length).split("::");
+      for (let i = segments2.length; i > 0; i--) {
+        const path = segments2.slice(0, i).join("/");
+        const asFile = join3(selfDir, path + ".rs");
+        if (projectFiles.has(asFile)) return asFile;
+        const asDir = join3(selfDir, path, "mod.rs");
+        if (projectFiles.has(asDir)) return asDir;
+      }
+      return null;
+    }
     const segments = importPath.split("::");
     for (let i = segments.length; i > 0; i--) {
       const path = segments.slice(0, i).join("/");
@@ -452,15 +1052,88 @@ var rust = {
   },
   defaultExclude: ["target"]
 };
+function extractRustUsePaths(body, prefix, results, rootPrefix) {
+  const trimmed = body.trim();
+  const braceStart = trimmed.indexOf("{");
+  if (braceStart === -1) {
+    let path = prefix ? `${prefix}::${trimmed}` : trimmed;
+    if (rootPrefix) {
+      path = `${rootPrefix}::${path}`;
+    }
+    if (path && !path.includes("{")) {
+      results.push(path);
+    }
+    return;
+  }
+  let pathPrefix = trimmed.slice(0, braceStart).trim();
+  if (pathPrefix.endsWith("::")) {
+    pathPrefix = pathPrefix.slice(0, -2);
+  }
+  const fullPrefix = prefix ? `${prefix}::${pathPrefix}` : pathPrefix;
+  let depth = 0;
+  let braceEnd = -1;
+  for (let i = braceStart; i < trimmed.length; i++) {
+    if (trimmed[i] === "{") depth++;
+    else if (trimmed[i] === "}") {
+      depth--;
+      if (depth === 0) {
+        braceEnd = i;
+        break;
+      }
+    }
+  }
+  if (braceEnd === -1) return;
+  const inner = trimmed.slice(braceStart + 1, braceEnd).trim();
+  const items = splitByTopLevelComma(inner);
+  for (const item of items) {
+    const cleaned = item.trim();
+    if (cleaned === "self") {
+      const selfPath = rootPrefix ? `${rootPrefix}::${fullPrefix}` : fullPrefix;
+      results.push(selfPath);
+    } else if (cleaned) {
+      extractRustUsePaths(cleaned, fullPrefix, results, rootPrefix);
+    }
+  }
+}
+function splitByTopLevelComma(s) {
+  const parts = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === "{") depth++;
+    else if (s[i] === "}") depth--;
+    else if (s[i] === "," && depth === 0) {
+      parts.push(s.slice(start, i));
+      start = i + 1;
+    }
+  }
+  parts.push(s.slice(start));
+  return parts;
+}
 var go = {
   id: "go",
   extensions: [".go"],
-  importPatterns: [
-    // import "path" or import ( "path" )
-    { regex: /\bimport\s+(?:\w+\s+)?"([^"]+)"/gm },
-    // import block entries
-    { regex: /^\s+(?:\w+\s+)?"([^"]+)"/gm }
-  ],
+  commentStyle: "c-style",
+  importPatterns: [],
+  // handled by extractImports
+  extractImports(content) {
+    const imports = [];
+    const singleRegex = /\bimport\s+(?:\w+\s+)?"([^"]+)"/gm;
+    let match;
+    while ((match = singleRegex.exec(content)) !== null) {
+      imports.push(match[1]);
+    }
+    const blockRegex = /\bimport\s*\(([^)]*)\)/gms;
+    while ((match = blockRegex.exec(content)) !== null) {
+      const block = match[1];
+      const entryRegex = /(?:\w+\s+)?"([^"]+)"/g;
+      let entry;
+      while ((entry = entryRegex.exec(block)) !== null) {
+        imports.push(entry[1]);
+      }
+    }
+    return imports;
+  },
   resolveImport(importPath, _sourceFile, rootDir, projectFiles) {
     const modPrefix = goModulePrefix(rootDir);
     if (!modPrefix || !importPath.startsWith(modPrefix)) return null;
@@ -477,8 +1150,7 @@ var goModCache = /* @__PURE__ */ new Map();
 function goModulePrefix(rootDir) {
   if (goModCache.has(rootDir)) return goModCache.get(rootDir);
   try {
-    const fs = __require("fs");
-    const content = fs.readFileSync(join3(rootDir, "go.mod"), "utf-8");
+    const content = readFileSync(join3(rootDir, "go.mod"), "utf-8");
     const match = content.match(/^module\s+(.+)$/m);
     const prefix = match ? match[1].trim() : null;
     goModCache.set(rootDir, prefix);
@@ -491,15 +1163,23 @@ function goModulePrefix(rootDir) {
 var java = {
   id: "java",
   extensions: [".java"],
+  commentStyle: "c-style",
   importPatterns: [
-    // import com.example.ClassName;
-    { regex: /^import\s+(?:static\s+)?([\w.]+);/gm }
+    // Bug #5 fix: import com.example.ClassName; and import com.example.*; (wildcard)
+    // Bug #6: static imports also captured here
+    { regex: /^import\s+(?:static\s+)?([\w.*]+);/gm }
   ],
   resolveImport(importPath, _sourceFile, rootDir, projectFiles) {
-    const filePath = importPath.replace(/\./g, "/") + ".java";
-    for (const srcRoot of ["", "src/main/java/", "src/", "app/src/main/java/"]) {
-      const full = join3(rootDir, srcRoot, filePath);
-      if (projectFiles.has(full)) return full;
+    if (importPath.endsWith(".*")) {
+      return null;
+    }
+    const segments = importPath.split(".");
+    for (let i = segments.length; i > 0; i--) {
+      const filePath = segments.slice(0, i).join("/") + ".java";
+      for (const srcRoot of ["", "src/main/java/", "src/", "app/src/main/java/"]) {
+        const full = join3(rootDir, srcRoot, filePath);
+        if (projectFiles.has(full)) return full;
+      }
     }
     return null;
   },
@@ -508,6 +1188,7 @@ var java = {
 var cCpp = {
   id: "c-cpp",
   extensions: [".c", ".cpp", ".cc", ".cxx", ".h", ".hpp"],
+  commentStyle: "c-style",
   importPatterns: [
     // #include "file.h" (skip <system> includes)
     { regex: /^#include\s+"([^"]+)"/gm }
@@ -528,6 +1209,7 @@ var cCpp = {
 var ruby = {
   id: "ruby",
   extensions: [".rb"],
+  commentStyle: "ruby",
   importPatterns: [
     // require_relative 'path'
     { regex: /\brequire_relative\s+['"]([^'"]+)['"]/gm },
@@ -549,11 +1231,12 @@ var ruby = {
 var php = {
   id: "php",
   extensions: [".php"],
+  commentStyle: "php",
   importPatterns: [
     // require/include/require_once/include_once 'path'
     { regex: /\b(?:require|include)(?:_once)?\s+['"]([^'"]+)['"]/gm },
-    // use Namespace\Class (PSR-4 style)
-    { regex: /^use\s+([\w\\]+)/gm }
+    // Bug #9 fix: use Namespace\Class — skip `function` and `const` keywords
+    { regex: /^use\s+(?:function\s+|const\s+)?([\w\\]+)/gm }
   ],
   resolveImport(importPath, sourceFile, rootDir, projectFiles) {
     if (importPath.includes("/") || importPath.endsWith(".php")) {
@@ -576,11 +1259,12 @@ var php = {
 var swift = {
   id: "swift",
   extensions: [".swift"],
+  commentStyle: "c-style",
   importPatterns: [
-    // import ModuleName
-    { regex: /^import\s+(?:class|struct|enum|protocol|func|var|let|typealias)?\s*(\w+)/gm }
+    // Bug #10 fix: import ModuleName and @testable import ModuleName
+    { regex: /^(?:@testable\s+)?import\s+(?:class\s+|struct\s+|enum\s+|protocol\s+|func\s+|var\s+|let\s+|typealias\s+)?(\w+)/gm }
   ],
-  resolveImport(importPath, _sourceFile, rootDir, projectFiles) {
+  resolveImport(importPath, sourceFile, rootDir, projectFiles) {
     const spmDir = join3(rootDir, "Sources", importPath);
     for (const f of projectFiles) {
       if (f.startsWith(spmDir + "/") && f.endsWith(".swift")) return f;
@@ -592,12 +1276,20 @@ var swift = {
 var kotlin = {
   id: "kotlin",
   extensions: [".kt", ".kts"],
+  commentStyle: "c-style",
   importPatterns: [
-    // import com.example.ClassName
-    { regex: /^import\s+([\w.]+)/gm }
+    // Bug #7/#8 fix: import com.example.ClassName and import com.example.*
+    { regex: /^import\s+([\w.*]+)/gm }
   ],
   resolveImport(importPath, _sourceFile, rootDir, projectFiles) {
-    const filePath = importPath.replace(/\./g, "/");
+    if (importPath.endsWith(".*")) {
+      return null;
+    }
+    let cleanPath = importPath;
+    if (cleanPath.endsWith(".")) {
+      cleanPath = cleanPath.slice(0, -1);
+    }
+    const filePath = cleanPath.replace(/\./g, "/");
     for (const ext of [".kt", ".kts"]) {
       for (const srcRoot of [
         "",
@@ -615,6 +1307,124 @@ var kotlin = {
   },
   defaultExclude: ["build", "\\.gradle", "\\.idea"]
 };
+var cSharp = {
+  id: "c-sharp",
+  extensions: [".cs"],
+  commentStyle: "c-style",
+  importPatterns: [
+    // using Namespace; and using Namespace.SubNamespace;
+    // using static Namespace.Class;
+    // Skip: using Alias = Namespace.Class; (captured but resolved same way)
+    { regex: /^using\s+(?:static\s+)?([\w.]+)\s*;/gm }
+  ],
+  resolveImport(importPath, _sourceFile, rootDir, projectFiles) {
+    const segments = importPath.split(".");
+    for (let i = segments.length; i > 0; i--) {
+      const filePath = segments.slice(0, i).join("/") + ".cs";
+      for (const srcRoot of ["", "src/", "lib/"]) {
+        const full = join3(rootDir, srcRoot, filePath);
+        if (projectFiles.has(full)) return full;
+      }
+    }
+    for (let start = 0; start < segments.length; start++) {
+      const dirPath = segments.slice(start).join("/");
+      for (const srcRoot of ["", "src/", "lib/"]) {
+        const prefix = join3(rootDir, srcRoot, dirPath) + "/";
+        for (const f of projectFiles) {
+          if (f.startsWith(prefix) && f.endsWith(".cs")) return f;
+        }
+      }
+    }
+    return null;
+  },
+  defaultExclude: ["bin", "obj", "\\.vs", "packages", "TestResults"]
+};
+var dart = {
+  id: "dart",
+  extensions: [".dart"],
+  commentStyle: "c-style",
+  importPatterns: [
+    // import 'package:pkg/file.dart'; or import 'relative/path.dart';
+    { regex: /^import\s+['"]([^'"]+)['"]/gm },
+    // export 'file.dart'; (re-exports create dependencies too)
+    { regex: /^export\s+['"]([^'"]+)['"]/gm }
+  ],
+  resolveImport(importPath, sourceFile, rootDir, projectFiles) {
+    if (importPath.startsWith("dart:")) return null;
+    if (importPath.startsWith("package:")) {
+      const ownPackage = dartPackageName(rootDir);
+      if (!ownPackage) return null;
+      const prefix = `package:${ownPackage}/`;
+      if (!importPath.startsWith(prefix)) return null;
+      const relPath = importPath.slice(prefix.length);
+      const full = join3(rootDir, "lib", relPath);
+      if (projectFiles.has(full)) return full;
+      return null;
+    }
+    const resolved = resolve3(dirname(sourceFile), importPath);
+    if (projectFiles.has(resolved)) return resolved;
+    return null;
+  },
+  defaultExclude: ["\\.dart_tool", "build", "\\.packages"]
+};
+var dartPackageCache = /* @__PURE__ */ new Map();
+function dartPackageName(rootDir) {
+  if (dartPackageCache.has(rootDir)) return dartPackageCache.get(rootDir);
+  try {
+    const content = readFileSync(join3(rootDir, "pubspec.yaml"), "utf-8");
+    const match = content.match(/^name:\s*(\S+)/m);
+    const name = match ? match[1] : null;
+    dartPackageCache.set(rootDir, name);
+    return name;
+  } catch {
+    dartPackageCache.set(rootDir, null);
+    return null;
+  }
+}
+var scala = {
+  id: "scala",
+  extensions: [".scala", ".sc"],
+  commentStyle: "c-style",
+  importPatterns: [],
+  // handled by extractImports for grouped syntax
+  extractImports(content) {
+    const imports = [];
+    const importRegex = /\bimport\s+([\w.]+(?:\.\{[^}]+\}|\.\w+|\._))/gm;
+    let match;
+    while ((match = importRegex.exec(content)) !== null) {
+      const full = match[1];
+      const braceMatch = full.match(/^([\w.]+)\.\{([^}]+)\}$/);
+      if (braceMatch) {
+        const prefix = braceMatch[1];
+        const items = braceMatch[2].split(",");
+        for (const item of items) {
+          const trimmed = item.trim().split(/\s+/)[0];
+          if (trimmed === "_") continue;
+          imports.push(`${prefix}.${trimmed}`);
+        }
+      } else if (full.endsWith("._")) {
+        continue;
+      } else {
+        imports.push(full);
+      }
+    }
+    return imports;
+  },
+  resolveImport(importPath, _sourceFile, rootDir, projectFiles) {
+    const segments = importPath.split(".");
+    for (let i = segments.length; i > 0; i--) {
+      const filePath = segments.slice(0, i).join("/");
+      for (const ext of [".scala", ".sc"]) {
+        for (const srcRoot of ["", "src/main/scala/", "src/", "app/"]) {
+          const full = join3(rootDir, srcRoot, filePath + ext);
+          if (projectFiles.has(full)) return full;
+        }
+      }
+    }
+    return null;
+  },
+  defaultExclude: ["target", "\\.bsp", "\\.metals", "\\.bloop"]
+};
 var LANGUAGE_CONFIGS = {
   javascript: null,
   // handled by DependencyCruiserEngine
@@ -623,10 +1433,13 @@ var LANGUAGE_CONFIGS = {
   go,
   java,
   "c-cpp": cCpp,
+  "c-sharp": cSharp,
   ruby,
   php,
   swift,
-  kotlin
+  kotlin,
+  dart,
+  scala
 };
 function getLanguageConfig(id) {
   return LANGUAGE_CONFIGS[id] ?? null;