ccjk 12.0.7 → 12.0.8

package/dist/shared/ccjk.DS7UESmF.mjs

@@ -1,2451 +0,0 @@
-import { c as consola } from './ccjk.UIvifqNE.mjs';
-import { promises, existsSync } from 'node:fs';
-import posix from '../chunks/index8.mjs';
-import { glob } from 'tinyglobby';
-import { p as parse } from './ccjk.BBtCGd_g.mjs';
-
-async function pathExists$5(p) {
-  try {
-    await promises.access(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function readJson$1(p) {
-  const content = await promises.readFile(p, "utf-8");
-  return JSON.parse(content);
-}
-const logger$6 = consola.withTag("dependency-resolver");
-async function analyzeDependencies$1(analysis, config) {
-  logger$6.info("Analyzing project dependencies");
-  if (config.analyzeTransitiveDeps) {
-    logger$6.warn(
-      'Transitive dependency analysis requested but not fully implemented. The "all" field will only contain direct dependencies. See dependency-resolver.ts for details.'
-    );
-  }
-  const projectPath = analysis.rootPath;
-  const packageManager = analysis.packageManager;
-  analysis.languages;
-  let direct = [];
-  let all = [];
-  if (packageManager === "npm" || packageManager === "yarn" || packageManager === "pnpm" || packageManager === "bun") {
-    const npmDeps = await analyzeNpmDependencies(projectPath);
-    direct = npmDeps.direct;
-    all = npmDeps.all;
-  } else if (packageManager === "pip" || packageManager === "poetry" || packageManager === "pipenv") {
-    const pythonDeps = await analyzePythonDependencies(projectPath, packageManager);
-    direct = pythonDeps.direct;
-    all = pythonDeps.all;
-  } else if (packageManager === "go") {
-    const goDeps = await analyzeGoDependencies(projectPath);
-    direct = goDeps.direct;
-    all = goDeps.all;
-  } else if (packageManager === "cargo") {
-    const rustDeps = await analyzeRustDependencies(projectPath);
-    direct = rustDeps.direct;
-    all = rustDeps.all;
-  }
-  const graph = buildDependencyGraph(all);
-  const installationPlan = generateInstallationPlan(all, packageManager);
-  const conflicts = detectConflicts(all);
-  const circularDeps = detectCircularDependencies(graph);
-  logger$6.info(`Found ${direct.length} direct dependencies, ${all.length} total`);
-  if (conflicts.length > 0) {
-    logger$6.warn(`Found ${conflicts.length} dependency conflicts`);
-  }
-  if (circularDeps.length > 0) {
-    logger$6.warn(`Found ${circularDeps.length} circular dependencies`);
-  }
-  return {
-    direct,
-    all,
-    graph,
-    installationPlan,
-    conflicts,
-    circularDeps
-  };
-}
-async function analyzeNpmDependencies(projectPath) {
-  const packageJsonPath = posix.join(projectPath, "package.json");
-  if (!await pathExists$5(packageJsonPath)) {
-    return { direct: [], all: [] };
-  }
-  try {
-    const packageJson = await readJson$1(packageJsonPath);
-    const direct = [];
-    const processDeps = (deps2, isDev, isPeer) => {
-      if (!deps2)
-        return [];
-      return Object.entries(deps2).map(([name, version]) => ({
-        name,
-        version,
-        type: isDev ? "dev" : isPeer ? "peer" : "runtime",
-        isDev,
-        isPeer,
-        isOptional: false
-      }));
-    };
-    const deps = processDeps(packageJson.dependencies, false, false);
-    const devDeps = processDeps(packageJson.devDependencies, true, false);
-    const peerDeps = processDeps(packageJson.peerDependencies, false, true);
-    const optionalDeps = processDeps(packageJson.optionalDependencies, false, false).map((d) => ({
-      ...d,
-      isOptional: true,
-      type: "optional"
-    }));
-    direct.push(...deps, ...devDeps, ...peerDeps, ...optionalDeps);
-    const all = [...direct];
-    return { direct, all };
-  } catch (error) {
-    logger$6.warn("Failed to analyze npm dependencies:", error);
-    return { direct: [], all: [] };
-  }
-}
-async function analyzePythonDependencies(projectPath, packageManager) {
-  const direct = [];
-  const all = [];
-  if (packageManager === "poetry") {
-    const pyprojectPath = posix.join(projectPath, "pyproject.toml");
-    if (await pathExists$5(pyprojectPath)) {
-      try {
-        const { parse } = await import('../chunks/index6.mjs');
-        const content = await promises.readFile(pyprojectPath, "utf-8");
-        const pyproject = parse(content);
-        const deps = pyproject.tool?.poetry?.dependencies || {};
-        const devDeps = pyproject.tool?.poetry?.["dev-dependencies"] || {};
-        for (const [name, version] of Object.entries(deps)) {
-          direct.push({
-            name,
-            version: typeof version === "string" ? version : "latest",
-            type: "runtime",
-            isDev: false,
-            isPeer: false,
-            isOptional: false
-          });
-        }
-        for (const [name, version] of Object.entries(devDeps)) {
-          direct.push({
-            name,
-            version: typeof version === "string" ? version : "latest",
-            type: "dev",
-            isDev: true,
-            isPeer: false,
-            isOptional: false
-          });
-        }
-      } catch (error) {
-        logger$6.warn("Failed to parse pyproject.toml:", error);
-      }
-    }
-  } else if (packageManager === "pipenv") {
-    const pipfilePath = posix.join(projectPath, "Pipfile");
-    if (await pathExists$5(pipfilePath)) {
-      try {
-        const { parse } = await import('../chunks/index6.mjs');
-        const content = await promises.readFile(pipfilePath, "utf-8");
-        const pipfile = parse(content);
-        const deps = pipfile.packages || {};
-        const devDeps = pipfile["dev-packages"] || {};
-        for (const [name, version] of Object.entries(deps)) {
-          direct.push({
-            name,
-            version: typeof version === "string" ? version : "latest",
-            type: "runtime",
-            isDev: false,
-            isPeer: false,
-            isOptional: false
-          });
-        }
-        for (const [name, version] of Object.entries(devDeps)) {
-          direct.push({
-            name,
-            version: typeof version === "string" ? version : "latest",
-            type: "dev",
-            isDev: true,
-            isPeer: false,
-            isOptional: false
-          });
-        }
-      } catch (error) {
-        logger$6.warn("Failed to parse Pipfile:", error);
-      }
-    }
-  } else {
-    const requirementsPath = posix.join(projectPath, "requirements.txt");
-    if (await pathExists$5(requirementsPath)) {
-      try {
-        const content = await promises.readFile(requirementsPath, "utf-8");
-        const lines = content.split("\n");
-        for (const line of lines) {
-          const trimmed = line.trim();
-          if (trimmed && !trimmed.startsWith("#")) {
-            const match = trimmed.match(/^([\w-]+)([[~=><].*)?$/);
-            if (match) {
-              direct.push({
-                name: match[1],
-                version: match[2] || "latest",
-                type: "runtime",
-                isDev: false,
-                isPeer: false,
-                isOptional: false
-              });
-            }
-          }
-        }
-      } catch (error) {
-        logger$6.warn("Failed to parse requirements.txt:", error);
-      }
-    }
-  }
-  all.push(...direct);
-  return { direct, all };
-}
-async function analyzeGoDependencies(projectPath) {
-  const goModPath = posix.join(projectPath, "go.mod");
-  if (!await pathExists$5(goModPath)) {
-    return { direct: [], all: [] };
-  }
-  try {
-    const content = await promises.readFile(goModPath, "utf-8");
-    const lines = content.split("\n");
-    const direct = [];
-    let inRequireBlock = false;
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (trimmed.startsWith("require (")) {
-        inRequireBlock = true;
-        continue;
-      }
-      if (inRequireBlock && trimmed === ")") {
-        inRequireBlock = false;
-        continue;
-      }
-      if (trimmed.startsWith("require ") || inRequireBlock) {
-        const parts = trimmed.split(/\s+/);
-        if (parts.length >= 2) {
-          const name = parts[0].replace("require ", "");
-          const version = parts[1];
-          direct.push({
-            name,
-            version,
-            type: "runtime",
-            isDev: false,
-            isPeer: false,
-            isOptional: false
-          });
-        }
-      }
-    }
-    const all = [...direct];
-    return { direct, all };
-  } catch (error) {
-    logger$6.warn("Failed to analyze Go dependencies:", error);
-    return { direct: [], all: [] };
-  }
-}
-async function analyzeRustDependencies(projectPath) {
-  const cargoTomlPath = posix.join(projectPath, "Cargo.toml");
-  if (!await pathExists$5(cargoTomlPath)) {
-    return { direct: [], all: [] };
-  }
-  try {
-    const { parse } = await import('../chunks/index6.mjs');
-    const content = await promises.readFile(cargoTomlPath, "utf-8");
-    const cargoToml = parse(content);
-    const direct = [];
-    const processDeps = (deps2, isDev) => {
-      if (!deps2)
-        return [];
-      return Object.entries(deps2).map(([name, version]) => ({
-        name,
-        version: typeof version === "string" ? version : version?.version || "latest",
-        type: isDev ? "dev" : "runtime",
-        isDev,
-        isPeer: false,
-        isOptional: false
-      }));
-    };
-    const deps = processDeps(cargoToml.dependencies, false);
-    const devDeps = processDeps(cargoToml["dev-dependencies"], true);
-    const buildDeps = processDeps(cargoToml["build-dependencies"], false);
-    direct.push(...deps, ...devDeps, ...buildDeps);
-    const all = [...direct];
-    return { direct, all };
-  } catch (error) {
-    logger$6.warn("Failed to analyze Rust dependencies:", error);
-    return { direct: [], all: [] };
-  }
-}
-function buildDependencyGraph(dependencies) {
-  const graph = /* @__PURE__ */ new Map();
-  for (const dep of dependencies) {
-    graph.set(dep.name, []);
-  }
-  return graph;
-}
-function generateInstallationPlan(dependencies, packageManager) {
-  const order = [...dependencies];
-  const runtime = order.filter((d) => d.type === "runtime");
-  order.filter((d) => d.type === "dev");
-  order.filter((d) => d.type === "peer");
-  order.filter((d) => d.type === "optional");
-  const parallelizable = runtime.length;
-  const commands = generateInstallationCommands(packageManager);
-  return {
-    order,
-    total: dependencies.length,
-    parallelizable,
-    commands
-  };
-}
-function generateInstallationCommands(packageManager) {
-  if (!packageManager) {
-    return {
-      installAll: 'echo "Unknown package manager"',
-      installPackage: () => 'echo "Unknown package manager"',
-      installDev: 'echo "Unknown package manager"',
-      add: () => 'echo "Unknown package manager"'
-    };
-  }
-  const commands = {
-    npm: {
-      installAll: "npm install",
-      installPackage: (name, version) => `npm install ${name}${version ? `@${version}` : ""}`,
-      installDev: "npm install --only=dev",
-      add: (name, isDev) => isDev ? `npm install -D ${name}` : `npm install ${name}`
-    },
-    yarn: {
-      installAll: "yarn install",
-      installPackage: (name, version) => `yarn add ${name}${version ? `@${version}` : ""}`,
-      installDev: "yarn install --dev",
-      add: (name, isDev) => isDev ? `yarn add -D ${name}` : `yarn add ${name}`
-    },
-    pnpm: {
-      installAll: "pnpm install",
-      installPackage: (name, version) => `pnpm add ${name}${version ? `@${version}` : ""}`,
-      installDev: "pnpm install --dev",
-      add: (name, isDev) => isDev ? `pnpm add -D ${name}` : `pnpm add ${name}`
-    },
-    bun: {
-      installAll: "bun install",
-      installPackage: (name, version) => `bun add ${name}${version ? `@${version}` : ""}`,
-      installDev: "bun install --dev",
-      add: (name, isDev) => isDev ? `bun add -d ${name}` : `bun add ${name}`
-    },
-    pip: {
-      installAll: "pip install -r requirements.txt",
-      installPackage: (name, version) => `pip install ${name}${version ? version.replace(/[*=]/, "==") : ""}`,
-      installDev: "pip install -r requirements-dev.txt",
-      add: (name) => `pip install ${name}`
-    },
-    poetry: {
-      installAll: "poetry install",
-      installPackage: (name, version) => `poetry add ${name}${version ? `=${version}` : ""}`,
-      installDev: "poetry install --with dev",
-      add: (name, isDev) => isDev ? `poetry add --group dev ${name}` : `poetry add ${name}`
-    },
-    pipenv: {
-      installAll: "pipenv install",
-      installPackage: (name, version) => `pipenv install ${name}${version ? `==${version}` : ""}`,
-      installDev: "pipenv install --dev",
-      add: (name, isDev) => isDev ? `pipenv install --dev ${name}` : `pipenv install ${name}`
-    },
-    go: {
-      installAll: "go mod download",
-      installPackage: (name) => `go get ${name}`,
-      installDev: "go mod download",
-      add: (name) => `go get ${name}`
-    },
-    cargo: {
-      installAll: "cargo build",
-      installPackage: (name, version) => `cargo add ${name}${version ? ` --vers ${version}` : ""}`,
-      installDev: "cargo build",
-      add: (name) => `cargo add ${name}`
-    }
-  };
-  return commands[packageManager] || commands.npm;
-}
-function detectConflicts(dependencies, _graph) {
-  const conflicts = [];
-  const versionMap = /* @__PURE__ */ new Map();
-  for (const dep of dependencies) {
-    if (!versionMap.has(dep.name)) {
-      versionMap.set(dep.name, /* @__PURE__ */ new Set());
-    }
-    versionMap.get(dep.name).add(dep.version);
-  }
-  for (const [name, versions] of versionMap) {
-    if (versions.size > 1) {
-      conflicts.push({
-        package: name,
-        versions: Array.from(versions),
-        requiredBy: [name],
-        severity: "warning"
-      });
-    }
-  }
-  return conflicts;
-}
-function detectCircularDependencies(graph) {
-  const circular = [];
-  const visited = /* @__PURE__ */ new Set();
-  const recStack = /* @__PURE__ */ new Set();
-  const path2 = [];
-  const dfs = (node) => {
-    visited.add(node);
-    recStack.add(node);
-    path2.push(node);
-    const neighbors = graph.get(node) || [];
-    for (const neighbor of neighbors) {
-      if (!visited.has(neighbor.name)) {
-        if (dfs(neighbor.name)) {
-          return true;
-        }
-      } else if (recStack.has(neighbor.name)) {
-        const cycleStart = path2.indexOf(neighbor.name);
-        const cycle = path2.slice(cycleStart).concat(neighbor.name);
-        circular.push(cycle);
-        return true;
-      }
-    }
-    path2.pop();
-    recStack.delete(node);
-    return false;
-  };
-  for (const node of graph.keys()) {
-    if (!visited.has(node)) {
-      dfs(node);
-    }
-  }
-  return circular;
-}
-
-async function pathExists$4(p) {
-  try {
-    await promises.access(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-const logger$5 = consola.withTag("go-analyzer");
-const FRAMEWORK_PATTERNS$3 = {
-  gin: {
-    imports: ["github.com/gin-gonic/gin"],
-    indicators: ["gin.Default()", "gin.Context"]
-  },
-  echo: {
-    imports: ["github.com/labstack/echo/v4"],
-    indicators: ["echo.New()", "echo.Context"]
-  },
-  fiber: {
-    imports: ["github.com/gofiber/fiber/v2"],
-    indicators: ["fiber.New()", "fiber.Ctx"]
-  },
-  chi: {
-    imports: ["github.com/go-chi/chi/v5"],
-    indicators: ["chi.NewRouter()", "chi.Router"]
-  },
-  mux: {
-    imports: ["github.com/gorilla/mux"],
-    indicators: ["mux.NewRouter()", "mux.Router"]
-  },
-  httprouter: {
-    imports: ["github.com/julienschmidt/httprouter"],
-    indicators: ["httprouter.New()", "httprouter.Params"]
-  },
-  fasthttp: {
-    imports: ["github.com/valyala/fasthttp"],
-    indicators: ["fasthttp.Server", "fasthttp.RequestHandler"]
-  },
-  grpc: {
-    imports: ["google.golang.org/grpc"],
-    indicators: ["grpc.NewServer()", "grpc.Dial"]
-  },
-  protobuf: {
-    imports: ["google.golang.org/protobuf"],
-    indicators: [".proto", "proto.Marshal"]
-  },
-  gorm: {
-    imports: ["gorm.io/gorm"],
-    indicators: ["gorm.Open", "gorm.DB"]
-  },
-  sql: {
-    imports: ["database/sql"],
-    indicators: ["sql.Open", "sql.DB"]
-  },
-  ent: {
-    imports: ["entgo.io/ent"],
-    indicators: ["ent.Client", "ent.Schema"]
-  },
-  cobra: {
-    imports: ["github.com/spf13/cobra"],
-    indicators: ["cobra.Command", "cobra.Execute"]
-  },
-  viper: {
-    imports: ["github.com/spf13/viper"],
-    indicators: ["viper.New", "viper.Get"]
-  },
-  testify: {
-    imports: ["github.com/stretchr/testify"],
-    indicators: ["assert.Equal", "require.NoError"]
-  },
-  mock: {
-    imports: ["github.com/golang/mock"],
-    indicators: ["gomock.Controller", "mockgen"]
-  },
-  redis: {
-    imports: ["github.com/redis/go-redis/v9"],
-    indicators: ["redis.NewClient", "redis.Client"]
-  },
-  mongo: {
-    imports: ["go.mongodb.org/mongo-driver"],
-    indicators: ["mongo.Connect", "mongo.Database"]
-  },
-  prometheus: {
-    imports: ["github.com/prometheus/client_golang"],
-    indicators: ["prometheus.Counter", "promhttp.Handler"]
-  },
-  jaeger: {
-    imports: ["github.com/uber/jaeger-client-go"],
-    indicators: ["jaeger.NewTracer", "jaeger.Config"]
-  },
-  kubernetes: {
-    imports: ["k8s.io/client-go"],
-    indicators: ["kubernetes.Clientset", "k8s.io"]
-  }
-};
-async function analyzeGoProject(projectPath, files, _languages) {
-  logger$5.info("Analyzing Go project");
-  const frameworks = [];
-  const goModPath = posix.join(projectPath, "go.mod");
-  let _goMod = null;
-  try {
-    if (await pathExists$4(goModPath)) {
-      const content = await promises.readFile(goModPath, "utf-8");
-      _goMod = parseGoMod(content);
-    }
-  } catch (error) {
-    logger$5.warn("Failed to read go.mod:", error);
-  }
-  const imports = await scanGoImports(projectPath, files);
-  for (const [frameworkName, patterns] of Object.entries(FRAMEWORK_PATTERNS$3)) {
-    const evidence = [];
-    let confidence = 0;
-    for (const importPath of patterns.imports) {
-      if (imports[importPath]) {
-        evidence.push(`Found import: ${importPath}`);
-        confidence += 0.5;
-      }
-    }
-    for (const indicator of patterns.indicators) {
-      const filesWithIndicator = Object.values(imports).flat();
-      if (filesWithIndicator.some((f) => f.includes(indicator))) {
-        evidence.push(`Found pattern: ${indicator}`);
-        confidence += 0.3;
-      }
-    }
-    if (confidence > 0) {
-      frameworks.push({
-        name: frameworkName,
-        category: getFrameworkCategory$3(frameworkName),
-        confidence: Math.min(confidence, 1),
-        evidence
-      });
-    }
-  }
-  await detectAdditionalPatterns$3(projectPath, files, frameworks, imports);
-  frameworks.sort((a, b) => b.confidence - a.confidence);
-  logger$5.debug(`Detected frameworks: ${frameworks.map((f) => `${f.name} (${Math.round(f.confidence * 100)}%)`).join(", ")}`);
-  return frameworks;
-}
-function parseGoMod(content) {
-  const result = {
-    requires: {}
-  };
-  const lines = content.split("\n");
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (trimmed.startsWith("module")) {
-      result.module = trimmed.split(" ")[1];
-    } else if (trimmed.startsWith("go")) {
-      result.go = trimmed.split(" ")[1];
-    } else if (trimmed.startsWith("require")) {
-      const parts = trimmed.split(" ");
-      if (parts.length >= 3) {
-        result.requires[parts[1]] = parts[2];
-      }
-    } else if (trimmed.includes(" ")) {
-      const parts = trimmed.split(" ");
-      if (parts.length >= 2 && !trimmed.startsWith("//")) {
-        result.requires[parts[0]] = parts[1];
-      }
-    }
-  }
-  return result;
-}
-async function scanGoImports(projectPath, files) {
-  const imports = {};
-  const goFiles = files.filter((f) => f.endsWith(".go"));
-  for (const file of goFiles) {
-    try {
-      const content = await promises.readFile(posix.join(projectPath, file), "utf-8");
-      const fileImports = extractGoImports(content);
-      for (const importPath of fileImports) {
-        if (!imports[importPath]) {
-          imports[importPath] = [];
-        }
-        imports[importPath].push(file);
-      }
-    } catch (error) {
-      logger$5.warn(`Failed to read ${file}:`, error);
-    }
-  }
-  return imports;
-}
-function extractGoImports(content) {
-  const imports = [];
-  const importRegex = /import\s+(?:\(\s*([\s\S]*?)\s*\)|(["`][^"`]+["`]))/g;
-  let match;
-  while ((match = importRegex.exec(content)) !== null) {
-    const importBlock = match[1] || match[2];
-    if (importBlock) {
-      const singleImportRegex = /["`]([^"`]+)["`]/g;
-      let importMatch;
-      while ((importMatch = singleImportRegex.exec(importBlock)) !== null) {
-        imports.push(importMatch[1]);
-      }
-    }
-  }
-  return imports;
-}
-function getFrameworkCategory$3(framework) {
-  const categories = {
-    web: [
-      "gin",
-      "echo",
-      "fiber",
-      "chi",
-      "mux",
-      "httprouter",
-      "fasthttp"
-    ],
-    rpc: ["grpc", "protobuf"],
-    database: ["gorm", "sql", "ent"],
-    cli: ["cobra", "viper"],
-    testing: ["testify", "mock"],
-    cache: ["redis"],
-    database2: ["mongo"],
-    monitoring: ["prometheus", "jaeger"],
-    infrastructure: ["kubernetes"]
-  };
-  for (const [category, frameworks] of Object.entries(categories)) {
-    if (frameworks.includes(framework)) {
-      return category;
-    }
-  }
-  return "other";
-}
-async function detectAdditionalPatterns$3(projectPath, files, frameworks, imports) {
-  const goModPath = posix.join(projectPath, "go.mod");
-  if (files.includes("go.mod") && await pathExists$4(goModPath)) {
-    try {
-      const content = await promises.readFile(goModPath, "utf-8");
-      const goVersionMatch = content.match(/^go\s+(\d+\.\d+)/m);
-      if (goVersionMatch) {
-        frameworks.push({
-          name: "go",
-          category: "language",
-          version: goVersionMatch[1],
-          confidence: 0.9,
-          evidence: ["Found go.mod"]
-        });
-      }
-    } catch (error) {
-      logger$5.warn("Failed to read go.mod:", error);
-    }
-  }
-  const dockerFiles = ["Dockerfile", "docker-compose.yml", "docker-compose.yaml"];
-  for (const file of dockerFiles) {
-    if (files.includes(file)) {
-      frameworks.push({
-        name: "docker",
-        category: "deployment",
-        confidence: 0.9,
-        evidence: [`Found ${file}`]
-      });
-    }
-  }
-  if (files.some((f) => f.endsWith("_test.go"))) {
-    frameworks.push({
-      name: "testing",
-      category: "testing",
-      confidence: 0.7,
-      evidence: ["Found test files"]
-    });
-  }
-  const buildFiles = {
-    "Makefile": "make",
-    "Dockerfile": "docker",
-    ".goreleaser.yml": "goreleaser",
-    ".goreleaser.yaml": "goreleaser"
-  };
-  for (const [file, tool] of Object.entries(buildFiles)) {
-    if (files.includes(file)) {
-      frameworks.push({
-        name: tool,
-        category: "build",
-        confidence: 0.8,
-        evidence: [`Found ${file}`]
-      });
-    }
-  }
-  const lintingTools = [
-    "github.com/golangci/golangci-lint",
-    "golang.org/x/lint",
-    "honnef.co/go/tools"
-  ];
-  for (const tool of lintingTools) {
-    if (imports[tool]) {
-      frameworks.push({
-        name: "golangci-lint",
-        category: "linting",
-        confidence: 0.8,
-        evidence: [`Found ${tool} import`]
-      });
-    }
-  }
-  const ciFiles = {
-    ".github/workflows": "github-actions",
-    ".gitlab-ci.yml": "gitlab-ci",
-    "Jenkinsfile": "jenkins",
-    ".travis.yml": "travis-ci"
-  };
-  for (const [file, tool] of Object.entries(ciFiles)) {
-    if (files.includes(file) || files.some((f) => f.startsWith(file))) {
-      frameworks.push({
-        name: tool,
-        category: "ci-cd",
-        confidence: 0.8,
-        evidence: [`Found ${file}`]
-      });
-    }
-  }
-  if (files.some((f) => f.endsWith(".proto"))) {
-    frameworks.push({
-      name: "protobuf",
-      category: "rpc",
-      confidence: 0.9,
-      evidence: ["Found .proto files"]
-    });
-  }
-  const goWorkPath = posix.join(projectPath, "go.work");
-  if (files.includes("go.work") && await pathExists$4(goWorkPath)) {
-    frameworks.push({
-      name: "workspace",
-      category: "workspace",
-      confidence: 0.9,
-      evidence: ["Found go.work"]
-    });
-  }
-  if (files.includes("vendor/") || files.some((f) => f.startsWith("vendor/"))) {
-    frameworks.push({
-      name: "vendor",
-      category: "dependency",
-      confidence: 0.8,
-      evidence: ["Found vendor directory"]
-    });
-  }
-}
-
-async function pathExists$3(p) {
-  try {
-    await promises.access(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-const logger$4 = consola.withTag("python-analyzer");
-const FRAMEWORK_PATTERNS$2 = {
-  "django": {
-    files: ["manage.py", "settings.py"],
-    dependencies: ["django"],
-    indicators: ["manage.py", "wsgi.py", "asgi.py", "settings/", "templates/", "static/"]
-  },
-  "fastapi": {
-    files: ["main.py"],
-    dependencies: ["fastapi"],
-    indicators: ["main.py", "app/", "api/", "routers/"]
-  },
-  "flask": {
-    files: ["app.py", "wsgi.py"],
-    dependencies: ["flask"],
-    indicators: ["app.py", "app/", "templates/", "static/"]
-  },
-  "tornado": {
-    files: [],
-    dependencies: ["tornado"],
-    indicators: ["tornado", "handlers/"]
-  },
-  "sanic": {
-    files: [],
-    dependencies: ["sanic"],
-    indicators: ["sanic"]
-  },
-  "quart": {
-    files: [],
-    dependencies: ["quart"],
-    indicators: ["quart"]
-  },
-  "falcon": {
-    files: [],
-    dependencies: ["falcon"],
-    indicators: ["falcon"]
-  },
-  "bottle": {
-    files: [],
-    dependencies: ["bottle"],
-    indicators: ["bottle"]
-  },
-  "pyramid": {
-    files: ["development.ini", "production.ini"],
-    dependencies: ["pyramid"],
-    indicators: ["development.ini", "production.ini"]
-  },
-  "starlette": {
-    files: [],
-    dependencies: ["starlette"],
-    indicators: ["starlette"]
-  },
-  "celery": {
-    files: ["celery.py"],
-    dependencies: ["celery"],
-    indicators: ["celery.py", "tasks.py", "celeryconfig.py"]
-  },
-  "pandas": {
-    files: [],
-    dependencies: ["pandas"],
-    indicators: ["pandas"]
-  },
-  "numpy": {
-    files: [],
-    dependencies: ["numpy"],
-    indicators: ["numpy"]
-  },
-  "scikit-learn": {
-    files: [],
-    dependencies: ["scikit-learn"],
-    indicators: ["sklearn"]
-  },
-  "tensorflow": {
-    files: [],
-    dependencies: ["tensorflow"],
-    indicators: ["tensorflow"]
-  },
-  "pytorch": {
-    files: [],
-    dependencies: ["torch"],
-    indicators: ["torch"]
-  },
-  "jupyter": {
-    files: [],
-    dependencies: ["jupyter"],
-    indicators: [".ipynb", "jupyter"]
-  },
-  "streamlit": {
-    files: [],
-    dependencies: ["streamlit"],
-    indicators: ["streamlit"]
-  },
-  "dash": {
-    files: [],
-    dependencies: ["dash"],
-    indicators: ["dash"]
-  },
-  "gradio": {
-    files: [],
-    dependencies: ["gradio"],
-    indicators: ["gradio"]
-  },
-  "pytest": {
-    files: [],
-    dependencies: ["pytest"],
-    indicators: ["pytest", "conftest.py", "test_"]
-  },
-  "unittest": {
-    files: [],
-    dependencies: [],
-    indicators: ["test_", "_test.py"]
-  },
-  "poetry": {
-    files: ["pyproject.toml"],
-    dependencies: [],
-    indicators: ["pyproject.toml", "poetry.lock"]
-  },
-  "pipenv": {
-    files: ["Pipfile"],
-    dependencies: [],
-    indicators: ["Pipfile", "Pipfile.lock"]
-  },
-  "conda": {
-    files: ["environment.yml", "environment.yaml"],
-    dependencies: [],
-    indicators: ["environment.yml", "environment.yaml"]
-  }
-};
-async function analyzePythonProject(projectPath, files, _languages) {
-  logger$4.info("Analyzing Python project");
-  const frameworks = [];
-  const dependencies = await analyzeDependencies(projectPath, files);
-  for (const [frameworkName, patterns] of Object.entries(FRAMEWORK_PATTERNS$2)) {
-    const evidence = [];
-    let confidence = 0;
-    for (const file of patterns.files) {
-      if (files.includes(file) || files.some((f) => f.includes(file))) {
-        evidence.push(`Found ${file}`);
-        confidence += 0.3;
-      }
-    }
-    for (const indicator of patterns.indicators) {
-      if (files.some((f) => f.includes(indicator))) {
-        evidence.push(`Found ${indicator} pattern`);
-        confidence += 0.2;
-      }
-    }
-    for (const dep of patterns.dependencies) {
-      if (dependencies[dep]) {
-        evidence.push(`Found ${dep} in dependencies`);
-        confidence += 0.4;
-      }
-    }
-    if (confidence > 0) {
-      frameworks.push({
-        name: frameworkName,
-        category: getFrameworkCategory$2(frameworkName),
-        version: dependencies[frameworkName],
-        confidence: Math.min(confidence, 1),
-        evidence
-      });
-    }
-  }
-  await detectAdditionalPatterns$2(projectPath, files, frameworks, dependencies);
-  frameworks.sort((a, b) => b.confidence - a.confidence);
-  logger$4.debug(`Detected frameworks: ${frameworks.map((f) => `${f.name} (${Math.round(f.confidence * 100)}%)`).join(", ")}`);
-  return frameworks;
-}
-async function analyzeDependencies(projectPath, files) {
-  const dependencies = {};
-  const requirementsPath = posix.join(projectPath, "requirements.txt");
-  if (files.includes("requirements.txt") && await pathExists$3(requirementsPath)) {
-    try {
-      const content = await promises.readFile(requirementsPath, "utf-8");
-      const lines = content.split("\n");
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (trimmed && !trimmed.startsWith("#")) {
-          const match = trimmed.match(/^([\w-]+)([[~=><].*)?$/);
-          if (match) {
-            dependencies[match[1]] = match[2] || "latest";
-          }
-        }
-      }
-    } catch (error) {
-      logger$4.warn("Failed to parse requirements.txt:", error);
-    }
-  }
-  const pyprojectPath = posix.join(projectPath, "pyproject.toml");
-  if (files.includes("pyproject.toml") && await pathExists$3(pyprojectPath)) {
-    try {
-      const content = await promises.readFile(pyprojectPath, "utf-8");
-      const parsed = parse(content);
-      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) && "tool" in parsed) {
-        const tool = parsed.tool;
-        if (typeof tool === "object" && tool !== null && !Array.isArray(tool) && "poetry" in tool) {
-          const poetry = tool.poetry;
-          if (typeof poetry === "object" && poetry !== null && !Array.isArray(poetry) && "dependencies" in poetry) {
-            const poetryDeps = poetry.dependencies;
-            if (typeof poetryDeps === "object" && poetryDeps !== null && !Array.isArray(poetryDeps)) {
-              Object.assign(dependencies, poetryDeps);
-            }
-          }
-        }
-      }
-      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) && "project" in parsed) {
-        const project = parsed.project;
-        if (typeof project === "object" && project !== null && !Array.isArray(project) && "dependencies" in project) {
-          const projectDeps = project.dependencies;
-          if (Array.isArray(projectDeps)) {
-            for (const dep of projectDeps) {
-              if (typeof dep === "string") {
-                const match = dep.match(/^([\w-]+)([[~=><].*)?$/);
-                if (match) {
-                  dependencies[match[1]] = match[2] || "latest";
-                }
-              }
-            }
-          }
-        }
-      }
-    } catch (error) {
-      logger$4.warn("Failed to parse pyproject.toml:", error);
-    }
-  }
-  const pipfilePath = posix.join(projectPath, "Pipfile");
-  if (files.includes("Pipfile") && await pathExists$3(pipfilePath)) {
-    try {
-      const content = await promises.readFile(pipfilePath, "utf-8");
-      const lines = content.split("\n");
-      let inPackages = false;
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (trimmed === "[packages]") {
-          inPackages = true;
-          continue;
-        }
-        if (trimmed.startsWith("[") && trimmed !== "[packages]") {
-          inPackages = false;
-          continue;
-        }
-        if (inPackages && trimmed && !trimmed.startsWith("#")) {
-          const match = trimmed.match(/^([\w-]+)\s*=\s*"?([^"]*)"?/);
-          if (match) {
-            dependencies[match[1]] = match[2] || "latest";
-          }
-        }
-      }
-    } catch (error) {
-      logger$4.warn("Failed to parse Pipfile:", error);
-    }
-  }
-  const setupPath = posix.join(projectPath, "setup.py");
-  if (files.includes("setup.py") && await pathExists$3(setupPath)) {
-    try {
-      const content = await promises.readFile(setupPath, "utf-8");
-      const installRequiresMatch = content.match(/install_requires\s*=\s*\[([\s\S]*?)\]/);
-      if (installRequiresMatch) {
-        const requiresList = installRequiresMatch[1];
-        const requires = requiresList.match(/['"`]([\w-]+)/g);
-        if (requires) {
-          for (const req of requires) {
-            const name = req.replace(/['"`]/g, "");
-            dependencies[name] = "latest";
-          }
-        }
-      }
-    } catch (error) {
-      logger$4.warn("Failed to parse setup.py:", error);
-    }
-  }
-  const envPath = posix.join(projectPath, "environment.yml");
-  if (files.includes("environment.yml") && await pathExists$3(envPath)) {
-    try {
-      const content = await promises.readFile(envPath, "utf-8");
-      const parsed = parse(content);
-      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) && "dependencies" in parsed) {
-        const deps = parsed.dependencies;
-        if (Array.isArray(deps)) {
-          for (const dep of deps) {
-            if (typeof dep === "string") {
-              const match = dep.match(/^([\w-]+)([[~=><].*)?$/);
-              if (match) {
-                dependencies[match[1]] = match[2] || "latest";
-              }
-            }
-          }
-        }
-      }
-    } catch (error) {
-      logger$4.warn("Failed to parse environment.yml:", error);
-    }
-  }
-  return dependencies;
-}
-function getFrameworkCategory$2(framework) {
-  const categories = {
-    web: [
-      "django",
-      "fastapi",
-      "flask",
-      "tornado",
-      "sanic",
-      "quart",
-      "falcon",
-      "bottle",
-      "pyramid",
-      "starlette"
-    ],
-    async: ["celery"],
-    data: ["pandas", "numpy", "scikit-learn", "tensorflow", "pytorch"],
-    notebook: ["jupyter"],
-    ui: ["streamlit", "dash", "gradio"],
-    testing: ["pytest", "unittest"],
-    package: ["poetry", "pipenv", "conda"]
-  };
-  for (const [category, frameworks] of Object.entries(categories)) {
-    if (frameworks.includes(framework)) {
-      return category;
-    }
-  }
-  return "other";
-}
-async function detectAdditionalPatterns$2(projectPath, files, frameworks, dependencies) {
-  const pythonVersionPath = posix.join(projectPath, ".python-version");
-  if (files.includes(".python-version") && await pathExists$3(pythonVersionPath)) {
-    try {
-      const version = await promises.readFile(pythonVersionPath, "utf-8");
-      frameworks.push({
-        name: "python",
-        category: "language",
-        version: version.trim(),
-        confidence: 0.9,
-        evidence: ["Found .python-version"]
-      });
-    } catch (error) {
-      logger$4.warn("Failed to read .python-version:", error);
-    }
-  }
-  const dockerFiles = ["Dockerfile", "docker-compose.yml", "docker-compose.yaml"];
-  for (const file of dockerFiles) {
-    if (files.includes(file)) {
-      frameworks.push({
-        name: "docker",
-        category: "deployment",
-        confidence: 0.9,
-        evidence: [`Found ${file}`]
-      });
-    }
-  }
-  if (files.some((f) => f.startsWith("test_") || f.includes("_test.py"))) {
-    frameworks.push({
-      name: "unittest",
-      category: "testing",
-      confidence: 0.6,
-      evidence: ["Found test files"]
-    });
-  }
-  const lintingTools = ["flake8", "pylint", "black", "isort", "mypy"];
-  for (const tool of lintingTools) {
-    if (dependencies[tool]) {
-      frameworks.push({
-        name: tool,
-        category: "linting",
-        version: dependencies[tool],
-        confidence: 0.8,
-        evidence: [`Found ${tool} in dependencies`]
-      });
-    }
-  }
-  const configFiles = {
-    "setup.cfg": "setuptools",
-    "tox.ini": "tox",
-    "mypy.ini": "mypy",
-    ".flake8": "flake8",
-    ".pylintrc": "pylint",
-    "pytest.ini": "pytest",
-    "pyproject.toml": "modern-python"
-  };
-  for (const [file, tool] of Object.entries(configFiles)) {
-    if (files.includes(file)) {
-      frameworks.push({
-        name: tool,
-        category: "config",
-        confidence: 0.8,
-        evidence: [`Found ${file}`]
-      });
-    }
-  }
-}
-
-async function pathExists$2(p) {
-  try {
-    await promises.access(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-const logger$3 = consola.withTag("rust-analyzer");
-const FRAMEWORK_PATTERNS$1 = {
-  "actix-web": {
-    dependencies: ["actix-web"],
-    indicators: ["HttpServer", "web::"]
-  },
-  "rocket": {
-    dependencies: ["rocket"],
-    indicators: ["rocket::", "#[get]", "#[post]"]
-  },
-  "tokio": {
-    dependencies: ["tokio"],
-    indicators: ["tokio::", "#[tokio::main]"]
-  },
-  "async-std": {
-    dependencies: ["async-std"],
-    indicators: ["async_std::"]
-  },
-  "serde": {
-    dependencies: ["serde"],
-    indicators: ["serde::", "Serialize", "Deserialize"]
-  },
-  "clap": {
-    dependencies: ["clap"],
-    indicators: ["clap::", "Command", "Parser"]
-  },
-  "axum": {
-    dependencies: ["axum"],
-    indicators: ["axum::", "Router"]
-  },
-  "warp": {
-    dependencies: ["warp"],
-    indicators: ["warp::", "Filter"]
-  },
-  "hyper": {
-    dependencies: ["hyper"],
-    indicators: ["hyper::", "Request", "Response"]
-  },
-  "tide": {
-    dependencies: ["tide"],
-    indicators: ["tide::", "Server"]
-  },
-  "tracing": {
-    dependencies: ["tracing"],
-    indicators: ["tracing::", "#[instrument]"]
-  },
-  "log": {
-    dependencies: ["log"],
-    indicators: ["log::", "info!", "debug!"]
-  },
-  "anyhow": {
-    dependencies: ["anyhow"],
-    indicators: ["anyhow::", "anyhow!"]
-  },
-  "thiserror": {
-    dependencies: ["thiserror"],
-    indicators: ["thiserror::", "#[error]"]
-  },
-  "sqlx": {
-    dependencies: ["sqlx"],
-    indicators: ["sqlx::", "PgPool"]
-  },
-  "diesel": {
-    dependencies: ["diesel"],
-    indicators: ["diesel::", "prelude::*"]
-  },
-  "sea-orm": {
-    dependencies: ["sea-orm"],
-    indicators: ["sea_orm::", "Database"]
-  },
-  "redis": {
-    dependencies: ["redis"],
-    indicators: ["redis::", "Connection"]
-  },
-  "tokio-postgres": {
-    dependencies: ["tokio-postgres"],
-    indicators: ["tokio_postgres::", "Client"]
-  },
-  "prometheus": {
-    dependencies: ["prometheus"],
-    indicators: ["prometheus::", "Counter"]
-  },
-  "sentry": {
-    dependencies: ["sentry"],
-    indicators: ["sentry::", "capture_event"]
-  },
-  "uuid": {
-    dependencies: ["uuid"],
-    indicators: ["uuid::", "Uuid"]
-  },
-  "chrono": {
-    dependencies: ["chrono"],
-    indicators: ["chrono::", "DateTime"]
-  },
-  "regex": {
-    dependencies: ["regex"],
-    indicators: ["regex::", "Regex"]
-  },
-  "rand": {
-    dependencies: ["rand"],
-    indicators: ["rand::", "Rng"]
-  },
-  "serde_json": {
-    dependencies: ["serde_json"],
-    indicators: ["serde_json::", "json!"]
-  },
-  "tower": {
-    dependencies: ["tower"],
-    indicators: ["tower::", "Service"]
-  },
-  "prost": {
-    dependencies: ["prost"],
-    indicators: ["prost::", "Message"]
-  },
-  "tonic": {
-    dependencies: ["tonic"],
-    indicators: ["tonic::", "#[tonic::async_trait]"]
-  },
-  "yew": {
-    dependencies: ["yew"],
-    indicators: ["yew::", "html!"]
-  },
-  "leptos": {
-    dependencies: ["leptos"],
-    indicators: ["leptos::", "view!"]
-  },
-  "tauri": {
-    dependencies: ["tauri"],
-    indicators: ["tauri::", "#[tauri::command]"]
-  },
-  "bevy": {
-    dependencies: ["bevy"],
-    indicators: ["bevy::", "App"]
-  },
-  "egui": {
-    dependencies: ["egui"],
-    indicators: ["egui::", "CentralPanel"]
-  }
-};
-async function analyzeRustProject(projectPath, files, _languages) {
-  logger$3.info("Analyzing Rust project");
-  const frameworks = [];
-  const cargoTomlPath = posix.join(projectPath, "Cargo.toml");
-  let cargoToml = null;
-  try {
-    if (await pathExists$2(cargoTomlPath)) {
-      const content = await promises.readFile(cargoTomlPath, "utf-8");
-      cargoToml = parse(content);
-    }
-  } catch (error) {
-    logger$3.warn("Failed to read Cargo.toml:", error);
-  }
-  const dependencies = extractCargoDependencies(cargoToml);
-  const patterns = await scanRustPatterns(projectPath, files);
-  for (const [frameworkName, frameworkPatterns] of Object.entries(FRAMEWORK_PATTERNS$1)) {
-    const evidence = [];
-    let confidence = 0;
-    for (const dep of frameworkPatterns.dependencies) {
-      if (dependencies[dep]) {
-        evidence.push(`Found ${dep} in dependencies`);
-        confidence += 0.5;
-      }
-    }
-    for (const indicator of frameworkPatterns.indicators) {
-      if (patterns[indicator]) {
-        evidence.push(`Found pattern: ${indicator}`);
-        confidence += 0.3;
-      }
-    }
-    if (confidence > 0) {
-      frameworks.push({
-        name: frameworkName,
-        category: getFrameworkCategory$1(frameworkName),
-        version: dependencies[frameworkName],
-        confidence: Math.min(confidence, 1),
-        evidence
-      });
-    }
-  }
-  await detectAdditionalPatterns$1(projectPath, files, frameworks, dependencies, patterns, cargoToml);
-  frameworks.sort((a, b) => b.confidence - a.confidence);
-  logger$3.debug(`Detected frameworks: ${frameworks.map((f) => `${f.name} (${Math.round(f.confidence * 100)}%)`).join(", ")}`);
-  return frameworks;
-}
-function extractCargoDependencies(cargoToml) {
-  const dependencies = {};
-  if (!cargoToml) {
-    return dependencies;
-  }
-  const depsSections = [
-    cargoToml.dependencies,
-    cargoToml["dev-dependencies"],
-    cargoToml["build-dependencies"]
-  ];
-  for (const section of depsSections) {
-    if (typeof section === "object") {
-      for (const [name, version] of Object.entries(section)) {
-        if (typeof version === "string") {
-          dependencies[name] = version;
-        } else if (typeof version === "object" && version !== null && "version" in version) {
-          dependencies[name] = version.version;
-        }
-      }
-    }
-  }
-  if (cargoToml.workspace?.dependencies) {
-    for (const [name, version] of Object.entries(cargoToml.workspace.dependencies)) {
-      if (!dependencies[name]) {
-        if (typeof version === "string") {
-          dependencies[name] = version;
-        } else if (typeof version === "object" && version !== null && "version" in version) {
-          dependencies[name] = version.version;
-        }
-      }
-    }
-  }
-  return dependencies;
-}
-async function scanRustPatterns(projectPath, files) {
-  const patterns = {};
-  const rustFiles = files.filter((f) => f.endsWith(".rs"));
-  for (const file of rustFiles) {
-    try {
-      const content = await promises.readFile(posix.join(projectPath, file), "utf-8");
-      const patternRegex = /(\w+::|@\[|!\w+\()/g;
-      let match;
-      while ((match = patternRegex.exec(content)) !== null) {
-        const pattern = match[1];
-        patterns[pattern] = (patterns[pattern] || 0) + 1;
-      }
-      const macroRegex = /(\w+!)/g;
-      while ((match = macroRegex.exec(content)) !== null) {
-        const macroName = match[1];
-        patterns[macroName] = (patterns[macroName] || 0) + 1;
-      }
-      const traitRegex = /:\s*([\w\s,]+)(?:\s*\{|<)/g;
-      while ((match = traitRegex.exec(content)) !== null) {
-        const traits = match[1].split(",").map((t) => t.trim());
-        for (const trait of traits) {
-          patterns[trait] = (patterns[trait] || 0) + 1;
-        }
-      }
-    } catch (error) {
-      logger$3.warn(`Failed to read ${file}:`, error);
-    }
-  }
-  return patterns;
-}
-function getFrameworkCategory$1(framework) {
-  const categories = {
-    web: [
-      "actix-web",
-      "rocket",
-      "axum",
-      "warp",
-      "hyper",
-      "tide"
-    ],
-    async: ["tokio", "async-std"],
-    serialization: ["serde", "serde_json"],
-    cli: ["clap"],
-    error: ["anyhow", "thiserror"],
-    logging: ["tracing", "log"],
-    database: ["sqlx", "diesel", "sea-orm", "tokio-postgres"],
-    cache: ["redis"],
-    monitoring: ["prometheus", "sentry"],
-    utility: ["uuid", "chrono", "regex", "rand"],
-    middleware: ["tower"],
-    rpc: ["prost", "tonic"],
-    frontend: ["yew", "leptos"],
-    desktop: ["tauri"],
-    game: ["bevy"],
-    gui: ["egui"]
-  };
-  for (const [category, frameworks] of Object.entries(categories)) {
-    if (frameworks.includes(framework)) {
-      return category;
-    }
-  }
-  return "other";
-}
-async function detectAdditionalPatterns$1(projectPath, files, frameworks, dependencies, patterns, cargoToml) {
-  if (cargoToml?.package?.edition) {
-    frameworks.push({
-      name: "rust",
-      category: "language",
-      version: cargoToml.package.edition,
-      confidence: 0.9,
-      evidence: ["Found Cargo.toml"]
-    });
-  }
-  if (cargoToml?.workspace) {
-    frameworks.push({
-      name: "workspace",
-      category: "workspace",
-      confidence: 0.9,
-      evidence: ["Found workspace in Cargo.toml"]
-    });
-  }
-  if (cargoToml?.bin) {
-    frameworks.push({
-      name: "binary",
-      category: "build",
-      confidence: 0.8,
-      evidence: ["Found binary targets"]
-    });
-  }
-  if (cargoToml?.lib) {
-    frameworks.push({
-      name: "library",
-      category: "build",
-      confidence: 0.8,
-      evidence: ["Found library configuration"]
-    });
-  }
-  const dockerFiles = ["Dockerfile", "docker-compose.yml", "docker-compose.yaml"];
-  for (const file of dockerFiles) {
-    if (files.includes(file)) {
-      frameworks.push({
-        name: "docker",
-        category: "deployment",
-        confidence: 0.9,
-        evidence: [`Found ${file}`]
-      });
-    }
-  }
-  if (files.some((f) => f.endsWith("_test.rs")) || patterns["#["] && patterns["#["] > 0) {
-    frameworks.push({
-      name: "testing",
-      category: "testing",
-      confidence: 0.7,
-      evidence: ["Found test files"]
-    });
-  }
-  if (files.some((f) => f.endsWith("_bench.rs"))) {
-    frameworks.push({
-      name: "benchmark",
-      category: "testing",
-      confidence: 0.8,
-      evidence: ["Found benchmark files"]
-    });
-  }
-  if (files.some((f) => f.startsWith("examples/"))) {
-    frameworks.push({
-      name: "examples",
-      category: "documentation",
-      confidence: 0.7,
-      evidence: ["Found examples directory"]
-    });
-  }
-  const ciFiles = {
-    ".github/workflows": "github-actions",
-    ".gitlab-ci.yml": "gitlab-ci",
-    "Jenkinsfile": "jenkins",
-    ".travis.yml": "travis-ci"
-  };
-  for (const [file, tool] of Object.entries(ciFiles)) {
-    if (files.includes(file) || files.some((f) => f.startsWith(file))) {
-      frameworks.push({
-        name: tool,
-        category: "ci-cd",
-        confidence: 0.8,
-        evidence: [`Found ${file}`]
-      });
-    }
-  }
-  const buildFiles = {
-    "Makefile": "make",
-    "justfile": "just",
-    "build.rs": "build-script"
-  };
-  for (const [file, tool] of Object.entries(buildFiles)) {
-    if (files.includes(file)) {
-      frameworks.push({
-        name: tool,
-        category: "build",
-        confidence: 0.8,
-        evidence: [`Found ${file}`]
-      });
-    }
-  }
-  if (files.some((f) => f.endsWith(".proto"))) {
-    frameworks.push({
-      name: "protobuf",
-      category: "rpc",
-      confidence: 0.9,
-      evidence: ["Found .proto files"]
-    });
-  }
-  if (dependencies["wasm-bindgen"] || dependencies["wasm-pack"]) {
-    frameworks.push({
-      name: "wasm",
-      category: "webassembly",
-      confidence: 0.8,
-      evidence: ["Found WASM dependencies"]
-    });
-  }
-  if (patterns["#![no_std]"]) {
-    frameworks.push({
-      name: "no_std",
-      category: "embedded",
-      confidence: 0.9,
-      evidence: ["Found #![no_std]"]
-    });
-  }
-  if (cargoToml?.lib?.proc_macro) {
-    frameworks.push({
-      name: "proc-macro",
-      category: "meta",
-      confidence: 0.9,
-      evidence: ["Found proc-macro configuration"]
-    });
-  }
-  if (dependencies.clippy) {
-    frameworks.push({
-      name: "clippy",
-      category: "linting",
-      confidence: 0.8,
-      evidence: ["Found clippy dependency"]
-    });
-  }
-  if (dependencies.rustfmt) {
-    frameworks.push({
-      name: "rustfmt",
-      category: "formatting",
-      confidence: 0.8,
-      evidence: ["Found rustfmt dependency"]
-    });
-  }
-  if (dependencies.rustdoc) {
-    frameworks.push({
-      name: "rustdoc",
-      category: "documentation",
-      confidence: 0.8,
-      evidence: ["Found rustdoc dependency"]
-    });
-  }
-  if (cargoToml?.package?.publish) {
-    frameworks.push({
-      name: "crates.io",
-      category: "registry",
-      confidence: 0.7,
-      evidence: ["Found publish configuration"]
-    });
-  }
-  if (cargoToml?.package?.license) {
-    frameworks.push({
-      name: cargoToml.package.license,
-      category: "legal",
-      confidence: 0.6,
-      evidence: ["Found license in Cargo.toml"]
-    });
-  }
-  if (cargoToml?.package) {
-    const type = cargoToml.bin ? "binary" : cargoToml.lib ? "library" : "unknown";
-    frameworks.push({
-      name: type,
-      category: "package",
-      confidence: 0.9,
-      evidence: [`Detected as ${type}`]
-    });
-  }
-  if (files.includes("target/") || files.some((f) => f.startsWith("target/"))) {
-    logger$3.debug("Found target/ directory (build artifacts)");
-  }
-  if (files.includes("Cargo.lock")) {
-    frameworks.push({
-      name: "cargo-lock",
-      category: "dependency",
-      confidence: 0.9,
-      evidence: ["Found Cargo.lock"]
-    });
-  }
-}
-
-async function pathExists$1(p) {
-  try {
-    await promises.access(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function readJson(p) {
-  const content = await promises.readFile(p, "utf-8");
-  return JSON.parse(content);
-}
-const logger$2 = consola.withTag("typescript-analyzer");
-const FRAMEWORK_PATTERNS = {
-  "next.js": {
-    files: ["next.config.js", "next.config.ts", "next.config.mjs"],
-    dependencies: ["next"],
-    indicators: ["pages/", "app/", "src/app/", "src/pages/"]
-  },
-  "nuxt": {
-    files: ["nuxt.config.js", "nuxt.config.ts"],
-    dependencies: ["nuxt"],
-    indicators: ["pages/", "layouts/", "components/", "store/"]
-  },
-  "sveltekit": {
-    files: ["svelte.config.js", "svelte.config.ts"],
-    dependencies: ["@sveltejs/kit"],
-    indicators: ["src/routes/", "src/lib/", ".svelte-kit/"]
-  },
-  "astro": {
-    files: ["astro.config.js", "astro.config.mjs", "astro.config.ts"],
-    dependencies: ["astro"],
-    indicators: ["src/pages/", "src/content/", "src/components/"]
-  },
-  "solidstart": {
-    files: ["vite.config.ts", "vite.config.js"],
-    dependencies: ["solid-start"],
-    indicators: ["src/routes/", "src/components/"]
-  },
-  "qwik": {
-    files: ["vite.config.ts"],
-    dependencies: ["@builder.io/qwik"],
-    indicators: ["src/routes/", "src/components/"]
-  },
-  "remix": {
-    files: ["remix.config.js", "vite.config.ts"],
-    dependencies: ["@remix-run/node"],
-    indicators: ["app/", "app/routes/", "app/components/"]
-  },
-  "gatsby": {
-    files: ["gatsby-config.js", "gatsby-config.ts"],
-    dependencies: ["gatsby"],
-    indicators: ["src/pages/", "src/templates/", "gatsby-node.js"]
-  },
-  "vue": {
-    files: ["vue.config.js"],
-    dependencies: ["vue"],
-    indicators: ["src/components/", "src/views/", "src/router/"]
-  },
-  "angular": {
-    files: ["angular.json"],
-    dependencies: ["@angular/core"],
-    indicators: ["src/app/", "e2e/", ".angular/"]
-  },
-  "react": {
-    files: [],
-    dependencies: ["react", "react-dom"],
-    indicators: ["src/", "components/", "src/components/"]
-  },
-  "preact": {
-    files: [],
-    dependencies: ["preact"],
-    indicators: ["src/", "components/"]
-  },
-  "solidjs": {
-    files: [],
-    dependencies: ["solid-js"],
-    indicators: ["src/", "components/"]
-  },
-  "svelte": {
-    files: [],
-    dependencies: ["svelte"],
-    indicators: ["src/", "components/", "src/components/"]
-  },
-  "nest.js": {
-    files: ["nest-cli.json"],
-    dependencies: ["@nestjs/core"],
-    indicators: ["src/", "src/modules/", "src/controllers/"]
-  },
-  "express": {
-    files: [],
-    dependencies: ["express"],
-    indicators: ["app.js", "server.js", "routes/", "middleware/"]
-  },
-  "fastify": {
-    files: [],
-    dependencies: ["fastify"],
-    indicators: ["app.js", "server.js", "routes/", "plugins/"]
-  },
-  "koa": {
-    files: [],
-    dependencies: ["koa"],
-    indicators: ["app.js", "server.js", "middleware/"]
-  },
-  "adonisjs": {
-    files: [".adonisrc.json"],
-    dependencies: ["@adonisjs/core"],
-    indicators: ["app/", "config/", "start/", "providers/"]
-  },
-  "feathers": {
-    files: [],
-    dependencies: ["@feathersjs/feathers"],
-    indicators: ["src/", "services/"]
-  },
-  "meteor": {
-    files: [".meteor/"],
-    dependencies: ["meteor-node-stubs"],
-    indicators: ["client/", "server/", "imports/"]
-  },
-  "ionic": {
-    files: ["ionic.config.json"],
-    dependencies: ["@ionic/core"],
-    indicators: ["src/", "www/"]
-  },
-  "electron": {
-    files: [],
-    dependencies: ["electron"],
-    indicators: ["main.js", "src/main/", "electron/"]
-  },
-  "turborepo": {
-    files: ["turbo.json"],
-    dependencies: ["turbo"],
-    indicators: ["apps/", "packages/"]
-  },
-  "nx": {
-    files: ["nx.json"],
-    dependencies: ["nx"],
-    indicators: ["apps/", "libs/"]
-  },
-  "lerna": {
-    files: ["lerna.json"],
-    dependencies: ["lerna"],
-    indicators: ["packages/"]
-  }
-};
-async function analyzeTypeScriptProject(projectPath, files, _languages) {
-  logger$2.info("Analyzing TypeScript/JavaScript project");
-  const frameworks = [];
-  const packageJsonPath = posix.join(projectPath, "package.json");
-  let packageJson = null;
-  try {
-    if (await pathExists$1(packageJsonPath)) {
-      packageJson = await readJson(packageJsonPath);
-    }
-  } catch (error) {
-    logger$2.warn("Failed to read package.json:", error);
-  }
-  for (const [frameworkName, patterns] of Object.entries(FRAMEWORK_PATTERNS)) {
-    const evidence = [];
-    let confidence = 0;
-    for (const file of patterns.files) {
-      if (files.includes(file)) {
-        evidence.push(`Found ${file}`);
-        confidence += 0.3;
-      }
-    }
-    for (const indicator of patterns.indicators) {
-      const indicatorPath = posix.join(projectPath, indicator);
-      if (files.some((f) => f.startsWith(indicator)) || await pathExists$1(indicatorPath)) {
-        evidence.push(`Found ${indicator} directory`);
-        confidence += 0.2;
-      }
-    }
-    if (packageJson) {
-      const allDeps = {
-        ...packageJson.dependencies,
-        ...packageJson.devDependencies
-      };
-      for (const dep of patterns.dependencies) {
-        if (allDeps[dep]) {
-          evidence.push(`Found ${dep} in dependencies`);
-          confidence += 0.4;
-        }
-      }
-    }
-    if (confidence > 0) {
-      let version;
-      if (packageJson) {
-        for (const dep of patterns.dependencies) {
-          const depVersion = packageJson.dependencies?.[dep] || packageJson.devDependencies?.[dep];
-          if (depVersion) {
-            version = depVersion;
-            break;
-          }
-        }
-      }
-      frameworks.push({
-        name: frameworkName,
-        category: getFrameworkCategory(frameworkName),
-        version,
-        confidence: Math.min(confidence, 1),
-        evidence
-      });
-    }
-  }
-  await detectAdditionalPatterns(projectPath, files, frameworks, packageJson);
-  frameworks.sort((a, b) => b.confidence - a.confidence);
-  logger$2.debug(`Detected frameworks: ${frameworks.map((f) => `${f.name} (${Math.round(f.confidence * 100)}%)`).join(", ")}`);
-  return frameworks;
-}
-function getFrameworkCategory(framework) {
-  const categories = {
-    frontend: [
-      "next.js",
-      "nuxt",
-      "sveltekit",
-      "astro",
-      "solidstart",
-      "qwik",
-      "remix",
-      "gatsby",
-      "vue",
-      "angular",
-      "react",
-      "preact",
-      "solidjs",
-      "svelte",
-      "ionic"
-    ],
-    backend: [
-      "nest.js",
-      "express",
-      "fastify",
-      "koa",
-      "adonisjs",
-      "feathers",
-      "meteor"
-    ],
-    desktop: ["electron"],
-    monorepo: ["turborepo", "nx", "lerna"]
-  };
-  for (const [category, frameworks] of Object.entries(categories)) {
-    if (frameworks.includes(framework)) {
-      return category;
-    }
-  }
-  return "other";
-}
-async function detectAdditionalPatterns(projectPath, files, frameworks, packageJson) {
-  if (files.includes("tsconfig.json")) {
-    const tsFramework = frameworks.find((f) => f.name === "typescript");
-    if (!tsFramework) {
-      frameworks.push({
-        name: "typescript",
-        category: "language",
-        confidence: 0.9,
-        evidence: ["Found tsconfig.json"]
-      });
-    }
-  }
-  const testDependencies = ["jest", "vitest", "cypress", "playwright", "mocha", "jasmine"];
-  if (packageJson) {
-    const allDeps = {
-      ...packageJson.dependencies,
-      ...packageJson.devDependencies
-    };
-    for (const testDep of testDependencies) {
-      if (allDeps[testDep]) {
-        frameworks.push({
-          name: testDep,
-          category: "testing",
-          version: allDeps[testDep],
-          confidence: 0.8,
-          evidence: [`Found ${testDep} in dependencies`]
-        });
-      }
-    }
-  }
-  const cssFrameworks = ["tailwindcss", "bootstrap", "bulma", "material-ui", "chakra-ui"];
-  if (packageJson) {
-    const allDeps = {
-      ...packageJson.dependencies,
-      ...packageJson.devDependencies
-    };
-    for (const cssFw of cssFrameworks) {
-      if (allDeps[cssFw]) {
-        frameworks.push({
-          name: cssFw,
-          category: "css",
-          version: allDeps[cssFw],
-          confidence: 0.8,
-          evidence: [`Found ${cssFw} in dependencies`]
-        });
-      }
-    }
-  }
-  const stateLibs = ["redux", "zustand", "recoil", "jotai", "valtio"];
-  if (packageJson) {
-    const allDeps = {
-      ...packageJson.dependencies,
-      ...packageJson.devDependencies
-    };
-    for (const lib of stateLibs) {
-      if (allDeps[lib]) {
-        frameworks.push({
-          name: lib,
-          category: "state-management",
-          version: allDeps[lib],
-          confidence: 0.8,
-          evidence: [`Found ${lib} in dependencies`]
-        });
-      }
-    }
-  }
-  const lintingTools = ["eslint", "prettier", "biome", "rome"];
-  if (packageJson) {
-    const allDeps = {
-      ...packageJson.dependencies,
-      ...packageJson.devDependencies
-    };
-    for (const tool of lintingTools) {
-      if (allDeps[tool]) {
-        frameworks.push({
-          name: tool,
-          category: "linting",
-          version: allDeps[tool],
-          confidence: 0.8,
-          evidence: [`Found ${tool} in dependencies`]
-        });
-      }
-    }
-  }
-  const deploymentFiles = {
-    "vercel.json": "vercel",
-    "netlify.toml": "netlify",
-    "app.yaml": "app-engine",
-    "now.json": "now"
-  };
-  for (const [file, platform] of Object.entries(deploymentFiles)) {
-    if (files.includes(file)) {
-      frameworks.push({
-        name: platform,
-        category: "deployment",
-        confidence: 0.9,
-        evidence: [`Found ${file}`]
-      });
-    }
-  }
-}
-
-async function pathExists(p) {
-  try {
-    await promises.access(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-const logger$1 = consola.withTag("project-detector");
-const LANGUAGE_PATTERNS = {
-  typescript: {
-    files: ["package.json", "tsconfig.json", "tsconfig.build.json"],
-    extensions: [".ts", ".tsx", ".mts", ".cts"],
-    indicators: ["node_modules", "yarn.lock", "package-lock.json", "pnpm-lock.yaml"]
-  },
-  javascript: {
-    files: ["package.json"],
-    extensions: [".js", ".jsx", ".mjs", ".cjs"],
-    indicators: ["node_modules", "yarn.lock", "package-lock.json", "pnpm-lock.yaml"]
-  },
-  python: {
-    files: ["requirements.txt", "pyproject.toml", "setup.py", "Pipfile"],
-    extensions: [".py", ".pyx", ".pyi"],
-    indicators: [".venv", "venv", "__pycache__", ".python-version"]
-  },
-  go: {
-    files: ["go.mod", "go.sum"],
-    extensions: [".go"],
-    indicators: ["vendor", "Gopkg.lock"]
-  },
-  rust: {
-    files: ["Cargo.toml", "Cargo.lock"],
-    extensions: [".rs"],
-    indicators: ["target"]
-  },
-  java: {
-    files: ["pom.xml", "build.gradle", "build.gradle.kts"],
-    extensions: [".java", ".kt"],
-    indicators: ["gradlew", "mvnw"]
-  },
-  dotnet: {
-    files: ["*.csproj", "*.sln", "*.fsproj", "*.vbproj"],
-    extensions: [".cs", ".fs", ".vb"],
-    indicators: ["bin", "obj"]
-  },
-  ruby: {
-    files: ["Gemfile", "Gemfile.lock"],
-    extensions: [".rb"],
-    indicators: ["vendor/bundle"]
-  },
-  php: {
-    files: ["composer.json", "composer.lock"],
-    extensions: [".php"],
-    indicators: ["vendor"]
-  },
-  swift: {
-    files: ["Package.swift"],
-    extensions: [".swift"],
-    indicators: [".build"]
-  },
-  kotlin: {
-    files: ["build.gradle.kts"],
-    extensions: [".kt", ".kts"],
-    indicators: ["gradlew"]
-  },
-  dart: {
-    files: ["pubspec.yaml"],
-    extensions: [".dart"],
-    indicators: [".dart_tool"]
-  }
-};
-const FRAMEWORK_PRIORITY = {
-  "next.js": 10,
-  "nuxt": 9,
-  "sveltekit": 8,
-  "astro": 7,
-  "solidstart": 6,
-  "qwik": 5,
-  "remix": 4,
-  "gatsby": 3,
-  "create-react-app": 2,
-  "vue": 1,
-  "angular": 1,
-  "react": 0
-};
-async function detectProject(projectPath, config) {
-  const startTime = Date.now();
-  logger$1.info(`Detecting project at: ${projectPath}`);
-  const absolutePath = posix.resolve(projectPath);
-  if (!await pathExists(absolutePath)) {
-    throw new Error(`Project path does not exist: ${absolutePath}`);
-  }
-  const files = await scanProjectFiles(absolutePath, config);
-  logger$1.debug(`Scanned ${files.length} files`);
-  const languages = await detectLanguages(absolutePath, files, config);
-  logger$1.debug(`Detected languages: ${languages.map((l) => l.language).join(", ")}`);
-  languages.sort((a, b) => b.confidence - a.confidence);
-  const primaryLanguage = languages[0];
-  let frameworks = [];
-  if (primaryLanguage) {
-    switch (primaryLanguage.language) {
-      case "typescript":
-      case "javascript":
-        frameworks = await analyzeTypeScriptProject(absolutePath, files);
-        break;
-      case "python":
-        frameworks = await analyzePythonProject(absolutePath, files);
-        break;
-      case "go":
-        frameworks = await analyzeGoProject(absolutePath, files);
-        break;
-      case "rust":
-        frameworks = await analyzeRustProject(absolutePath, files);
-        break;
-    }
-  }
-  const packageManager = detectPackageManager(files);
-  const buildSystem = detectBuildSystem(files, frameworks);
-  const configFiles = detectConfigFiles(files);
-  const importantDirs = detectImportantDirs(absolutePath);
-  const analysis = {
-    rootPath: absolutePath,
-    projectType: determineProjectType(languages, frameworks),
-    languages,
-    frameworks,
-    packageManager,
-    buildSystem,
-    configFiles,
-    importantDirs,
-    metadata: {
-      timestamp: /* @__PURE__ */ new Date(),
-      duration: Date.now() - startTime,
-      filesScanned: files.length,
-      confidence: calculateOverallConfidence(languages, frameworks),
-      version: "1.0.0"
-    }
-  };
-  logger$1.info(`Detected project type: ${analysis.projectType}`);
-  return analysis;
-}
-const ROOT_CONFIG_FILES = [
-  "package.json",
-  "tsconfig.json",
-  "jsconfig.json",
-  "go.mod",
-  "Cargo.toml",
-  "pyproject.toml",
-  "requirements.txt",
-  "setup.py",
-  "Gemfile",
-  "composer.json",
-  "pom.xml",
-  "build.gradle",
-  "build.gradle.kts",
-  "pubspec.yaml",
-  "Package.swift",
-  "pom.xml"
-];
-async function scanProjectFiles(projectPath, config) {
-  const rootConfigFiles = [];
-  for (const configFile of ROOT_CONFIG_FILES) {
-    const configPath = posix.join(projectPath, configFile);
-    if (await pathExists(configPath)) {
-      rootConfigFiles.push(configFile);
-      logger$1.debug(`Found root config: ${configFile}`);
-    }
-  }
-  const patterns = ["**/*"];
-  const ignore = config.excludePatterns;
-  if (!config.includeNodeModules) {
-    ignore.push("node_modules/**");
-  }
-  const allFiles = await glob(patterns, {
-    cwd: projectPath,
-    ignore,
-    absolute: false
-  });
-  const fileSet = /* @__PURE__ */ new Set([...rootConfigFiles, ...allFiles]);
-  const files = Array.from(fileSet);
-  if (files.length > config.maxFilesToScan) {
-    logger$1.warn(`Too many files (${files.length}), limiting to ${config.maxFilesToScan}`);
-    const rootConfigs = files.filter((f) => ROOT_CONFIG_FILES.includes(f));
-    const otherFiles = files.filter((f) => !ROOT_CONFIG_FILES.includes(f));
-    const limitedOthers = otherFiles.slice(0, config.maxFilesToScan - rootConfigs.length);
-    return [...rootConfigs, ...limitedOthers];
-  }
-  return files;
-}
-async function detectLanguages(projectPath, files, config) {
-  const languageCounts = /* @__PURE__ */ new Map();
-  const languageIndicators = /* @__PURE__ */ new Map();
-  for (const file of files) {
-    const ext = posix.extname(file).toLowerCase();
-    for (const [language, patterns] of Object.entries(LANGUAGE_PATTERNS)) {
-      const extensions = patterns.extensions;
-      if (extensions.includes(ext)) {
-        languageCounts.set(language, (languageCounts.get(language) || 0) + 1);
-      }
-    }
-  }
-  const fileSet = new Set(files);
-  for (const [language, patterns] of Object.entries(LANGUAGE_PATTERNS)) {
-    const indicators = [];
-    for (const file of patterns.files) {
-      if (fileSet.has(file) || fileSet.has(file.toLowerCase())) {
-        indicators.push(`Found ${file}`);
-        languageCounts.set(language, (languageCounts.get(language) || 0) + 10);
-      }
-    }
-    for (const indicator of patterns.indicators) {
-      if (fileSet.has(indicator) || await pathExists(posix.join(projectPath, indicator))) {
-        indicators.push(`Found ${indicator}`);
-        languageCounts.set(language, (languageCounts.get(language) || 0) + 5);
-      }
-    }
-    if (indicators.length > 0) {
-      languageIndicators.set(language, new Set(indicators));
-    }
-  }
-  const totalFiles = files.length;
-  const languages = [];
-  for (const [language, count] of Array.from(languageCounts.entries())) {
-    const confidence = Math.min(count / totalFiles, 1);
-    if (confidence >= config.minConfidence) {
-      languages.push({
-        language,
-        confidence,
-        fileCount: count,
-        indicators: Array.from(languageIndicators.get(language) || [])
-      });
-    }
-  }
-  return languages;
-}
-function detectPackageManager(files) {
-  const managers = {
-    "pnpm-lock.yaml": "pnpm",
-    "yarn.lock": "yarn",
-    "package-lock.json": "npm",
-    "bun.lockb": "bun",
-    "requirements.txt": "pip",
-    "Pipfile": "pipenv",
-    "pyproject.toml": "poetry",
-    "go.mod": "go",
-    "Cargo.toml": "cargo",
-    "pom.xml": "maven",
-    "build.gradle": "gradle"
-  };
-  for (const [file, manager] of Object.entries(managers)) {
-    if (files.includes(file)) {
-      return manager;
-    }
-  }
-  return void 0;
-}
-function detectBuildSystem(files, frameworks) {
-  for (const framework of frameworks) {
-    if (framework.name.includes("next"))
-      return "next";
-    if (framework.name.includes("nuxt"))
-      return "nuxt";
-    if (framework.name.includes("sveltekit"))
-      return "svelte";
-    if (framework.name.includes("astro"))
-      return "unknown";
-  }
-  const buildFiles = {
-    "webpack.config.js": "webpack",
-    "webpack.config.ts": "webpack",
-    "vite.config.ts": "vite",
-    "vite.config.js": "vite",
-    "rollup.config.js": "rollup",
-    "rollup.config.ts": "rollup",
-    "esbuild.config.js": "esbuild",
-    "tsconfig.json": "tsc",
-    ".babelrc": "babel",
-    "babel.config.js": "babel",
-    ".swcrc": "swc",
-    "Makefile": "make",
-    "CMakeLists.txt": "cmake",
-    "BUILD": "bazel"
-  };
-  for (const [file, system] of Object.entries(buildFiles)) {
-    if (files.includes(file)) {
-      return system;
-    }
-  }
-  return void 0;
-}
-function detectConfigFiles(files) {
-  const configPatterns = [
-    "package.json",
-    "tsconfig.json",
-    "jsconfig.json",
-    "pyproject.toml",
-    "requirements.txt",
-    "setup.py",
-    "go.mod",
-    "Cargo.toml",
-    "pom.xml",
-    "build.gradle",
-    "build.gradle.kts",
-    "composer.json",
-    "Gemfile",
-    "pubspec.yaml",
-    "docker-compose.yml",
-    "docker-compose.yaml",
-    "Dockerfile",
-    ".env",
-    ".env.example",
-    ".gitignore",
-    ".dockerignore",
-    "README.md",
-    "readme.md",
-    "README.rst",
-    "readme.rst"
-  ];
-  return files.filter((file) => configPatterns.includes(file));
-}
-function detectImportantDirs(projectPath) {
-  const importantDirs = [
-    "src",
-    "lib",
-    "app",
-    "public",
-    "static",
-    "assets",
-    "components",
-    "pages",
-    "views",
-    "templates",
-    "styles",
-    "css",
-    "scss",
-    "sass",
-    "less",
-    "tests",
-    "test",
-    "spec",
-    "__tests__",
-    "docs",
-    "doc",
-    "examples",
-    "samples",
-    "scripts",
-    "bin",
-    "tools",
-    "config",
-    "configs",
-    "build",
-    "dist",
-    "out",
-    "target",
-    ".github",
-    ".vscode",
-    ".idea"
-  ];
-  const foundDirs = [];
-  for (const dir of importantDirs) {
-    if (existsSync(posix.join(projectPath, dir))) {
-      foundDirs.push(dir);
-    }
-  }
-  return foundDirs;
-}
-function determineProjectType(languages, frameworks) {
-  if (languages.length === 0) {
-    return "unknown";
-  }
-  const sortedFrameworks = [...frameworks].sort((a, b) => {
-    const priorityA = FRAMEWORK_PRIORITY[a.name.toLowerCase()] || 0;
-    const priorityB = FRAMEWORK_PRIORITY[b.name.toLowerCase()] || 0;
-    return priorityB - priorityA;
-  });
-  if (sortedFrameworks.length > 0 && sortedFrameworks[0].confidence > 0.7) {
-    return sortedFrameworks[0].name;
-  }
-  return languages[0].language;
-}
-function calculateOverallConfidence(languages, frameworks) {
-  if (languages.length === 0)
-    return 0;
-  const langConfidence = languages.reduce((sum, lang) => sum + lang.confidence, 0) / languages.length;
-  let frameworkConfidence = 0;
-  if (frameworks.length > 0) {
-    frameworkConfidence = frameworks.reduce((sum, fw) => sum + fw.confidence, 0) / frameworks.length;
-  }
-  return frameworkConfidence > 0 ? langConfidence * 0.7 + frameworkConfidence * 0.3 : langConfidence;
-}
-
-class ProjectAnalyzer {
-  config = {};
-  constructor(config = {}) {
-    this.config = config;
-  }
-  /**
-   * Analyze a project directory
-   */
-  async analyze(projectPath) {
-    return analyzeProject(projectPath, this.config);
-  }
-  /**
-   * Get project type only
-   */
-  async getProjectType(projectPath) {
-    return detectProjectType(projectPath);
-  }
-}
-const logger = consola.withTag("analyzer");
-const DEFAULT_CONFIG = {
-  minConfidence: 0.5,
-  includeNodeModules: false,
-  analyzeTransitiveDeps: true,
-  maxFilesToScan: 1e4,
-  includePatterns: [],
-  excludePatterns: [
-    "node_modules",
-    ".git",
-    "dist",
-    "build",
-    "coverage",
-    ".vscode",
-    ".idea",
-    "*.log",
-    "*.tmp",
-    ".DS_Store",
-    "Thumbs.db"
-  ]
-};
-async function analyzeProject(projectPath, config = {}) {
-  const startTime = Date.now();
-  logger.info(`Analyzing project at: ${projectPath}`);
-  const mergedConfig = {
-    ...DEFAULT_CONFIG,
-    ...config
-  };
-  try {
-    const analysis = await detectProject(projectPath, mergedConfig);
-    if (mergedConfig.analyzeTransitiveDeps && analysis.dependencies) {
-      analysis.dependencies = await analyzeDependencies$1(analysis, mergedConfig);
-    }
-    analysis.metadata.duration = Date.now() - startTime;
-    logger.success(`Project analysis completed in ${analysis.metadata.duration}ms`);
-    logger.info(`Detected: ${analysis.projectType} (${analysis.metadata.confidence * 100}% confidence)`);
-    return analysis;
-  } catch (error) {
-    logger.error("Project analysis failed:", error);
-    throw new Error(`Failed to analyze project at ${projectPath}: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-async function detectProjectType(projectPath) {
-  const analysis = await analyzeProject(projectPath, {
-    analyzeTransitiveDeps: false
-  });
-  return analysis.projectType;
-}
-
-export { ProjectAnalyzer as P, analyzeProject as a };