@stackweld/core 0.2.1 → 0.3.0

package/src/engine/stack-detector.ts

@@ -1,345 +0,0 @@
-/**
- * Stack Detector — Analyze a project directory to detect its technology stack.
- */
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-export interface DetectedStack {
-  technologies: DetectedTech[];
-  confidence: number;
-  projectType: "frontend" | "backend" | "fullstack" | "monorepo" | "library" | "unknown";
-  packageManagers: string[];
-}
-
-export interface DetectedTech {
-  id: string;
-  name: string;
-  confidence: number;
-  detectedVia: string;
-  version?: string;
-}
-
-// ─── Dependency → Registry ID mappings ─────────────────
-
-const NPM_DEPENDENCY_MAP: Record<string, { id: string; name: string }> = {
-  next: { id: "nextjs", name: "Next.js" },
-  react: { id: "react", name: "React" },
-  vue: { id: "vue", name: "Vue" },
-  "@angular/core": { id: "angular", name: "Angular" },
-  express: { id: "express", name: "Express" },
-  fastify: { id: "fastify", name: "Fastify" },
-  "@nestjs/core": { id: "nestjs", name: "NestJS" },
-  prisma: { id: "prisma", name: "Prisma" },
-  "drizzle-orm": { id: "drizzle", name: "Drizzle ORM" },
-  typeorm: { id: "typeorm", name: "TypeORM" },
-  tailwindcss: { id: "tailwindcss", name: "Tailwind CSS" },
-  "@chakra-ui/react": { id: "chakra-ui", name: "Chakra UI" },
-  typescript: { id: "typescript", name: "TypeScript" },
-  vitest: { id: "vitest", name: "Vitest" },
-  jest: { id: "jest", name: "Jest" },
-  "next-auth": { id: "nextauth", name: "NextAuth.js" },
-  "@clerk/nextjs": { id: "clerk", name: "Clerk" },
-};
-
-const PYTHON_DEPENDENCY_MAP: Record<string, { id: string; name: string }> = {
-  fastapi: { id: "fastapi", name: "FastAPI" },
-  django: { id: "django", name: "Django" },
-  flask: { id: "flask", name: "Flask" },
-  sqlalchemy: { id: "sqlalchemy", name: "SQLAlchemy" },
-};
-
-const GO_DEPENDENCY_MAP: Record<string, { id: string; name: string }> = {
-  "github.com/gin-gonic/gin": { id: "gin", name: "Gin" },
-  "github.com/labstack/echo": { id: "echo", name: "Echo" },
-};
-
-const DOCKER_IMAGE_MAP: Record<string, { id: string; name: string }> = {
-  postgres: { id: "postgresql", name: "PostgreSQL" },
-  mysql: { id: "mysql", name: "MySQL" },
-  mongo: { id: "mongodb", name: "MongoDB" },
-  redis: { id: "redis", name: "Redis" },
-  rabbitmq: { id: "rabbitmq", name: "RabbitMQ" },
-  nginx: { id: "nginx", name: "Nginx" },
-};
-
-// ─── Helpers ───────────────────────────────────────────
-
-function readFileOr(filePath: string): string | null {
-  try {
-    if (fs.existsSync(filePath)) {
-      return fs.readFileSync(filePath, "utf-8");
-    }
-  } catch {
-    // Ignore read errors
-  }
-  return null;
-}
-
-function extractVersion(value: string): string | undefined {
-  const match = value.replace(/[\^~>=<]/g, "").match(/(\d+[.\d]*)/);
-  return match?.[1];
-}
-
-// ─── Main detection ────────────────────────────────────
-
-/**
- * Detect the technology stack of a project at the given path.
- */
-export function detectStack(projectPath: string): DetectedStack {
-  const techs: DetectedTech[] = [];
-  const packageManagers: string[] = [];
-  let hasFrontend = false;
-  let hasBackend = false;
-  let isMonorepo = false;
-
-  // ── Package managers ──
-  if (fs.existsSync(path.join(projectPath, "pnpm-lock.yaml"))) packageManagers.push("pnpm");
-  if (fs.existsSync(path.join(projectPath, "yarn.lock"))) packageManagers.push("yarn");
-  if (fs.existsSync(path.join(projectPath, "package-lock.json"))) packageManagers.push("npm");
-  if (fs.existsSync(path.join(projectPath, "bun.lockb"))) packageManagers.push("bun");
-
-  // ── 1. package.json ──
-  const pkgContent = readFileOr(path.join(projectPath, "package.json"));
-  if (pkgContent) {
-    try {
-      const pkg = JSON.parse(pkgContent);
-      const allDeps: Record<string, string> = {
-        ...(pkg.dependencies || {}),
-        ...(pkg.devDependencies || {}),
-      };
-
-      for (const [dep, version] of Object.entries(allDeps)) {
-        const mapping = NPM_DEPENDENCY_MAP[dep];
-        if (mapping) {
-          const isDevDep = dep in (pkg.devDependencies || {});
-          techs.push({
-            id: mapping.id,
-            name: mapping.name,
-            confidence: 95,
-            detectedVia: isDevDep ? "devDependencies" : "package.json",
-            version: extractVersion(version),
-          });
-
-          // Track frontend/backend
-          if (["react", "vue", "angular", "nextjs"].includes(mapping.id)) {
-            hasFrontend = true;
-          }
-          if (["express", "fastify", "nestjs"].includes(mapping.id)) {
-            hasBackend = true;
-          }
-          // Next.js is fullstack
-          if (mapping.id === "nextjs") {
-            hasBackend = true;
-          }
-        }
-      }
-    } catch {
-      // Invalid JSON, skip
-    }
-  }
-
-  // ── 2. requirements.txt ──
-  const reqContent = readFileOr(path.join(projectPath, "requirements.txt"));
-  if (reqContent) {
-    packageManagers.push("pip");
-    const lines = reqContent.split("\n");
-    for (const line of lines) {
-      const dep = line
-        .trim()
-        .split(/[=<>!~]/)[0]
-        .toLowerCase();
-      const mapping = PYTHON_DEPENDENCY_MAP[dep];
-      if (mapping) {
-        const versionMatch = line.match(/==(\d+[.\d]*)/);
-        techs.push({
-          id: mapping.id,
-          name: mapping.name,
-          confidence: 95,
-          detectedVia: "requirements.txt",
-          version: versionMatch?.[1],
-        });
-        hasBackend = true;
-      }
-    }
-  }
-
-  // ── 2b. pyproject.toml ──
-  const pyprojectContent = readFileOr(path.join(projectPath, "pyproject.toml"));
-  if (pyprojectContent) {
-    if (!packageManagers.includes("pip")) packageManagers.push("pip");
-    for (const [dep, mapping] of Object.entries(PYTHON_DEPENDENCY_MAP)) {
-      if (pyprojectContent.includes(`"${dep}`) || pyprojectContent.includes(`'${dep}`)) {
-        const versionMatch = pyprojectContent.match(new RegExp(`["']${dep}[><=~!]*([\\d.]+)?["']`));
-        techs.push({
-          id: mapping.id,
-          name: mapping.name,
-          confidence: 85,
-          detectedVia: "pyproject.toml",
-          version: versionMatch?.[1],
-        });
-        hasBackend = true;
-      }
-    }
-  }
-
-  // ── 3. go.mod ──
-  const goModContent = readFileOr(path.join(projectPath, "go.mod"));
-  if (goModContent) {
-    packageManagers.push("go");
-    for (const [dep, mapping] of Object.entries(GO_DEPENDENCY_MAP)) {
-      if (goModContent.includes(dep)) {
-        const versionMatch = goModContent.match(
-          new RegExp(`${dep.replace(/\//g, "\\/")}\\s+v(\\d+[.\\d]*)`),
-        );
-        techs.push({
-          id: mapping.id,
-          name: mapping.name,
-          confidence: 95,
-          detectedVia: "go.mod",
-          version: versionMatch?.[1],
-        });
-        hasBackend = true;
-      }
-    }
-  }
-
-  // ── 4. Cargo.toml ──
-  const cargoContent = readFileOr(path.join(projectPath, "Cargo.toml"));
-  if (cargoContent) {
-    packageManagers.push("cargo");
-    techs.push({
-      id: "rust",
-      name: "Rust",
-      confidence: 95,
-      detectedVia: "Cargo.toml",
-    });
-    hasBackend = true;
-  }
-
-  // ── 5. docker-compose.yml / docker-compose.yaml ──
-  for (const composeName of [
-    "docker-compose.yml",
-    "docker-compose.yaml",
-    "compose.yml",
-    "compose.yaml",
-  ]) {
-    const composeContent = readFileOr(path.join(projectPath, composeName));
-    if (composeContent) {
-      for (const [imageKey, mapping] of Object.entries(DOCKER_IMAGE_MAP)) {
-        const imagePattern = new RegExp(`image:\\s*["']?[^\\n]*${imageKey}`, "i");
-        if (imagePattern.test(composeContent)) {
-          const versionMatch = composeContent.match(new RegExp(`${imageKey}:(\\d+[.\\d]*)`, "i"));
-          techs.push({
-            id: mapping.id,
-            name: mapping.name,
-            confidence: 90,
-            detectedVia: composeName,
-            version: versionMatch?.[1],
-          });
-        }
-      }
-      break; // Only process the first compose file found
-    }
-  }
-
-  // ── 6. Dockerfile ──
-  const dockerfileContent = readFileOr(path.join(projectPath, "Dockerfile"));
-  if (dockerfileContent) {
-    techs.push({
-      id: "docker",
-      name: "Docker",
-      confidence: 95,
-      detectedVia: "Dockerfile",
-    });
-  }
-
-  // ── 7. .github/workflows ──
-  const workflowsDir = path.join(projectPath, ".github", "workflows");
-  try {
-    if (fs.existsSync(workflowsDir) && fs.statSync(workflowsDir).isDirectory()) {
-      const files = fs.readdirSync(workflowsDir);
-      const ymlFiles = files.filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
-      if (ymlFiles.length > 0) {
-        techs.push({
-          id: "github-actions",
-          name: "GitHub Actions",
-          confidence: 95,
-          detectedVia: ".github/workflows",
-        });
-      }
-    }
-  } catch {
-    // Ignore
-  }
-
-  // ── 8. turbo.json ──
-  if (fs.existsSync(path.join(projectPath, "turbo.json"))) {
-    techs.push({
-      id: "turborepo",
-      name: "Turborepo",
-      confidence: 95,
-      detectedVia: "turbo.json",
-    });
-    isMonorepo = true;
-  }
-
-  // ── 9. pnpm-workspace.yaml ──
-  if (fs.existsSync(path.join(projectPath, "pnpm-workspace.yaml"))) {
-    isMonorepo = true;
-    // Only add if turborepo not already detected (they often coexist)
-    if (!techs.some((t) => t.id === "turborepo")) {
-      techs.push({
-        id: "pnpm-workspace",
-        name: "pnpm Workspace",
-        confidence: 90,
-        detectedVia: "pnpm-workspace.yaml",
-      });
-    }
-  }
-
-  // ── Determine project type ──
-  let projectType: DetectedStack["projectType"] = "unknown";
-  if (isMonorepo) {
-    projectType = "monorepo";
-  } else if (hasFrontend && hasBackend) {
-    projectType = "fullstack";
-  } else if (hasFrontend) {
-    projectType = "frontend";
-  } else if (hasBackend) {
-    projectType = "backend";
-  } else if (pkgContent) {
-    // Has package.json but no clear frontend/backend → likely a library
-    try {
-      const pkg = JSON.parse(pkgContent);
-      if (pkg.main || pkg.exports || pkg.types) {
-        projectType = "library";
-      }
-    } catch {
-      // Ignore
-    }
-  }
-
-  // ── Deduplicate techs (keep highest confidence) ──
-  const techMap = new Map<string, DetectedTech>();
-  for (const tech of techs) {
-    const existing = techMap.get(tech.id);
-    if (!existing || tech.confidence > existing.confidence) {
-      techMap.set(tech.id, tech);
-    }
-  }
-  const deduped = Array.from(techMap.values());
-
-  // ── Calculate overall confidence ──
-  const confidence =
-    deduped.length > 0
-      ? Math.round(deduped.reduce((sum, t) => sum + t.confidence, 0) / deduped.length)
-      : 0;
-
-  return {
-    technologies: deduped,
-    confidence,
-    projectType,
-    packageManagers: [...new Set(packageManagers)],
-  };
-}

