@vpxa/kb 0.1.1

package/packages/analyzers/dist/pattern-analyzer.js

@@ -0,0 +1,359 @@
+import { access, readdir, readFile } from "node:fs/promises";
+import { extname, join, relative } from "node:path";
+const DEFAULT_EXCLUDES = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "coverage",
+  ".turbo",
+  ".cache",
+  "cdk.out",
+  "__pycache__",
+  ".venv",
+  "target",
+  "bin",
+  "obj",
+  ".gradle",
+  "venv",
+  "env"
+]);
+const DIRECTORY_PATTERNS = [
+  {
+    dirs: ["adapters", "ports"],
+    pattern: "Hexagonal Architecture",
+    description: "Ports & adapters (hexagonal) separation"
+  },
+  {
+    dirs: ["domain", "infrastructure", "application"],
+    pattern: "Clean Architecture",
+    description: "Layered with domain/infrastructure separation"
+  },
+  {
+    dirs: ["controllers", "models"],
+    pattern: "MVC Pattern",
+    description: "Model-View-Controller structure"
+  },
+  {
+    dirs: ["repositories"],
+    pattern: "Repository Pattern",
+    description: "Data access abstraction via repositories"
+  },
+  { dirs: ["factories"], pattern: "Factory Pattern", description: "Object creation via factories" },
+  {
+    dirs: ["handlers"],
+    pattern: "Handler Pattern",
+    description: "Event/request handler separation"
+  },
+  {
+    dirs: ["middleware"],
+    pattern: "Middleware Pattern",
+    description: "Request pipeline middleware"
+  },
+  { dirs: ["hooks"], pattern: "React Hooks", description: "Custom React hooks for logic reuse" },
+  {
+    dirs: ["components"],
+    pattern: "Component Architecture",
+    description: "UI component-based structure"
+  },
+  {
+    dirs: ["stacks", "constructs"],
+    pattern: "CDK IaC",
+    description: "AWS CDK infrastructure as code"
+  },
+  {
+    dirs: ["lambdas", "functions"],
+    pattern: "Serverless",
+    description: "Serverless function architecture"
+  }
+];
+function collapseLocations(locations) {
+  if (locations.length <= 3) return locations;
+  const byDir = /* @__PURE__ */ new Map();
+  for (const loc of locations) {
+    const parts = loc.split("/");
+    const dir = parts.length > 1 ? parts.slice(0, -1).join("/") : ".";
+    const arr = byDir.get(dir);
+    if (arr) arr.push(loc);
+    else byDir.set(dir, [loc]);
+  }
+  const result = [];
+  for (const [dir, files] of byDir) {
+    if (files.length >= 3) {
+      result.push(`${dir}/ (${files.length} files)`);
+    } else {
+      result.push(...files);
+    }
+  }
+  return result.slice(0, 5);
+}
+const CODE_PATTERNS = [
+  {
+    regex: /container\.register|@injectable|@inject/i,
+    pattern: "Dependency Injection",
+    description: "IoC container or DI decorators"
+  },
+  {
+    regex: /\.pipe\(|Observable|BehaviorSubject/i,
+    pattern: "Reactive (RxJS)",
+    description: "Reactive programming with observables",
+    lang: "js"
+  },
+  {
+    regex: /createContext|useContext/i,
+    pattern: "React Context",
+    description: "React Context API for state sharing",
+    lang: "js"
+  },
+  {
+    regex: /createSlice|configureStore/i,
+    pattern: "Redux Toolkit",
+    description: "Redux state management",
+    lang: "js"
+  },
+  {
+    regex: /defineStore|usePinia/i,
+    pattern: "Pinia Store",
+    description: "Vue Pinia state management",
+    lang: "js"
+  },
+  {
+    regex: /\.(test|spec)\.[jt]sx?|describe\s*\(|\bit\s*\([\s'"]/i,
+    pattern: "Test Suite",
+    description: "Unit/integration test files"
+  },
+  {
+    regex: /@SpringBootApplication|@EnableAutoConfiguration/,
+    pattern: "Spring Boot",
+    description: "Spring Boot application framework",
+    lang: "java",
+    definitive: true
+  },
+  {
+    regex: /@Autowired|@Component|@Service|@Repository|@Controller/,
+    pattern: "Spring DI",
+    description: "Spring dependency injection",
+    lang: "java"
+  },
+  {
+    regex: /@RestController|@RequestMapping|@GetMapping|@PostMapping/,
+    pattern: "Spring REST",
+    description: "Spring REST API controllers",
+    lang: "java"
+  },
+  {
+    regex: /app\s*=\s*Flask\s*\(|@app\.route/,
+    pattern: "Flask",
+    description: "Flask web framework",
+    lang: "python"
+  },
+  {
+    regex: /app\s*=\s*FastAPI\s*\(|@app\.get|@app\.post/,
+    pattern: "FastAPI",
+    description: "FastAPI web framework",
+    lang: "python"
+  },
+  {
+    regex: /func\s+main\s*\(\s*\)|http\.ListenAndServe/,
+    pattern: "Go Application",
+    description: "Go main application",
+    lang: "go"
+  }
+];
+class PatternAnalyzer {
+  name = "patterns";
+  async analyze(rootPath, _options = {}) {
+    const startTime = Date.now();
+    const dirs = await this.collectDirectories(rootPath);
+    const dirPatterns = this.detectDirectoryPatterns(dirs, rootPath);
+    const files = await this.collectCodeFiles(rootPath);
+    const codePatterns = await this.detectCodePatterns(files, rootPath);
+    const allPatterns = [...dirPatterns, ...codePatterns];
+    const configPatterns = await this.detectConfigPatterns(rootPath);
+    const primaryBuild = configPatterns.find(
+      (p) => p.pattern === "Maven" || p.pattern === "Gradle" || p.pattern === "Gradle (Kotlin DSL)" || p.pattern === "Node.js Project" || p.pattern === "Go Module" || p.pattern === "Rust (Cargo)"
+    );
+    const secondaryLangPatterns = /* @__PURE__ */ new Set([
+      "Ruby (Bundler)",
+      "PHP (Composer)",
+      "Swift Package",
+      "SBT"
+    ]);
+    for (const cp of configPatterns) {
+      if (primaryBuild && secondaryLangPatterns.has(cp.pattern)) continue;
+      allPatterns.push(cp);
+    }
+    const output = this.formatMarkdown(allPatterns, rootPath);
+    return {
+      output,
+      data: { patterns: allPatterns, total: allPatterns.length },
+      meta: {
+        analyzedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        scope: rootPath,
+        fileCount: files.length,
+        durationMs: Date.now() - startTime
+      }
+    };
+  }
+  async collectDirectories(rootPath) {
+    const dirs = [];
+    const walk = async (dir, depth) => {
+      if (depth > 5) return;
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        if (DEFAULT_EXCLUDES.has(entry.name)) continue;
+        if (entry.name.startsWith(".")) continue;
+        const fullPath = join(dir, entry.name);
+        dirs.push(entry.name);
+        await walk(fullPath, depth + 1);
+      }
+    };
+    await walk(rootPath, 0);
+    return dirs;
+  }
+  async collectCodeFiles(rootPath) {
+    const files = [];
+    const codeExts = /* @__PURE__ */ new Set([
+      ".ts",
+      ".tsx",
+      ".js",
+      ".jsx",
+      ".java",
+      ".py",
+      ".go",
+      ".cs",
+      ".kt",
+      ".scala",
+      ".rb",
+      ".rs",
+      ".php",
+      ".swift"
+    ]);
+    const walk = async (dir) => {
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (DEFAULT_EXCLUDES.has(entry.name)) continue;
+        if (entry.name.startsWith(".")) continue;
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+          await walk(fullPath);
+        } else if (codeExts.has(extname(entry.name))) {
+          files.push(fullPath);
+        }
+      }
+    };
+    await walk(rootPath);
+    return files;
+  }
+  detectDirectoryPatterns(dirs, _rootPath) {
+    const dirSet = new Set(dirs.map((d) => d.toLowerCase()));
+    const matches = [];
+    for (const dp of DIRECTORY_PATTERNS) {
+      const found = dp.dirs.filter((d) => dirSet.has(d));
+      if (found.length === 0) continue;
+      if (dp.dirs.length > 1 && found.length < 2) continue;
+      matches.push({
+        pattern: dp.pattern,
+        description: dp.description,
+        locations: found.map((d) => `${d}/`),
+        confidence: found.length === dp.dirs.length ? "high" : "medium"
+      });
+    }
+    return matches;
+  }
+  async detectCodePatterns(files, rootPath) {
+    const matches = [];
+    const patternFiles = {};
+    const priorityFiles = files.filter(
+      (f) => /Application\.\w+$|Main\.\w+$|app\.\w+$|main\.\w+$/i.test(f) || /Controller|Service|Handler|Router/i.test(f)
+    );
+    const rest = files.filter((f) => !priorityFiles.includes(f));
+    const sampled = [...priorityFiles.slice(0, 50), ...rest.slice(0, 150)];
+    for (const filePath of sampled) {
+      try {
+        const content = await readFile(filePath, "utf-8");
+        const ext = extname(filePath).toLowerCase();
+        const fileLang = ext === ".java" || ext === ".kt" || ext === ".scala" ? "java" : ext === ".py" ? "python" : ext === ".go" ? "go" : "js";
+        for (const cp of CODE_PATTERNS) {
+          if (cp.lang && cp.lang !== fileLang) continue;
+          if (cp.regex.test(content)) {
+            if (!patternFiles[cp.pattern]) patternFiles[cp.pattern] = /* @__PURE__ */ new Set();
+            patternFiles[cp.pattern].add(relative(rootPath, filePath).replace(/\\/g, "/"));
+          }
+        }
+      } catch {
+      }
+    }
+    for (const cp of CODE_PATTERNS) {
+      const locations = patternFiles[cp.pattern];
+      if (locations && locations.size > 0) {
+        const collapsed = collapseLocations([...locations]);
+        matches.push({
+          pattern: cp.pattern,
+          description: cp.description,
+          locations: collapsed,
+          confidence: cp.definitive || locations.size >= 3 ? "high" : locations.size >= 2 ? "medium" : "low"
+        });
+      }
+    }
+    return matches;
+  }
+  async detectConfigPatterns(rootPath) {
+    const matches = [];
+    const checks = [
+      { file: "Dockerfile", pattern: "Docker", description: "Containerized application" },
+      {
+        file: "docker-compose.yml",
+        pattern: "Docker Compose",
+        description: "Container orchestration"
+      },
+      { file: "cdk.json", pattern: "AWS CDK", description: "AWS CDK infrastructure as code" },
+      { file: "terraform.tf", pattern: "Terraform", description: "Terraform IaC" },
+      { file: "main.tf", pattern: "Terraform", description: "Terraform IaC" }
+    ];
+    for (const check of checks) {
+      try {
+        await access(join(rootPath, check.file));
+        matches.push({
+          pattern: check.pattern,
+          description: check.description,
+          locations: [check.file],
+          confidence: "high"
+        });
+      } catch {
+      }
+    }
+    return matches;
+  }
+  formatMarkdown(patterns, rootPath) {
+    const lines = [];
+    lines.push(`## Patterns Detected: ${rootPath}
+`);
+    lines.push(`**${patterns.length} patterns** found
+`);
+    const byConfidence = {
+      high: [],
+      medium: [],
+      low: []
+    };
+    for (const p of patterns) {
+      byConfidence[p.confidence].push(p);
+    }
+    for (const [level, group] of Object.entries(byConfidence)) {
+      if (group.length === 0) continue;
+      lines.push(`### ${level.charAt(0).toUpperCase() + level.slice(1)} Confidence
+`);
+      for (const p of group) {
+        lines.push(`- **${p.pattern}**: ${p.description}`);
+        lines.push(`  Locations: ${p.locations.slice(0, 5).join(", ")}`);
+      }
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+}
+export {
+  PatternAnalyzer
+};
+//# sourceMappingURL=pattern-analyzer.js.map

package/packages/analyzers/dist/regex-call-graph.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Regex-based call graph extractor for all languages.
+ *
+ * Parses import statements to extract imported symbol names and source modules,
+ * then scans the file body for usage of those symbols to build module-level
+ * call edges. Works for TS/JS, Java, Python, Go, C#, Rust, PHP, Ruby, Kotlin, Scala.
+ *
+ * Less precise than the TypeScript Compiler API version (ts-call-graph.ts) but
+ * works across all languages without requiring language-specific compilers.
+ */
+import type { CallGraphResult } from './ts-call-graph.js';
+/**
+ * Extract regex-based call graph for any supported language.
+ * Returns null if no source files found.
+ */
+export declare function extractRegexCallGraph(rootPath: string): Promise<CallGraphResult | null>;
+//# sourceMappingURL=regex-call-graph.d.ts.map