@plumpslabs/kuma 2.3.20 → 2.3.22

package/dist/kumaCodeScanner-J6B2EHGI.js

@@ -1,563 +0,0 @@
-import {
-  addEdge,
-  nodeId,
-  upsertNode
-} from "./chunk-PRUTTZBS.js";
-import "./chunk-3BRBJZ7P.js";
-import {
-  getProjectRoot
-} from "./chunk-E2KFPEBT.js";
-
-// src/engine/kumaCodeScanner.ts
-import fastGlob from "fast-glob";
-import fs from "fs";
-import path from "path";
-var DEFAULT_MAX_FILES = 200;
-var DEFAULT_MAX_FILE_SIZE = 100 * 1024;
-var fileCache = /* @__PURE__ */ new Map();
-var _cachedRoot = null;
-function getRoot() {
-  if (!_cachedRoot) _cachedRoot = getProjectRoot();
-  return _cachedRoot;
-}
-var FUNCTION_DECL_RE = /(?:export\s+)?(?:async\s+)?function\s*(?:\*\s*)?(\w+)\s*\(/g;
-var ARROW_FN_RE = /(?:export\s+)?(?:const|let|var)\s+(\w+)\s*[=:]\s*(?:async\s*)?(?:<[^>]+>\s*)?(?:\([\s\S]*?\)|\w+)\s*(?::\s*\w+(?:<[^>]*>)?)?\s*=>/g;
-var TYPED_ARROW_RE = /(?:export\s+)?(?:const|let|var)\s+(\w+)\s*:\s*(?:\w+(?:<[^>]*>)?)?\s*=\s*(?:async\s*)?(?:<[^>]+>\s*)?\(/g;
-var CLASS_RE = /(?:export\s+)?(?:abstract\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?(?:\s+implements\s+([\w,\s]+))?/g;
-var IMPORT_RE = /import\s+(?:\{([^}]*)\}\s+from\s+)?(?:\w+\s+from\s+)?(?:\*\s+as\s+\w+\s+from\s+)?['"]([^'"]+)['"]/g;
-var JSX_RETURN_RE = /return\s*\(?\s*</;
-var JSX_ELEMENT_RE = /<([A-Z]\w+)[\s/>]/g;
-var JSX_IMPLICIT_RE = /=>\s*(?:\(\s*)?</;
-var EXPRESS_ROUTE_RE = /\.(get|post|put|delete|patch)\s*\(\s*['"]([^'"]+)['"]\s*,\s*(\w+)/g;
-var HONO_ROUTE_RE = /c\.(get|post|put|delete|patch)\s*\(\s*['"]([^'"]+)['"]/g;
-var EXPORT_RE = /export\s+(?:default\s+)?(\w+)/g;
-var CALL_RE = /(\w+)\s*\(/g;
-var TEST_PATTERNS = [".test.", ".spec.", "__tests__", "/test/"];
-var knownComponents = /* @__PURE__ */ new Set();
-var knownFunctions = /* @__PURE__ */ new Set();
-var symbolLocations = /* @__PURE__ */ new Map();
-function lineAt(content, index) {
-  return content.substring(0, index).split("\n").length;
-}
-function getDirectoryDirs(filePaths) {
-  const dirs = /* @__PURE__ */ new Set();
-  for (const fp of filePaths) {
-    let dir = path.dirname(fp);
-    while (dir && dir !== "." && dir !== "/") {
-      dirs.add(dir);
-      dir = path.dirname(dir);
-    }
-  }
-  return [...dirs].sort();
-}
-async function scanCodebase(options = {}) {
-  const root = getRoot();
-  const maxFiles = options.maxFiles ?? DEFAULT_MAX_FILES;
-  const maxFileSize = options.maxFileSize ?? DEFAULT_MAX_FILE_SIZE;
-  const result = { nodeCount: 0, edgeCount: 0, filesScanned: 0, errors: [] };
-  const includePatterns = options.include || [
-    "src/**/*.{ts,tsx,js,jsx}",
-    "app/**/*.{ts,tsx,js,jsx}",
-    "lib/**/*.{ts,tsx,js,jsx}",
-    "packages/**/*.{ts,tsx,js,jsx}",
-    "server/**/*.{ts,tsx,js,jsx}",
-    "api/**/*.{ts,tsx,js,jsx}"
-  ];
-  if (options.scope) {
-    includePatterns.length = 0;
-    if (options.scope.includes("/") || options.scope.includes(".")) {
-      includePatterns.push(options.scope);
-    } else {
-      includePatterns.push(`**/*${options.scope}*/**/*.{ts,tsx,js,jsx}`);
-      includePatterns.push(`**/*${options.scope}*.{ts,tsx,js,jsx}`);
-    }
-  }
-  const ignorePatterns = [
-    "**/node_modules/**",
-    "**/.git/**",
-    "**/dist/**",
-    "**/build/**",
-    "**/.next/**",
-    "**/coverage/**",
-    "**/*.d.ts"
-  ];
-  let files;
-  try {
-    files = await fastGlob(includePatterns, {
-      cwd: root,
-      ignore: ignorePatterns,
-      onlyFiles: true,
-      deep: options.scope ? 10 : 6,
-      dot: false
-    });
-  } catch (err) {
-    result.errors.push(`Glob failed: ${err}`);
-    return result;
-  }
-  knownComponents.clear();
-  knownFunctions.clear();
-  symbolLocations.clear();
-  const scannedCount = Math.min(files.length, maxFiles);
-  const allParsed = [];
-  const scannedFilePaths = [];
-  for (let i = 0; i < scannedCount; i++) {
-    const filePath = files[i];
-    const fullPath = path.join(root, filePath);
-    if (!fs.existsSync(fullPath)) continue;
-    const stat = fs.statSync(fullPath);
-    if (stat.size > maxFileSize) continue;
-    const mtime = stat.mtimeMs;
-    const cached = fileCache.get(filePath);
-    if (cached === mtime && !options.force) continue;
-    fileCache.set(filePath, mtime);
-    try {
-      const content = fs.readFileSync(fullPath, "utf-8");
-      const parsed = parseFile(filePath, content);
-      allParsed.push({ filePath, parsed, content });
-      scannedFilePaths.push(filePath);
-      for (const comp of parsed.components) {
-        knownComponents.add(comp.name);
-        if (!symbolLocations.has(comp.name)) symbolLocations.set(comp.name, filePath);
-      }
-      for (const fn of parsed.functions) {
-        knownFunctions.add(fn.name);
-        if (!symbolLocations.has(fn.name)) symbolLocations.set(fn.name, filePath);
-      }
-    } catch (err) {
-      result.errors.push(`Error scanning ${filePath}: ${err}`);
-    }
-  }
-  for (const { parsed } of allParsed) {
-    for (const cls of parsed.classes) {
-      knownFunctions.add(cls.name);
-      if (!symbolLocations.has(cls.name)) symbolLocations.set(cls.name, parsed.filePath);
-    }
-  }
-  for (const { filePath, parsed, content } of allParsed) {
-    try {
-      await recordParsedFile(filePath, parsed, content, result);
-      result.filesScanned++;
-    } catch (err) {
-      result.errors.push(`Error recording ${filePath}: ${err}`);
-    }
-  }
-  if (scannedFilePaths.length > 0) {
-    try {
-      const dirs = getDirectoryDirs(scannedFilePaths);
-      for (const dir of dirs) {
-        const moduleId = nodeId("module", dir);
-        await upsertNode({
-          id: moduleId,
-          type: "module",
-          name: dir,
-          metadata: { path: dir }
-        });
-        result.nodeCount++;
-        for (const fp of scannedFilePaths) {
-          if (path.dirname(fp) === dir) {
-            const fileId = nodeId("file", fp);
-            try {
-              await addEdge({ sourceId: moduleId, targetId: fileId, type: "owns" });
-              result.edgeCount++;
-            } catch {
-            }
-          }
-        }
-      }
-    } catch (err) {
-      result.errors.push(`Module nodes error: ${err}`);
-    }
-  }
-  return result;
-}
-function parseFile(filePath, content) {
-  const result = {
-    filePath,
-    functions: [],
-    classes: [],
-    components: [],
-    routes: [],
-    imports: [],
-    exports: [],
-    isTest: TEST_PATTERNS.some((p) => filePath.includes(p))
-  };
-  const lines = content.split("\n");
-  const isTsx = /\.(tsx|jsx)$/.test(filePath);
-  const hasJSX = isTsx && content.includes("<") && content.includes(">");
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const lineNum = i + 1;
-    const trimmed = line.trim();
-    if (trimmed.startsWith("//") || trimmed.startsWith("*") || trimmed.startsWith("/*")) continue;
-    let m;
-    FUNCTION_DECL_RE.lastIndex = 0;
-    while ((m = FUNCTION_DECL_RE.exec(line)) !== null) {
-      const fnName = m[1];
-      if (fnName) {
-        const prevLine = (lines[i - 1] || "").trim();
-        if (!prevLine.match(/^\s*(?:export\s+)?(?:abstract\s+)?class\s+/)) {
-          result.functions.push({ name: fnName, line: lineNum });
-        }
-      }
-    }
-    ARROW_FN_RE.lastIndex = 0;
-    while ((m = ARROW_FN_RE.exec(line)) !== null) {
-      const fnName = m[1];
-      if (fnName && !fnName.startsWith("_")) result.functions.push({ name: fnName, line: lineNum });
-    }
-    TYPED_ARROW_RE.lastIndex = 0;
-    while ((m = TYPED_ARROW_RE.exec(line)) !== null) {
-      const fnName = m[1];
-      if (fnName && !fnName.startsWith("_") && /^\s*(?:const|let|var)\s+/.test(line)) {
-        if (line.includes("=>") || line.includes("function(") || line.includes("async")) {
-          result.functions.push({ name: fnName, line: lineNum });
-        }
-      }
-    }
-    CLASS_RE.lastIndex = 0;
-    while ((m = CLASS_RE.exec(line)) !== null) {
-      const cls = { name: m[1], line: lineNum };
-      if (m[2]) cls.extends = m[2];
-      if (m[3]) cls.implements = m[3].split(",").map((s) => s.trim());
-      result.classes.push(cls);
-    }
-    IMPORT_RE.lastIndex = 0;
-    while ((m = IMPORT_RE.exec(line)) !== null) {
-      const symbols = m[1] ? m[1].split(",").map((s) => s.trim().split(" as ")[0].trim()) : [];
-      const source = m[2] || "";
-      if (source.startsWith(".") || source.startsWith("/")) {
-        result.imports.push({ source, symbols, isDefault: false });
-      }
-    }
-    EXPORT_RE.lastIndex = 0;
-    while ((m = EXPORT_RE.exec(line)) !== null) {
-      const exportName = m[1];
-      if (exportName && !["const", "let", "var", "function", "class", "interface", "type", "default"].includes(exportName)) {
-        result.exports.push(exportName);
-      }
-    }
-  }
-  if (hasJSX) {
-    for (const fn of [...result.functions]) {
-      const fnStartLine = fn.line - 1;
-      const endLine = Math.min(fnStartLine + 50, lines.length);
-      let isComponent = false;
-      for (let i = fnStartLine; i < endLine; i++) {
-        if (JSX_RETURN_RE.test(lines[i])) {
-          isComponent = true;
-          break;
-        }
-      }
-      if (!isComponent && JSX_IMPLICIT_RE.test(lines[fnStartLine])) isComponent = true;
-      if (!isComponent && fnStartLine + 1 < endLine) {
-        const nextLine = lines[fnStartLine + 1].trim();
-        if (nextLine.startsWith("<") || nextLine.startsWith("(") || nextLine.startsWith("<>")) isComponent = true;
-      }
-      if (isComponent) {
-        result.components.push({ name: fn.name, line: fn.line });
-        result.functions = result.functions.filter((f) => f.name !== fn.name);
-      }
-    }
-  }
-  let rm;
-  EXPRESS_ROUTE_RE.lastIndex = 0;
-  while ((rm = EXPRESS_ROUTE_RE.exec(content)) !== null) {
-    result.routes.push({
-      method: rm[1].toUpperCase(),
-      pathPattern: rm[2],
-      handler: rm[3],
-      line: lineAt(content, rm.index)
-    });
-  }
-  HONO_ROUTE_RE.lastIndex = 0;
-  while ((rm = HONO_ROUTE_RE.exec(content)) !== null) {
-    result.routes.push({
-      method: rm[1].toUpperCase(),
-      pathPattern: rm[2],
-      handler: "",
-      line: lineAt(content, rm.index)
-    });
-  }
-  return result;
-}
-async function recordParsedFile(filePath, parsed, content, result) {
-  const { functions, classes, components, routes, imports } = parsed;
-  const root = getRoot();
-  const fileNodeId = nodeId("file", filePath);
-  await upsertNode({ id: fileNodeId, type: "file", name: filePath });
-  result.nodeCount++;
-  if (parsed.isTest) {
-    const testNodeId = nodeId("test", filePath);
-    await upsertNode({ id: testNodeId, type: "test", name: filePath, filePath });
-    result.nodeCount++;
-    try {
-      await addEdge({ sourceId: fileNodeId, targetId: testNodeId, type: "contains" });
-      result.edgeCount++;
-    } catch {
-    }
-  }
-  for (const imp of imports) {
-    const resolved = resolveImportPath(filePath, imp.source, root);
-    if (resolved) {
-      const targetId = nodeId("file", resolved);
-      await upsertNode({ id: targetId, type: "file", name: resolved });
-      result.nodeCount++;
-      try {
-        await addEdge({ sourceId: fileNodeId, targetId, type: "imports" });
-        result.edgeCount++;
-      } catch {
-      }
-    }
-  }
-  function scopedId(type, name, fp) {
-    return `${type}::${fp}::${name}`;
-  }
-  for (const fn of functions) {
-    const fnNodeId = scopedId("function", fn.name, filePath);
-    await upsertNode({ id: fnNodeId, type: "function", name: fn.name, filePath });
-    result.nodeCount++;
-    try {
-      await addEdge({ sourceId: fileNodeId, targetId: fnNodeId, type: "contains" });
-      result.edgeCount++;
-    } catch {
-    }
-  }
-  for (const comp of components) {
-    const compNodeId = scopedId("component", comp.name, filePath);
-    await upsertNode({ id: compNodeId, type: "component", name: comp.name, filePath });
-    result.nodeCount++;
-    try {
-      await addEdge({ sourceId: fileNodeId, targetId: compNodeId, type: "contains" });
-      result.edgeCount++;
-    } catch {
-    }
-  }
-  for (const cls of classes) {
-    const clsNodeId = scopedId("class", cls.name, filePath);
-    await upsertNode({ id: clsNodeId, type: "class", name: cls.name, filePath });
-    result.nodeCount++;
-    try {
-      await addEdge({ sourceId: fileNodeId, targetId: clsNodeId, type: "contains" });
-      result.edgeCount++;
-    } catch {
-    }
-    if (cls.extends) {
-      const parentFile = symbolLocations.get(cls.extends) || filePath;
-      const parentId = scopedId("class", cls.extends, parentFile);
-      await upsertNode({ id: parentId, type: "class", name: cls.extends, filePath: parentFile });
-      result.nodeCount++;
-      try {
-        await addEdge({ sourceId: clsNodeId, targetId: parentId, type: "extends" });
-        result.edgeCount++;
-      } catch {
-      }
-    }
-    if (cls.implements) {
-      for (const iface of cls.implements) {
-        const ifaceId = nodeId("interface", iface);
-        await upsertNode({ id: ifaceId, type: "interface", name: iface });
-        result.nodeCount++;
-        try {
-          await addEdge({ sourceId: clsNodeId, targetId: ifaceId, type: "implements" });
-          result.edgeCount++;
-        } catch {
-        }
-      }
-    }
-  }
-  for (const route of routes) {
-    const routeName = `${route.method} ${route.pathPattern}`;
-    const routeNodeId = nodeId("api_route", routeName);
-    await upsertNode({
-      id: routeNodeId,
-      type: "api_route",
-      name: routeName,
-      filePath,
-      metadata: { method: route.method, path: route.pathPattern }
-    });
-    result.nodeCount++;
-    try {
-      await addEdge({ sourceId: fileNodeId, targetId: routeNodeId, type: "contains" });
-      result.edgeCount++;
-    } catch {
-    }
-    if (route.handler) {
-      const handlerPath = symbolLocations.get(route.handler) || filePath;
-      const handlerId = scopedId("function", route.handler, handlerPath);
-      await upsertNode({ id: handlerId, type: "function", name: route.handler, filePath: handlerPath });
-      result.nodeCount++;
-      try {
-        await addEdge({ sourceId: routeNodeId, targetId: handlerId, type: "routes" });
-        result.edgeCount++;
-      } catch {
-      }
-    }
-  }
-  if (content.includes("<")) {
-    JSX_ELEMENT_RE.lastIndex = 0;
-    let jm;
-    while ((jm = JSX_ELEMENT_RE.exec(content)) !== null) {
-      const subComp = jm[1];
-      if (knownComponents.has(subComp) && components.some((c) => c.name === subComp) === false) {
-        const tagLine = lineAt(content, jm.index);
-        const parentComp = components.find((c) => {
-          const endLine = c.line + 80;
-          return tagLine >= c.line && tagLine <= endLine;
-        });
-        if (parentComp) {
-          const childFile = symbolLocations.get(subComp) || filePath;
-          const parentId = scopedId("component", parentComp.name, filePath);
-          const childId = scopedId("component", subComp, childFile);
-          try {
-            await addEdge({ sourceId: parentId, targetId: childId, type: "composes" });
-            result.edgeCount++;
-          } catch {
-          }
-        }
-      }
-    }
-  }
-  const callContent = content.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/\/\/.*$/gm, " ").replace(/\/[^\n\s][^\n]*?\/[gimsuy]*/g, " ").replace(/['"`][^'"`]*['"`]/g, " ");
-  CALL_RE.lastIndex = 0;
-  const fileCalls = /* @__PURE__ */ new Set();
-  let cm;
-  while ((cm = CALL_RE.exec(callContent)) !== null) {
-    const callee = cm[1];
-    if (!callee || callee.length < 2) continue;
-    if ([
-      "if",
-      "for",
-      "while",
-      "switch",
-      "catch",
-      "return",
-      "typeof",
-      "delete",
-      "throw",
-      "import",
-      "export",
-      "function",
-      "class",
-      "new",
-      "try",
-      "yield",
-      "await",
-      "this",
-      "super",
-      "undefined",
-      "null",
-      "true",
-      "false",
-      "console",
-      "describe",
-      "it",
-      "test",
-      "expect",
-      "assert",
-      "beforeEach",
-      "afterEach",
-      "beforeAll",
-      "afterAll",
-      "jest",
-      "process",
-      "require",
-      "setTimeout",
-      "setInterval",
-      "clearTimeout",
-      "clearInterval",
-      "Math",
-      "JSON",
-      "Object",
-      "Array",
-      "String",
-      "Number",
-      "Boolean",
-      "Promise",
-      "Error",
-      "Date",
-      "RegExp",
-      "Map",
-      "Set",
-      "Symbol",
-      "fetch",
-      "localStorage",
-      "sessionStorage",
-      "exports",
-      "call",
-      "apply",
-      "bind",
-      "then",
-      "finally",
-      "resolve",
-      "reject",
-      "next",
-      "value",
-      "done"
-    ].includes(callee)) continue;
-    if (knownFunctions.has(callee)) {
-      const isSelf = functions.some((f) => f.name === callee) || components.some((c) => c.name === callee);
-      if (!isSelf && !fileCalls.has(callee)) {
-        fileCalls.add(callee);
-        const calleeFile = symbolLocations.get(callee) || filePath;
-        const fnId = `function::${calleeFile}::${callee}`;
-        try {
-          await addEdge({ sourceId: fileNodeId, targetId: fnId, type: "calls" });
-          result.edgeCount++;
-        } catch {
-        }
-      }
-    }
-  }
-}
-function resolveImportPath(fromFile, importPath, root) {
-  if (!importPath.startsWith(".") && !importPath.startsWith("/")) return null;
-  const fromDir = path.dirname(path.join(root, fromFile));
-  const exts = [".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js", "/index.jsx"];
-  for (const ext of exts) {
-    const resolved = path.resolve(fromDir, importPath + ext);
-    if (fs.existsSync(resolved)) return path.relative(root, resolved);
-  }
-  const dirPath = path.resolve(fromDir, importPath);
-  if (fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory()) {
-    for (const ext of [".ts", ".tsx", ".js", ".jsx"]) {
-      const indexPath = path.join(dirPath, `index${ext}`);
-      if (fs.existsSync(indexPath)) return path.relative(root, indexPath);
-    }
-  }
-  return null;
-}
-function formatScanResult(result) {
-  const lines = [
-    "\u{1F52C} **Kuma Code Scan Complete**",
-    `\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`,
-    "",
-    `\u{1F4C1} **${result.filesScanned}** files scanned`,
-    `\u{1F4CA} **${result.nodeCount}** nodes added to knowledge graph`,
-    `\u{1F517} **${result.edgeCount}** edges added to knowledge graph`
-  ];
-  if (result.errors.length > 0) {
-    lines.push("");
-    lines.push(`\u26A0\uFE0F **${result.errors.length}** warning(s):`);
-    for (const err of result.errors.slice(0, 5)) {
-      lines.push(`  \u2022 ${err.substring(0, 120)}`);
-    }
-    if (result.errors.length > 5) {
-      lines.push(`  \u2022 ... and ${result.errors.length - 5} more`);
-    }
-  }
-  lines.push(
-    "",
-    "\u{1F4A1} The knowledge graph now has richer code structure data.",
-    "\u{1F4A1} Use kuma_context({ action: 'visualize' }) to see the graph."
-  );
-  return lines.join("\n");
-}
-async function scanAndFormat(options = {}) {
-  const result = await scanCodebase(options);
-  return formatScanResult(result);
-}
-export {
-  formatScanResult,
-  scanAndFormat,
-  scanCodebase
-};