openkrak-mcp 1.0.18 → 1.1.0

package/dist/index.js

@@ -241629,13 +241629,63 @@ function createLogger(component) {
     process.stderr
   );
 }
-var SUPPORTED_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"];
+var SUPPORTED_EXTENSIONS = [
+  // JavaScript / TypeScript
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  // Python
+  ".py",
+  // Go
+  ".go",
+  // Rust
+  ".rs",
+  // Java
+  ".java",
+  // C#
+  ".cs"
+];
+var LANGUAGE_BY_EXT = {
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".py": "python",
+  ".go": "go",
+  ".rs": "rust",
+  ".java": "java",
+  ".cs": "csharp"
+};
+function isTypeScriptOrJS(filePath) {
+  const ext2 = import_path.default.extname(filePath).toLowerCase();
+  return [".ts", ".tsx", ".js", ".jsx"].includes(ext2);
+}
 async function discoverFiles(repoRoot) {
   const patterns = SUPPORTED_EXTENSIONS.map((ext2) => `**/*${ext2}`);
   const files = await glob(patterns, {
     cwd: repoRoot,
     absolute: false,
-    ignore: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.git/**", "**/*.d.ts"]
+    ignore: [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/.git/**",
+      "**/*.d.ts",
+      // Python
+      "**/__pycache__/**",
+      "**/.venv/**",
+      "**/venv/**",
+      "**/*.pyc",
+      // Go
+      "**/vendor/**",
+      // Rust
+      "**/target/**",
+      // Java / C#
+      "**/bin/**",
+      "**/obj/**",
+      "**/.gradle/**"
+    ]
   });
   return files.map((f) => f.replace(/\\/g, "/")).sort();
 }
@@ -242516,7 +242566,7 @@ function detectSecurityPatterns(filePath, content) {
 }
 async function classifyTopology(repoRoot, allFiles) {
   const type = await detectProjectType(repoRoot);
-  const framework = await detectFramework(repoRoot);
+  const framework = await detectFramework(repoRoot, allFiles);
   const entryPoints = detectEntryPoints(allFiles);
   const layers = detectLayers(allFiles);
   const modules = detectModules(allFiles);
@@ -242539,9 +242589,8 @@ async function detectProjectType(repoRoot) {
   }
   return "monolith";
 }