package/src/engine/stack-differ.ts

@@ -1,118 +0,0 @@
-/**
- * Stack Comparison — Diff two stack definitions by technology.
- */
-
-import type { StackDefinition } from "../types/stack.js";
-
-// ─── Types ────────────────────────────────────────────
-
-export interface StackDiff {
-  added: DiffItem[];
-  removed: DiffItem[];
-  changed: DiffChange[];
-  unchanged: string[];
-  summary: string;
-}
-
-export interface DiffItem {
-  technologyId: string;
-  name: string;
-  version?: string;
-  port?: number;
-}
-
-export interface DiffChange {
-  technologyId: string;
-  name: string;
-  field: string;
-  from: string;
-  to: string;
-}
-
-// ─── Main Function ────────────────────────────────────
-
-export function diffStacks(stackA: StackDefinition, stackB: StackDefinition): StackDiff {
-  const techMapA = new Map(stackA.technologies.map((t) => [t.technologyId, t]));
-  const techMapB = new Map(stackB.technologies.map((t) => [t.technologyId, t]));
-
-  const added: DiffItem[] = [];
-  const removed: DiffItem[] = [];
-  const changed: DiffChange[] = [];
-  const unchanged: string[] = [];
-
-  // Find removed (in A but not B) and changed/unchanged
-  for (const [id, techA] of techMapA) {
-    const techB = techMapB.get(id);
-    if (!techB) {
-      removed.push({
-        technologyId: id,
-        name: id,
-        version: techA.version,
-        port: techA.port,
-      });
-      continue;
-    }
-
-    let hasChanges = false;
-
-    if (techA.version !== techB.version) {
-      changed.push({
-        technologyId: id,
-        name: id,
-        field: "version",
-        from: techA.version,
-        to: techB.version,
-      });
-      hasChanges = true;
-    }
-
-    if (techA.port !== techB.port) {
-      changed.push({
-        technologyId: id,
-        name: id,
-        field: "port",
-        from: techA.port !== undefined ? String(techA.port) : "none",
-        to: techB.port !== undefined ? String(techB.port) : "none",
-      });
-      hasChanges = true;
-    }
-
-    const configA = JSON.stringify(techA.config ?? {});
-    const configB = JSON.stringify(techB.config ?? {});
-    if (configA !== configB) {
-      changed.push({
-        technologyId: id,
-        name: id,
-        field: "config",
-        from: configA,
-        to: configB,
-      });
-      hasChanges = true;
-    }
-
-    if (!hasChanges) {
-      unchanged.push(id);
-    }
-  }
-
-  // Find added (in B but not A)
-  for (const [id, techB] of techMapB) {
-    if (!techMapA.has(id)) {
-      added.push({
-        technologyId: id,
-        name: id,
-        version: techB.version,
-        port: techB.port,
-      });
-    }
-  }
-
-  const parts: string[] = [];
-  if (added.length > 0) parts.push(`+${added.length} added`);
-  if (removed.length > 0) parts.push(`-${removed.length} removed`);
-  if (changed.length > 0) parts.push(`~${changed.length} changed`);
-  if (unchanged.length > 0) parts.push(`${unchanged.length} unchanged`);
-  const summary = parts.join(", ");
-
-  return { added, removed, changed, unchanged, summary };
-}