sigmap 1.5.0

package/src/map/import-graph.js

@@ -0,0 +1,148 @@
+'use strict';
+
+/**
+ * Import graph analyzer.
+ * Extracts relative import relationships from JS/TS/Python files
+ * and detects circular dependencies.
+ *
+ * @param {string[]} files — absolute file paths to analyze
+ * @param {string}   cwd   — project root for relative path display
+ * @returns {string} formatted section content (empty string if nothing found)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const JS_EXTS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs']);
+const PY_EXTS = new Set(['.py', '.pyw']);
+
+// ---------------------------------------------------------------------------
+// Import extraction per language
+// ---------------------------------------------------------------------------
+function extractImports(filePath, content, fileSet) {
+  const ext = path.extname(filePath).toLowerCase();
+  const dir = path.dirname(filePath);
+  const found = [];
+
+  if (JS_EXTS.has(ext)) {
+    // ES: import ... from './foo'  or  import './side-effect'
+    const re1 = /(?:^|[\r\n])\s*import\s+(?:[^'";\r\n]*?\s+from\s+)?['"](\.[^'"]+)['"]/g;
+    let m;
+    while ((m = re1.exec(content)) !== null) {
+      const resolved = resolveJsPath(dir, m[1], fileSet);
+      if (resolved) found.push(resolved);
+    }
+    // CommonJS: require('./foo')
+    const re2 = /\brequire\s*\(\s*['"](\.[^'"]+)['"]\s*\)/g;
+    while ((m = re2.exec(content)) !== null) {
+      const resolved = resolveJsPath(dir, m[1], fileSet);
+      if (resolved) found.push(resolved);
+    }
+  }
+
+  if (PY_EXTS.has(ext)) {
+    // from .module import ...  /  from ..pkg import ...
+    const re = /^[ \t]*from\s+(\.+[\w.]*)\s+import/gm;
+    let m;
+    while ((m = re.exec(content)) !== null) {
+      const dotCount = (m[1].match(/^\.+/) || [''])[0].length;
+      const modPart = m[1].slice(dotCount).replace(/\./g, '/');
+      let base = dir;
+      for (let i = 1; i < dotCount; i++) base = path.dirname(base);
+      const candidate = modPart ? path.join(base, modPart + '.py') : null;
+      if (candidate && fileSet.has(candidate)) found.push(candidate);
+    }
+  }
+
+  return [...new Set(found)];
+}
+
+function resolveJsPath(dir, importStr, fileSet) {
+  const base = path.resolve(dir, importStr);
+  const candidates = [
+    base,
+    base + '.ts', base + '.tsx',
+    base + '.js', base + '.jsx',
+    base + '/index.ts', base + '/index.js',
+  ];
+  for (const c of candidates) {
+    if (fileSet.has(c)) return c;
+  }
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// Cycle detection (DFS with path tracking)
+// ---------------------------------------------------------------------------
+function detectCycles(graph) {
+  const cycles = [];
+  const visited = new Set();
+  const onStack = new Set();
+  const stackArr = [];
+
+  function dfs(node) {
+    if (onStack.has(node)) {
+      const start = stackArr.indexOf(node);
+      if (start !== -1) cycles.push([...stackArr.slice(start), node]);
+      return;
+    }
+    if (visited.has(node)) return;
+
+    onStack.add(node);
+    stackArr.push(node);
+    for (const dep of (graph.get(node) || [])) dfs(dep);
+    stackArr.pop();
+    onStack.delete(node);
+    visited.add(node);
+  }
+
+  for (const node of graph.keys()) {
+    if (!visited.has(node)) dfs(node);
+  }
+  return cycles;
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+function analyze(files, cwd) {
+  const fileSet = new Set(files.map((f) => path.resolve(f)));
+  const graph = new Map();
+
+  for (const filePath of files) {
+    let content;
+    try { content = fs.readFileSync(filePath, 'utf8'); } catch (_) { continue; }
+    const deps = extractImports(path.resolve(filePath), content, fileSet);
+    if (deps.length > 0) graph.set(path.resolve(filePath), deps);
+  }
+
+  if (graph.size === 0) return '';
+
+  const cycles = detectCycles(graph);
+  const cycleNodeSet = new Set(cycles.flatMap((c) => c));
+
+  const lines = [];
+  const sorted = [...graph.entries()].sort((a, b) => a[0].localeCompare(b[0]));
+
+  for (const [fp, deps] of sorted) {
+    const rel = path.relative(cwd, fp).replace(/\\/g, '/');
+    const depList = deps.map((d) => {
+      const drel = path.relative(cwd, d).replace(/\\/g, '/');
+      return cycleNodeSet.has(d) ? `${drel} ⚠` : drel;
+    });
+    lines.push(`${rel} → ${depList.join(', ')}`);
+  }
+
+  if (cycles.length > 0) {
+    lines.push('');
+    lines.push('Circular dependencies detected:');
+    for (const cycle of cycles) {
+      const relPath = cycle.map((n) => path.relative(cwd, n).replace(/\\/g, '/')).join(' → ');
+      lines.push(`  ⚠ ${relPath}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+module.exports = { analyze };

package/src/map/route-table.js

@@ -0,0 +1,127 @@
+'use strict';
+
+/**
+ * HTTP route table extractor.
+ * Detects routes in Express, Fastify, NestJS, Flask, FastAPI, Gin, Spring.
+ *
+ * @param {string[]} files — absolute file paths to analyze
+ * @param {string}   cwd   — project root for relative path display
+ * @returns {string} formatted markdown table (empty string if no routes found)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const JS_EXTS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs']);
+const PY_EXTS = new Set(['.py', '.pyw']);
+
+function shouldSkipFile(rel) {
+  const normalized = rel.replace(/\\/g, '/').toLowerCase();
+  return /(^|\/)(gen-context|gen-project-map)\.js$/.test(normalized);
+}
+
+function analyze(files, cwd) {
+  const routes = [];
+
+  for (const filePath of files) {
+    const ext = path.extname(filePath).toLowerCase();
+    const rel = path.relative(cwd, filePath).replace(/\\/g, '/');
+    if (shouldSkipFile(rel)) continue;
+    let content;
+    try { content = fs.readFileSync(filePath, 'utf8'); } catch (_) { continue; }
+
+    // -----------------------------------------------------------------------
+    // Express / Fastify / Koa (JS/TS)
+    // -----------------------------------------------------------------------
+    if (JS_EXTS.has(ext)) {
+      // app.get('/path', ...) / router.post('/path') / fastify.put('/path')
+      const re1 = /\b(?:app|router|fastify|server|koa|instance)\.(get|post|put|patch|delete|head|options|all)\s*\(\s*['"`]([^'"`]+)['"`]/gi;
+      let m;
+      while ((m = re1.exec(content)) !== null) {
+        routes.push({ method: m[1].toUpperCase(), path: m[2], file: rel });
+      }
+
+      // NestJS decorators: @Get('/path') @Post('/path')
+      const re2 = /@(Get|Post|Put|Patch|Delete|Head|Options|All)\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/g;
+      while ((m = re2.exec(content)) !== null) {
+        routes.push({ method: m[1].toUpperCase(), path: m[2], file: rel });
+      }
+
+      // NestJS: @Get() with no path
+      const re3 = /@(Get|Post|Put|Patch|Delete)\s*\(\s*\)/g;
+      while ((m = re3.exec(content)) !== null) {
+        routes.push({ method: m[1].toUpperCase(), path: '/', file: rel });
+      }
+    }
+
+    // -----------------------------------------------------------------------
+    // Flask / FastAPI (Python)
+    // -----------------------------------------------------------------------
+    if (PY_EXTS.has(ext)) {
+      // @app.route('/path', methods=['GET', 'POST'])
+      const re1 = /@[\w.]+\.route\s*\(\s*['"]([^'"]+)['"]([\s\S]{0,150}?)\)/g;
+      let m;
+      while ((m = re1.exec(content)) !== null) {
+        const routePath = m[1];
+        const methodsMatch = m[2].match(/methods\s*=\s*\[([^\]]+)\]/);
+        if (methodsMatch) {
+          const methods = methodsMatch[1].match(/['"]([A-Z]+)['"]/g) || [];
+          for (const meth of methods) {
+            routes.push({ method: meth.replace(/['"]/g, ''), path: routePath, file: rel });
+          }
+        } else {
+          routes.push({ method: 'GET', path: routePath, file: rel });
+        }
+      }
+
+      // @app.get('/path')  @router.post('/path')  FastAPI style
+      const re2 = /@[\w.]+\.(get|post|put|patch|delete|head|options)\s*\(\s*['"]([^'"]+)['"]/g;
+      while ((m = re2.exec(content)) !== null) {
+        routes.push({ method: m[1].toUpperCase(), path: m[2], file: rel });
+      }
+    }
+
+    // -----------------------------------------------------------------------
+    // Go — Gin / Echo / chi / net/http
+    // -----------------------------------------------------------------------
+    if (ext === '.go') {
+      // r.GET("/path", handler)
+      const re1 = /\b\w+\.(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s*\(\s*["']([^"']+)["']/g;
+      let m;
+      while ((m = re1.exec(content)) !== null) {
+        routes.push({ method: m[1], path: m[2], file: rel });
+      }
+      // http.HandleFunc("/path", handler)
+      const re2 = /http\.HandleFunc\s*\(\s*["']([^"']+)["']/g;
+      while ((m = re2.exec(content)) !== null) {
+        routes.push({ method: 'ANY', path: m[1], file: rel });
+      }
+    }
+
+    // -----------------------------------------------------------------------
+    // Spring (Java)
+    // -----------------------------------------------------------------------
+    if (ext === '.java') {
+      // @GetMapping("/path") @PostMapping @RequestMapping
+      const re1 = /@(Get|Post|Put|Patch|Delete|Request)Mapping\s*\(\s*(?:value\s*=\s*)?["']([^"']+)["']/g;
+      let m;
+      while ((m = re1.exec(content)) !== null) {
+        const method = m[1] === 'Request' ? 'ANY' : m[1].toUpperCase();
+        routes.push({ method, path: m[2], file: rel });
+      }
+    }
+  }
+
+  if (routes.length === 0) return '';
+
+  const lines = [
+    '| Method | Path | File |',
+    '|--------|------|------|',
+  ];
+  for (const r of routes) {
+    lines.push(`| ${r.method} | ${r.path} | ${r.file} |`);
+  }
+  return lines.join('\n');
+}
+
+module.exports = { analyze };