-async function detectFramework(repoRoot) {
+async function readFrameworkFromPkg(pkgPath) {
   try {
-    const pkgPath = import_path4.default.join(repoRoot, "package.json");
     const pkg = JSON.parse(await import_promises3.default.readFile(pkgPath, "utf-8"));
     const deps = { ...pkg.dependencies, ...pkg.devDependencies };
     if (deps["next"]) return `next@${deps["next"].replace(/[\^~]/g, "")}`;
@@ -242558,30 +242607,68 @@ async function detectFramework(repoRoot) {
     if (deps["@angular/core"]) return "angular";
   } catch {
   }
-  try {
-    await import_promises3.default.access(import_path4.default.join(repoRoot, "next.config.js"));
-    return "next";
-  } catch {
-  }
-  try {
-    await import_promises3.default.access(import_path4.default.join(repoRoot, "next.config.mjs"));
-    return "next";
-  } catch {
+  return null;
+}
+async function findSubPackageRoots(repoRoot, allFiles) {
+  const candidates = /* @__PURE__ */ new Set();
+  for (const f of allFiles) {
+    const parts = f.split("/");
+    if (parts.length >= 1) candidates.add(parts[0]);
+    if (parts.length >= 2) candidates.add(`${parts[0]}/${parts[1]}`);
   }
-  try {
-    await import_promises3.default.access(import_path4.default.join(repoRoot, "next.config.ts"));
-    return "next";
-  } catch {
+  const roots = [];
+  for (const candidate of candidates) {
+    const pkgPath = import_path4.default.join(repoRoot, candidate, "package.json");
+    try {
+      await import_promises3.default.access(pkgPath);
+      roots.push(candidate);
+    } catch {
+    }
   }
-  try {
-    await import_promises3.default.access(import_path4.default.join(repoRoot, "vite.config.ts"));
-    return "vite";
-  } catch {
+  return roots;
+}
+async function detectFramework(repoRoot, allFiles) {
+  const rootFramework = await readFrameworkFromPkg(import_path4.default.join(repoRoot, "package.json"));
+  if (rootFramework) return rootFramework;
+  const configChecks = [
+    ["next.config.js", "next"],
+    ["next.config.mjs", "next"],
+    ["next.config.ts", "next"],
+    ["vite.config.ts", "vite"],
+    ["astro.config.mjs", "astro"]
+  ];
+  for (const [cfg, name] of configChecks) {
+    try {
+      await import_promises3.default.access(import_path4.default.join(repoRoot, cfg));
+      return name;
+    } catch {
+    }
   }
-  try {
-    await import_promises3.default.access(import_path4.default.join(repoRoot, "astro.config.mjs"));
-    return "astro";
-  } catch {
+  if (allFiles && allFiles.length > 0) {
+    const subRoots = await findSubPackageRoots(repoRoot, allFiles);
+    const detected = [];
+    for (const subRoot of subRoots) {
+      const fw = await readFrameworkFromPkg(import_path4.default.join(repoRoot, subRoot, "package.json"));
+      if (fw && !detected.includes(fw)) detected.push(fw);
+    }
+    for (const subRoot of subRoots) {
+      for (const [cfg, name] of configChecks) {
+        try {
+          await import_promises3.default.access(import_path4.default.join(repoRoot, subRoot, cfg));
+          if (!detected.includes(name)) detected.push(name);
+        } catch {
+        }
+      }
+    }
+    if (detected.length === 1) return detected[0];
+    if (detected.length > 1) {
+      const prefixCount = /* @__PURE__ */ new Map();
+      for (const d of detected) {
+        const prefix = d.split("@")[0];
+        prefixCount.set(prefix, (prefixCount.get(prefix) ?? 0) + 1);
+      }
+      return [...prefixCount.entries()].map(([fw, count]) => count > 1 ? `${fw} (\xD7${count})` : fw).join(", ");
+    }
   }
   return null;
 }
@@ -242593,11 +242680,15 @@ function detectEntryPoints(files) {
       entries.push({ path: f, type });
       continue;
     }
-    if (/^app\/.*page\.(ts|js)x?$/.test(f) || /^app\/layout\.(ts|js)x?$/.test(f)) {
+    if (/(?:^|\/)app\/.*page\.(ts|js)x?$/.test(f) || /(?:^|\/)app\/layout\.(ts|js)x?$/.test(f)) {
+      entries.push({ path: f, type: "api" });
+      continue;
+    }
+    if (/(?:^|\/)app\/.*(?:loading|error|not-found)\.(ts|js)x?$/.test(f)) {
       entries.push({ path: f, type: "api" });
       continue;
     }
-    if (/^app\/.*route\.(ts|js)x?$/.test(f) || /^pages\/api\//.test(f)) {
+    if (/(?:^|\/)app\/.*route\.(ts|js)x?$/.test(f) || /(?:^|\/)pages\/api\//.test(f)) {
       entries.push({ path: f, type: "api" });
       continue;
     }
@@ -242763,6 +242854,35 @@ function extractCyclomaticComplexity(ast, filePath) {
   return fileMetrics;
 }
 var logger = createLogger("deepstrike");
+function detectPrimaryLanguage(filePaths) {
+  const counts = computeLanguageCounts(filePaths);
+  let maxLang = "typescript";
+  let maxCount = 0;
+  for (const [lang, count] of Object.entries(counts)) {
+    if (count > maxCount) {
+      maxCount = count;
+      maxLang = lang;
+    }
+  }
+  return maxLang;
+}
+function computeLanguageBreakdown(filePaths) {
+  const counts = computeLanguageCounts(filePaths);
+  const total = filePaths.length || 1;
+  return Object.entries(counts).map(([name, count]) => ({
+    name,
+    percentage: Math.round(count / total * 100)
+  }));
+}
+function computeLanguageCounts(filePaths) {
+  const counts = {};
+  for (const fp of filePaths) {
+    const ext2 = fp.slice(fp.lastIndexOf(".")).toLowerCase();
+    const lang = LANGUAGE_BY_EXT[ext2] ?? "unknown";
+    counts[lang] = (counts[lang] ?? 0) + 1;
+  }
+  return counts;
+}
 async function runDeepStrike(store, opts) {
   const start = Date.now();
   const scanId = store.getMeta().scan_id;
@@ -242808,7 +242928,7 @@ async function runDeepStrike(store, opts) {
     allFindings.push(...secFindings);
     try {
       const partialEntry = await buildFileIndexEntry(opts.repoRoot, relPath, content, symbols.length);
-      const cyclomaticByFunc = extractCyclomaticComplexity(ast, relPath);
+      const cyclomaticByFunc = isTypeScriptOrJS(relPath) ? extractCyclomaticComplexity(parseFile(absPath, content, opts.repoRoot).ast, relPath) : /* @__PURE__ */ new Map();
       const entry = {
         ...partialEntry,
         complexity: {
@@ -242840,8 +242960,8 @@ async function runDeepStrike(store, opts) {
     name: repoName,
     path: opts.repoRoot,
     remote_url: null,
-    primary_language: "typescript",
-    languages: [{ name: "typescript", percentage: 100 }],
+    primary_language: detectPrimaryLanguage(fileIndexEntries.map((e) => e.path)),
+    languages: computeLanguageBreakdown(fileIndexEntries.map((e) => e.path)),
     framework: null,
     total_files: relFiles.length,
     total_loc: fileIndexEntries.reduce((s, e) => s + e.loc, 0),
@@ -243034,6 +243154,73 @@ function buildImpactChains(candidates) {
 function describeMechanism(root, related, depth) {
   return `${root.type} in ${root.file} propagates via ${depth} dependency hop(s) to ${related.type} in ${related.file}`;
 }
+var CROSS_BUNDLE_SAFE_EXPORTS = /* @__PURE__ */ new Set([
+  // action_contracts
+  "ActionType",
+  "PlannedAction",
+  "ShellCommandSpec",
+  "TEST_COMMAND_WHITELIST",
+  "SENSITIVE_KEY_RE",
+  "DESTRUCTIVE_RE",
+  // orchestrator / plan
+  "OrchestratorPlan",
+  "OrchestratorStep",
+  // contracts / store
+  "MahadataStore",
+  "InMemoryMahadataStore",
+  "Mahadata",
+  "TokenCounter",
+  "LLMClientConfig",
+  // handlers exposed via MCP tool layer
+  "handleAnalyzeRepo",
+  "handleBlastRadius",
+  "handleGetHotspots",
+  "handleGetMahadata",
+  // shared utilities
+  "calculateRiskScore",
+  "assembleGraph",
+  "classifyTopology",
+  "resolveTaskDependencies",
+  // constants / prompts
+  "SYSTEM_PROMPT",
+  "JSON_TAG_RE",
+  // Next.js / framework reserved exports — always safe
+  "metadata",
+  "nextConfig",
+  "geistSans",
+  "geistMono",
+  "default"
+  // default exports are always externally consumable
+]);
+var SAFE_EXPORT_PREFIXES = [
+  "handle",
+  // MCP handlers
+  "create",
+  // factory functions
+  "build",
+  // builder functions
+  "run"
+  // runner functions exposed to orchestrator
+];
+var CROSS_BUNDLE_BARREL_PATTERNS = [
+  /\/contracts\/index\.ts$/,
+  /\/action_contracts\/index\.ts$/,
+  /\/action_layer\/index\.ts$/,
+  /\/shared\/index\.ts$/,
+  /\/shared\/logger\/index\.ts$/,
+  /\/orchestrator\/index\.ts$/
+];
+function isCrossBundleSafeSymbol(symbolName, filePath) {
+  if (CROSS_BUNDLE_SAFE_EXPORTS.has(symbolName)) return true;
+  for (const prefix of SAFE_EXPORT_PREFIXES) {
+    if (symbolName.startsWith(prefix)) return true;
+  }
+  if (symbolName === "logger" || symbolName.startsWith("logger")) return true;
+  for (const pattern of CROSS_BUNDLE_BARREL_PATTERNS) {
+    if (pattern.test(filePath)) return true;
+  }
+  return false;
+}
 function tagNoise(findings, chains) {
   const suppressionReasons = /* @__PURE__ */ new Map();
   const severityOrder = {
@@ -243043,6 +243230,17 @@ function tagNoise(findings, chains) {
     low: 1,
     info: 0
   };
+  for (const f of findings) {
+    if (f.type !== "dead_code") continue;
+    if (suppressionReasons.has(f.id)) continue;
+    const symbolName = f.symbol ? f.symbol.split("::")[1] ?? f.symbol : "";
+    if (isCrossBundleSafeSymbol(symbolName, f.file)) {
+      suppressionReasons.set(
+        f.id,
+        `Cross-bundle false positive: '${symbolName}' is a known exported interface consumed outside this scan boundary.`
+      );
+    }
+  }
   const groupedByFileType = /* @__PURE__ */ new Map();
   for (const f of findings) {
     const key = `${f.file}::${f.type}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openkrak-mcp",
-  "version": "1.0.18",
+  "version": "1.1.0",
   "description": "OpenKrak MCP Server - AI coding intelligence via Dorchester engine",
   "mcpName": "io.github.FrnzJulianBergmann/openkrak",
   "type": "commonjs",