@codexa/cli 8.6.0 → 8.6.9

package/detectors/index.ts

@@ -1,388 +1,388 @@
-/**
- * Universal Stack Detection System
- *
- * Modular detector architecture for language-agnostic stack detection.
- * Each detector is responsible for identifying technologies in its ecosystem.
- */
-
-import { existsSync, readFileSync, readdirSync, statSync } from "fs";
-import { join, extname } from "path";
-import { Glob } from "bun";
-
-// ============================================================
-// TYPES
-// ============================================================
-
-export interface DetectedTechnology {
-  name: string;
-  version?: string;
-  confidence: number; // 0-1
-  source: string; // File/marker that triggered detection
-  category: "frontend" | "backend" | "database" | "orm" | "styling" | "auth" | "testing" | "runtime" | "build" | "devops";
-  metadata?: Record<string, any>;
-}
-
-export interface DetectorResult {
-  ecosystem: string;
-  technologies: DetectedTechnology[];
-  structure: Record<string, string>;
-  configFiles: string[];
-}
-
-export interface Detector {
-  name: string;
-  ecosystem: string;
-  priority: number; // Higher = checked first
-  markers: MarkerConfig[];
-  detect: (cwd: string) => Promise<DetectorResult | null>;
-}
-
-export interface MarkerConfig {
-  type: "file" | "glob" | "directory" | "content";
-  pattern: string;
-  contentMatch?: RegExp;
-  weight: number; // 0-1, contributes to confidence
-}
-
-// ============================================================
-// DETECTOR REGISTRY
-// ============================================================
-
-const detectors: Detector[] = [];
-
-export function registerDetector(detector: Detector): void {
-  detectors.push(detector);
-  detectors.sort((a, b) => b.priority - a.priority);
-}
-
-export function getDetectors(): Detector[] {
-  return [...detectors];
-}
-
-// ============================================================
-// UTILITY FUNCTIONS
-// ============================================================
-
-export function fileExists(path: string): boolean {
-  try {
-    return existsSync(path) && statSync(path).isFile();
-  } catch {
-    return false;
-  }
-}
-
-export function dirExists(path: string): boolean {
-  try {
-    return existsSync(path) && statSync(path).isDirectory();
-  } catch {
-    return false;
-  }
-}
-
-export function findFiles(cwd: string, pattern: string): string[] {
-  try {
-    const glob = new Glob(pattern);
-    const results: string[] = [];
-    for (const file of glob.scanSync({ cwd, onlyFiles: true })) {
-      results.push(file);
-    }
-    return results;
-  } catch {
-    return [];
-  }
-}
-
-export function readJson(path: string): any | null {
-  try {
-    return JSON.parse(readFileSync(path, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-
-export function readText(path: string): string | null {
-  try {
-    return readFileSync(path, "utf-8");
-  } catch {
-    return null;
-  }
-}
-
-export function parseToml(content: string): Record<string, any> {
-  // Simple TOML parser for basic cases
-  const result: Record<string, any> = {};
-  let currentSection = result;
-
-  for (const line of content.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) continue;
-
-    // Section header
-    const sectionMatch = trimmed.match(/^\[([^\]]+)\]$/);
-    if (sectionMatch) {
-      const path = sectionMatch[1].split(".");
-      currentSection = result;
-      for (const part of path) {
-        if (!currentSection[part]) currentSection[part] = {};
-        currentSection = currentSection[part];
-      }
-      continue;
-    }
-
-    // Key-value pair
-    const kvMatch = trimmed.match(/^([^=]+)=\s*(.+)$/);
-    if (kvMatch) {
-      const key = kvMatch[1].trim();
-      let value = kvMatch[2].trim();
-
-      // Parse value
-      if (value.startsWith('"') && value.endsWith('"')) {
-        value = value.slice(1, -1);
-      } else if (value === "true") {
-        currentSection[key] = true;
-        continue;
-      } else if (value === "false") {
-        currentSection[key] = false;
-        continue;
-      } else if (!isNaN(Number(value))) {
-        currentSection[key] = Number(value);
-        continue;
-      }
-
-      currentSection[key] = value;
-    }
-  }
-
-  return result;
-}
-
-export function parseYaml(content: string): Record<string, any> {
-  // Simple YAML parser for basic cases (key: value only)
-  const result: Record<string, any> = {};
-  const lines = content.split("\n");
-  let currentIndent = 0;
-  const stack: { obj: Record<string, any>; indent: number }[] = [{ obj: result, indent: -1 }];
-
-  for (const line of lines) {
-    if (!line.trim() || line.trim().startsWith("#")) continue;
-
-    const indent = line.search(/\S/);
-    const trimmed = line.trim();
-
-    // Pop stack to correct level
-    while (stack.length > 1 && indent <= stack[stack.length - 1].indent) {
-      stack.pop();
-    }
-
-    const current = stack[stack.length - 1].obj;
-
-    // Check for key: value
-    const colonIdx = trimmed.indexOf(":");
-    if (colonIdx > 0) {
-      const key = trimmed.slice(0, colonIdx).trim();
-      const value = trimmed.slice(colonIdx + 1).trim();
-
-      if (value) {
-        // Parse value
-        if (value.startsWith('"') && value.endsWith('"')) {
-          current[key] = value.slice(1, -1);
-        } else if (value === "true") {
-          current[key] = true;
-        } else if (value === "false") {
-          current[key] = false;
-        } else if (!isNaN(Number(value))) {
-          current[key] = Number(value);
-        } else {
-          current[key] = value;
-        }
-      } else {
-        // Nested object
-        current[key] = {};
-        stack.push({ obj: current[key], indent });
-      }
-    }
-  }
-
-  return result;
-}
-
-// ============================================================
-// MAIN DETECTION ENGINE
-// ============================================================
-
-export interface UnifiedDetectionResult {
-  primary: {
-    language: string;
-    runtime?: string;
-    framework?: string;
-  };
-  stack: {
-    frontend?: string[];
-    backend?: string[];
-    database?: string[];
-    orm?: string[];
-    styling?: string[];
-    auth?: string[];
-    testing?: string[];
-    devops?: string[];
-  };
-  structure: Record<string, string>;
-  configFiles: string[];
-  allTechnologies: DetectedTechnology[];
-  ecosystems: string[];
-}
-
-export async function detectUniversal(cwd: string = process.cwd()): Promise<UnifiedDetectionResult> {
-  const results: DetectorResult[] = [];
-
-  // Run all detectors in parallel
-  const detectorPromises = detectors.map(async (detector) => {
-    try {
-      return await detector.detect(cwd);
-    } catch (err) {
-      console.error(`Detector ${detector.name} failed:`, err);
-      return null;
-    }
-  });
-
-  const detectorResults = await Promise.all(detectorPromises);
-
-  for (const result of detectorResults) {
-    if (result && result.technologies.length > 0) {
-      results.push(result);
-    }
-  }
-
-  // Merge results
-  return mergeResults(results);
-}
-
-function mergeResults(results: DetectorResult[]): UnifiedDetectionResult {
-  const allTechnologies: DetectedTechnology[] = [];
-  const structure: Record<string, string> = {};
-  const configFiles: string[] = [];
-  const ecosystems: string[] = [];
-
-  for (const result of results) {
-    allTechnologies.push(...result.technologies);
-    Object.assign(structure, result.structure);
-    configFiles.push(...result.configFiles);
-    if (!ecosystems.includes(result.ecosystem)) {
-      ecosystems.push(result.ecosystem);
-    }
-  }
-
-  // Sort by confidence
-  allTechnologies.sort((a, b) => b.confidence - a.confidence);
-
-  // Group by category
-  const stack: UnifiedDetectionResult["stack"] = {};
-  const categoryMap: Record<string, DetectedTechnology[]> = {};
-
-  for (const tech of allTechnologies) {
-    if (!categoryMap[tech.category]) {
-      categoryMap[tech.category] = [];
-    }
-    categoryMap[tech.category].push(tech);
-  }
-
-  for (const [category, techs] of Object.entries(categoryMap)) {
-    // Take unique names, sorted by confidence
-    const uniqueNames = [...new Set(techs.map(t => t.name))];
-    (stack as any)[category] = uniqueNames;
-  }
-
-  // Determine primary language/runtime
-  const primary = determinePrimary(allTechnologies, ecosystems);
-
-  return {
-    primary,
-    stack,
-    structure,
-    configFiles: [...new Set(configFiles)],
-    allTechnologies,
-    ecosystems,
-  };
-}
-
-function determinePrimary(technologies: DetectedTechnology[], ecosystems: string[]): UnifiedDetectionResult["primary"] {
-  // Find highest confidence runtime
-  const runtimes = technologies.filter(t => t.category === "runtime");
-  const backends = technologies.filter(t => t.category === "backend");
-  const frontends = technologies.filter(t => t.category === "frontend");
-
-  // Language mapping
-  const ecosystemToLanguage: Record<string, string> = {
-    "dotnet": "C#",
-    "node": "TypeScript/JavaScript",
-    "python": "Python",
-    "go": "Go",
-    "rust": "Rust",
-    "java": "Java",
-    "ruby": "Ruby",
-    "php": "PHP",
-    "flutter": "Dart",
-    "swift": "Swift",
-    "kotlin": "Kotlin",
-  };
-
-  const primaryEcosystem = ecosystems[0] || "unknown";
-
-  return {
-    language: ecosystemToLanguage[primaryEcosystem] || primaryEcosystem,
-    runtime: runtimes[0]?.name,
-    framework: backends[0]?.name || frontends[0]?.name,
-  };
-}
-
-// ============================================================
-// LEGACY COMPATIBILITY ADAPTER
-// ============================================================
-
-export interface LegacyStackDetection {
-  frontend?: string;
-  backend?: string;
-  database?: string;
-  orm?: string;
-  styling?: string;
-  auth?: string;
-  testing?: string;
-}
-
-export interface LegacyStructureDetection {
-  components?: string;
-  services?: string;
-  schema?: string;
-  types?: string;
-  hooks?: string;
-  utils?: string;
-  api?: string;
-}
-
-export async function detectStackLegacy(cwd: string = process.cwd()): Promise<{
-  stack: LegacyStackDetection;
-  structure: LegacyStructureDetection;
-}> {
-  const result = await detectUniversal(cwd);
-
-  // Convert to legacy format (single value per category)
-  const stack: LegacyStackDetection = {};
-  const structure: LegacyStructureDetection = {};
-
-  if (result.stack.frontend?.length) stack.frontend = result.stack.frontend[0];
-  if (result.stack.backend?.length) stack.backend = result.stack.backend[0];
-  if (result.stack.database?.length) stack.database = result.stack.database[0];
-  if (result.stack.orm?.length) stack.orm = result.stack.orm[0];
-  if (result.stack.styling?.length) stack.styling = result.stack.styling[0];
-  if (result.stack.auth?.length) stack.auth = result.stack.auth[0];
-  if (result.stack.testing?.length) stack.testing = result.stack.testing[0];
-
-  // Map structure
-  for (const [key, value] of Object.entries(result.structure)) {
-    if (key in structure || ["components", "services", "schema", "types", "hooks", "utils", "api"].includes(key)) {
-      (structure as any)[key] = value;
-    }
-  }
-
-  return { stack, structure };
+/**
+ * Universal Stack Detection System
+ *
+ * Modular detector architecture for language-agnostic stack detection.
+ * Each detector is responsible for identifying technologies in its ecosystem.
+ */
+
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { join, extname } from "path";
+import { Glob } from "bun";
+
+// ============================================================
+// TYPES
+// ============================================================
+
+export interface DetectedTechnology {
+  name: string;
+  version?: string;
+  confidence: number; // 0-1
+  source: string; // File/marker that triggered detection
+  category: "frontend" | "backend" | "database" | "orm" | "styling" | "auth" | "testing" | "runtime" | "build" | "devops";
+  metadata?: Record<string, any>;
+}
+
+export interface DetectorResult {
+  ecosystem: string;
+  technologies: DetectedTechnology[];
+  structure: Record<string, string>;
+  configFiles: string[];
+}
+
+export interface Detector {
+  name: string;
+  ecosystem: string;
+  priority: number; // Higher = checked first
+  markers: MarkerConfig[];
+  detect: (cwd: string) => Promise<DetectorResult | null>;
+}
+
+export interface MarkerConfig {
+  type: "file" | "glob" | "directory" | "content";
+  pattern: string;
+  contentMatch?: RegExp;
+  weight: number; // 0-1, contributes to confidence
+}
+
+// ============================================================
+// DETECTOR REGISTRY
+// ============================================================
+
+const detectors: Detector[] = [];
+
+export function registerDetector(detector: Detector): void {
+  detectors.push(detector);
+  detectors.sort((a, b) => b.priority - a.priority);
+}
+
+export function getDetectors(): Detector[] {
+  return [...detectors];
+}
+
+// ============================================================
+// UTILITY FUNCTIONS
+// ============================================================
+
+export function fileExists(path: string): boolean {
+  try {
+    return existsSync(path) && statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+
+export function dirExists(path: string): boolean {
+  try {
+    return existsSync(path) && statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+export function findFiles(cwd: string, pattern: string): string[] {
+  try {
+    const glob = new Glob(pattern);
+    const results: string[] = [];
+    for (const file of glob.scanSync({ cwd, onlyFiles: true })) {
+      results.push(file);
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+
+export function readJson(path: string): any | null {
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+export function readText(path: string): string | null {
+  try {
+    return readFileSync(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+export function parseToml(content: string): Record<string, any> {
+  // Simple TOML parser for basic cases
+  const result: Record<string, any> = {};
+  let currentSection = result;
+
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+
+    // Section header
+    const sectionMatch = trimmed.match(/^\[([^\]]+)\]$/);
+    if (sectionMatch) {
+      const path = sectionMatch[1].split(".");
+      currentSection = result;
+      for (const part of path) {
+        if (!currentSection[part]) currentSection[part] = {};
+        currentSection = currentSection[part];
+      }
+      continue;
+    }
+
+    // Key-value pair
+    const kvMatch = trimmed.match(/^([^=]+)=\s*(.+)$/);
+    if (kvMatch) {
+      const key = kvMatch[1].trim();
+      let value = kvMatch[2].trim();
+
+      // Parse value
+      if (value.startsWith('"') && value.endsWith('"')) {
+        value = value.slice(1, -1);
+      } else if (value === "true") {
+        currentSection[key] = true;
+        continue;
+      } else if (value === "false") {
+        currentSection[key] = false;
+        continue;
+      } else if (!isNaN(Number(value))) {
+        currentSection[key] = Number(value);
+        continue;
+      }
+
+      currentSection[key] = value;
+    }
+  }
+
+  return result;
+}
+
+export function parseYaml(content: string): Record<string, any> {
+  // Simple YAML parser for basic cases (key: value only)
+  const result: Record<string, any> = {};
+  const lines = content.split("\n");
+  let currentIndent = 0;
+  const stack: { obj: Record<string, any>; indent: number }[] = [{ obj: result, indent: -1 }];
+
+  for (const line of lines) {
+    if (!line.trim() || line.trim().startsWith("#")) continue;
+
+    const indent = line.search(/\S/);
+    const trimmed = line.trim();
+
+    // Pop stack to correct level
+    while (stack.length > 1 && indent <= stack[stack.length - 1].indent) {
+      stack.pop();
+    }
+
+    const current = stack[stack.length - 1].obj;
+
+    // Check for key: value
+    const colonIdx = trimmed.indexOf(":");
+    if (colonIdx > 0) {
+      const key = trimmed.slice(0, colonIdx).trim();
+      const value = trimmed.slice(colonIdx + 1).trim();
+
+      if (value) {
+        // Parse value
+        if (value.startsWith('"') && value.endsWith('"')) {
+          current[key] = value.slice(1, -1);
+        } else if (value === "true") {
+          current[key] = true;
+        } else if (value === "false") {
+          current[key] = false;
+        } else if (!isNaN(Number(value))) {
+          current[key] = Number(value);
+        } else {
+          current[key] = value;
+        }
+      } else {
+        // Nested object
+        current[key] = {};
+        stack.push({ obj: current[key], indent });
+      }
+    }
+  }
+
+  return result;
+}
+
+// ============================================================
+// MAIN DETECTION ENGINE
+// ============================================================
+
+export interface UnifiedDetectionResult {
+  primary: {
+    language: string;
+    runtime?: string;
+    framework?: string;
+  };
+  stack: {
+    frontend?: string[];
+    backend?: string[];
+    database?: string[];
+    orm?: string[];
+    styling?: string[];
+    auth?: string[];
+    testing?: string[];
+    devops?: string[];
+  };
+  structure: Record<string, string>;
+  configFiles: string[];
+  allTechnologies: DetectedTechnology[];
+  ecosystems: string[];
+}
+
+export async function detectUniversal(cwd: string = process.cwd()): Promise<UnifiedDetectionResult> {
+  const results: DetectorResult[] = [];
+
+  // Run all detectors in parallel
+  const detectorPromises = detectors.map(async (detector) => {
+    try {
+      return await detector.detect(cwd);
+    } catch (err) {
+      console.error(`Detector ${detector.name} failed:`, err);
+      return null;
+    }
+  });
+
+  const detectorResults = await Promise.all(detectorPromises);
+
+  for (const result of detectorResults) {
+    if (result && result.technologies.length > 0) {
+      results.push(result);
+    }
+  }
+
+  // Merge results
+  return mergeResults(results);
+}
+
+function mergeResults(results: DetectorResult[]): UnifiedDetectionResult {
+  const allTechnologies: DetectedTechnology[] = [];
+  const structure: Record<string, string> = {};
+  const configFiles: string[] = [];
+  const ecosystems: string[] = [];
+
+  for (const result of results) {
+    allTechnologies.push(...result.technologies);
+    Object.assign(structure, result.structure);
+    configFiles.push(...result.configFiles);
+    if (!ecosystems.includes(result.ecosystem)) {
+      ecosystems.push(result.ecosystem);
+    }
+  }
+
+  // Sort by confidence
+  allTechnologies.sort((a, b) => b.confidence - a.confidence);
+
+  // Group by category
+  const stack: UnifiedDetectionResult["stack"] = {};
+  const categoryMap: Record<string, DetectedTechnology[]> = {};
+
+  for (const tech of allTechnologies) {
+    if (!categoryMap[tech.category]) {
+      categoryMap[tech.category] = [];
+    }
+    categoryMap[tech.category].push(tech);
+  }
+
+  for (const [category, techs] of Object.entries(categoryMap)) {
+    // Take unique names, sorted by confidence
+    const uniqueNames = [...new Set(techs.map(t => t.name))];
+    (stack as any)[category] = uniqueNames;
+  }
+
+  // Determine primary language/runtime
+  const primary = determinePrimary(allTechnologies, ecosystems);
+
+  return {
+    primary,
+    stack,
+    structure,
+    configFiles: [...new Set(configFiles)],
+    allTechnologies,
+    ecosystems,
+  };
+}
+
+function determinePrimary(technologies: DetectedTechnology[], ecosystems: string[]): UnifiedDetectionResult["primary"] {
+  // Find highest confidence runtime
+  const runtimes = technologies.filter(t => t.category === "runtime");
+  const backends = technologies.filter(t => t.category === "backend");
+  const frontends = technologies.filter(t => t.category === "frontend");
+
+  // Language mapping
+  const ecosystemToLanguage: Record<string, string> = {
+    "dotnet": "C#",
+    "node": "TypeScript/JavaScript",
+    "python": "Python",
+    "go": "Go",
+    "rust": "Rust",
+    "java": "Java",
+    "ruby": "Ruby",
+    "php": "PHP",
+    "flutter": "Dart",
+    "swift": "Swift",
+    "kotlin": "Kotlin",
+  };
+
+  const primaryEcosystem = ecosystems[0] || "unknown";
+
+  return {
+    language: ecosystemToLanguage[primaryEcosystem] || primaryEcosystem,
+    runtime: runtimes[0]?.name,
+    framework: backends[0]?.name || frontends[0]?.name,
+  };
+}
+
+// ============================================================
+// LEGACY COMPATIBILITY ADAPTER
+// ============================================================
+
+export interface LegacyStackDetection {
+  frontend?: string;
+  backend?: string;
+  database?: string;
+  orm?: string;
+  styling?: string;
+  auth?: string;
+  testing?: string;
+}
+
+export interface LegacyStructureDetection {
+  components?: string;
+  services?: string;
+  schema?: string;
+  types?: string;
+  hooks?: string;
+  utils?: string;
+  api?: string;
+}
+
+export async function detectStackLegacy(cwd: string = process.cwd()): Promise<{
+  stack: LegacyStackDetection;
+  structure: LegacyStructureDetection;
+}> {
+  const result = await detectUniversal(cwd);
+
+  // Convert to legacy format (single value per category)
+  const stack: LegacyStackDetection = {};
+  const structure: LegacyStructureDetection = {};
+
+  if (result.stack.frontend?.length) stack.frontend = result.stack.frontend[0];
+  if (result.stack.backend?.length) stack.backend = result.stack.backend[0];
+  if (result.stack.database?.length) stack.database = result.stack.database[0];
+  if (result.stack.orm?.length) stack.orm = result.stack.orm[0];
+  if (result.stack.styling?.length) stack.styling = result.stack.styling[0];
+  if (result.stack.auth?.length) stack.auth = result.stack.auth[0];
+  if (result.stack.testing?.length) stack.testing = result.stack.testing[0];
+
+  // Map structure
+  for (const [key, value] of Object.entries(result.structure)) {
+    if (key in structure || ["components", "services", "schema", "types", "hooks", "utils", "api"].includes(key)) {
+      (structure as any)[key] = value;
+    }
+  }
+
+  return { stack, structure };
 }