komodo-cli 2.1.1 → 2.3.0

package/dist/{chunk-VHGNG7AW.js → chunk-G2KKBIAH.js}

@@ -35,9 +35,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // ../core/dist/index.js
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 import { mkdir as mkdir3 } from "fs/promises";
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { resolve } from "path";
 import { execSync } from "child_process";
 import os from "os";
@@ -52,6 +52,11 @@ import { randomUUID } from "crypto";
 import { mkdir as mkdir2, writeFile as writeFile3, readFile as readFile3 } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
 import { join as join3 } from "path";
+import { execa as execa3 } from "execa";
+import { existsSync as existsSync3 } from "fs";
+import { readFile as readFile4 } from "fs/promises";
+import { join as join4 } from "path";
+import { randomUUID as randomUUID2 } from "crypto";
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/external.js
 var external_exports = {};
@@ -4095,10 +4100,12 @@ var coerce = {
 var NEVER = INVALID;
 
 // ../core/dist/index.js
-import { execa as execa3 } from "execa";
-import { existsSync as existsSync4 } from "fs";
-import { readFile as readFile4 } from "fs/promises";
-import { join as join5 } from "path";
+import { execa as execa4 } from "execa";
+import { existsSync as existsSync5 } from "fs";
+import { join as join6 } from "path";
+import { randomUUID as randomUUID4 } from "crypto";
+import { execa as execa5 } from "execa";
+import { execa as execa6 } from "execa";
 function detectOs() {
   const platform = os.platform();
   if (platform === "darwin") return "darwin";
@@ -4938,6 +4945,16 @@ async function listSnapshots(basePath, environmentId) {
   }
   return state.snapshots;
 }
+async function getLatestSnapshot(basePath, environmentId) {
+  const snapshots = await listSnapshots(basePath, environmentId);
+  if (snapshots.length === 0) {
+    return void 0;
+  }
+  snapshots.sort(
+    (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+  );
+  return snapshots[0];
+}
 var DEFAULT_MODEL = "llama-3.3-70b";
 var DEFAULT_MAX_TOKENS = 2048;
 var DEFAULT_TEMPERATURE = 0.2;
@@ -5320,6 +5337,450 @@ Only include the JSON block if you're recommending specific package changes.`;
     return result;
   }
 };
+var KNOWN_CONFLICTS = [
+  {
+    packages: ["tensorflow", "torch"],
+    reason: "Both use significant GPU memory and may conflict",
+    suggestion: "Use separate environments for TensorFlow and PyTorch projects"
+  },
+  {
+    packages: ["numpy", "jax"],
+    reason: "JAX includes its own numpy-like API that may conflict",
+    suggestion: "Use jax.numpy instead of importing both"
+  },
+  {
+    packages: ["PIL", "pillow"],
+    reason: "PIL and Pillow are the same library, cannot coexist",
+    suggestion: "Remove PIL and use Pillow instead"
+  },
+  {
+    packages: ["opencv-python", "opencv-contrib-python"],
+    reason: "These packages overlap and can cause import conflicts",
+    suggestion: "Use opencv-contrib-python only (includes all opencv-python features)"
+  },
+  {
+    packages: ["tensorflow", "tensorflow-gpu"],
+    reason: "TensorFlow 2.x already includes GPU support",
+    suggestion: "Remove tensorflow-gpu and use tensorflow only"
+  },
+  {
+    packages: ["requests", "urllib3"],
+    reason: "Requests includes urllib3, may cause version conflicts",
+    suggestion: "Let requests manage its own urllib3 dependency"
+  },
+  {
+    packages: ["pandas", "numpy"],
+    reason: "Version mismatch between pandas and numpy can cause errors",
+    suggestion: "Ensure compatible versions or let pandas manage numpy version"
+  },
+  {
+    packages: ["jupyter", "ipython"],
+    reason: "Conflicting IPython versions",
+    suggestion: "Use jupyter only, which includes IPython"
+  },
+  {
+    packages: ["scikit-learn", "sklearn"],
+    reason: "sklearn is deprecated, scikit-learn is the correct package",
+    suggestion: "Remove sklearn and use scikit-learn only"
+  },
+  {
+    packages: ["pyyaml", "yaml"],
+    reason: "Different YAML parsers can conflict",
+    suggestion: "Use pyyaml only"
+  },
+  // Node.js conflicts
+  {
+    packages: ["moment", "dayjs"],
+    reason: "Both date libraries serve same purpose, adds bundle bloat",
+    suggestion: "Choose one date library (dayjs is lighter)"
+  },
+  {
+    packages: ["axios", "node-fetch"],
+    reason: "Both HTTP clients serve same purpose",
+    suggestion: "Choose one HTTP client"
+  },
+  {
+    packages: ["lodash", "underscore"],
+    reason: "Both utility libraries serve same purpose",
+    suggestion: "Choose one utility library (lodash is more feature-complete)"
+  },
+  {
+    packages: ["express", "koa"],
+    reason: "Both web frameworks, cannot be used together",
+    suggestion: "Choose one web framework"
+  },
+  {
+    packages: ["react", "vue"],
+    reason: "Cannot use multiple frontend frameworks simultaneously",
+    suggestion: "Choose one frontend framework"
+  },
+  {
+    packages: ["webpack", "vite"],
+    reason: "Both bundlers serve same purpose",
+    suggestion: "Choose one bundler (vite is faster for development)"
+  },
+  {
+    packages: ["eslint", "tslint"],
+    reason: "TSLint is deprecated in favor of ESLint",
+    suggestion: "Remove tslint and use eslint with @typescript-eslint"
+  },
+  {
+    packages: ["node-sass", "sass"],
+    reason: "node-sass is deprecated, sass is the new implementation",
+    suggestion: "Remove node-sass and use sass (dart-sass)"
+  }
+];
+async function getInstalledPackages(path, runtime) {
+  if (runtime === "python") {
+    return getPythonPackages(path);
+  } else {
+    return getNodePackages(path);
+  }
+}
+async function getPythonPackages(path) {
+  const venvPath = join4(path, ".venv");
+  if (!existsSync3(venvPath)) {
+    return [];
+  }
+  try {
+    const pipPath = join4(venvPath, "bin", "pip");
+    const result = await execa3(pipPath, ["list", "--format=json"], { cwd: path });
+    const packages = JSON.parse(result.stdout);
+    return packages.map((pkg) => ({
+      name: pkg.name,
+      version: pkg.version
+    }));
+  } catch {
+    try {
+      const result = await execa3(
+        "uv",
+        ["pip", "list", "--format=json", "--python", join4(venvPath, "bin", "python")],
+        { cwd: path }
+      );
+      const packages = JSON.parse(result.stdout);
+      return packages.map((pkg) => ({
+        name: pkg.name,
+        version: pkg.version
+      }));
+    } catch {
+      return [];
+    }
+  }
+}
+async function getNodePackages(path) {
+  const packageJsonPath = join4(path, "package.json");
+  if (!existsSync3(packageJsonPath)) {
+    return [];
+  }
+  try {
+    const content = await readFile4(packageJsonPath, "utf-8");
+    const packageJson = JSON.parse(content);
+    const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+    const packages = [];
+    for (const [name, version] of Object.entries(deps)) {
+      packages.push({
+        name,
+        version: String(version).replace(/^[\^~]/, "")
+      });
+    }
+    return packages;
+  } catch {
+    return [];
+  }
+}
+function detectConflicts(packages) {
+  const conflicts = [];
+  const packageNames = packages.map((p) => p.name.toLowerCase());
+  for (const known of KNOWN_CONFLICTS) {
+    const [pkg1, pkg2] = known.packages;
+    if (packageNames.includes(pkg1) && packageNames.includes(pkg2)) {
+      conflicts.push({
+        package1: pkg1,
+        package2: pkg2,
+        reason: known.reason,
+        severity: "warning",
+        suggestion: known.suggestion
+      });
+    }
+  }
+  return conflicts;
+}
+function analyzeHealth(packages, conflicts) {
+  const issues = [];
+  let score = 100;
+  for (const conflict of conflicts) {
+    issues.push({
+      type: "conflict",
+      severity: conflict.severity,
+      title: `${conflict.package1} and ${conflict.package2} may conflict`,
+      description: conflict.reason,
+      fix: conflict.suggestion,
+      autoFixable: false
+    });
+    score -= conflict.severity === "error" ? 20 : 10;
+  }
+  const commonOutdated = ["requests", "axios", "lodash"];
+  for (const pkg of packages) {
+    if (commonOutdated.includes(pkg.name.toLowerCase())) {
+    }
+  }
+  return {
+    healthy: issues.filter((i) => i.severity === "error").length === 0,
+    issues,
+    score: Math.max(0, score)
+  };
+}
+async function detectRealConflicts(path, runtime) {
+  const conflicts = [];
+  if (runtime === "python") {
+    const venvPath = join4(path, ".venv");
+    if (!existsSync3(venvPath)) {
+      return conflicts;
+    }
+    try {
+      const pipPath = join4(venvPath, "bin", "pip");
+      const result = await execa3(pipPath, ["check"], { cwd: path, reject: false });
+      if (result.exitCode !== 0 && result.stdout) {
+        const lines = result.stdout.split("\n");
+        for (const line of lines) {
+          const match = line.match(/(\S+)\s+[\d.]+\s+requires\s+(\S+)\s*([>=<]+[\d.]+)?.*but.*you.*have\s+(\S+)\s+([\d.]+)/);
+          if (match) {
+            const [, pkg1, pkg2, requiredVersion, , actualVersion] = match;
+            if (pkg1 && pkg2) {
+              conflicts.push({
+                package1: pkg1,
+                package2: pkg2,
+                reason: `${pkg1} requires ${pkg2}${requiredVersion || ""}, but ${actualVersion || "unknown version"} is installed`,
+                severity: "error",
+                suggestion: `Upgrade ${pkg2} to meet ${pkg1}'s requirements`
+              });
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  } else {
+    try {
+      const result = await execa3("npm", ["ls", "--json"], {
+        cwd: path,
+        reject: false
+      });
+      if (result.stdout) {
+        try {
+          const output = JSON.parse(result.stdout);
+          if (output.problems && Array.isArray(output.problems)) {
+            for (const problem of output.problems) {
+              const problemStr = String(problem);
+              const match = problemStr.match(/(\S+)@[\d.]+\s+requires\s+(\S+)@([^\s]+)/);
+              if (match) {
+                const [, pkg1, pkg2, version] = match;
+                if (pkg1 && pkg2) {
+                  conflicts.push({
+                    package1: pkg1,
+                    package2: pkg2,
+                    reason: `${pkg1} requires ${pkg2}@${version || "unknown"}`,
+                    severity: "warning",
+                    suggestion: `Install compatible version of ${pkg2}`
+                  });
+                }
+              } else {
+                conflicts.push({
+                  package1: "unknown",
+                  package2: "unknown",
+                  reason: problemStr,
+                  severity: "warning"
+                });
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  return conflicts;
+}
+async function checkPreInstallConflicts(path, runtime, newPackages) {
+  const conflicts = [];
+  const suggestions = [];
+  const installed = await getInstalledPackages(path, runtime);
+  const installedNames = installed.map((p) => p.name.toLowerCase());
+  for (const newPkg of newPackages) {
+    for (const known of KNOWN_CONFLICTS) {
+      const [pkg1, pkg2] = known.packages;
+      const newPkgName = newPkg.name.toLowerCase();
+      if (newPkgName === pkg1 && installedNames.includes(pkg2)) {
+        conflicts.push({
+          package1: pkg1,
+          package2: pkg2,
+          reason: known.reason,
+          severity: "warning",
+          suggestion: known.suggestion
+        });
+      } else if (newPkgName === pkg2 && installedNames.includes(pkg1)) {
+        conflicts.push({
+          package1: pkg1,
+          package2: pkg2,
+          reason: known.reason,
+          severity: "warning",
+          suggestion: known.suggestion
+        });
+      }
+    }
+  }
+  const newPackageNames = newPackages.map((p) => p.name.toLowerCase());
+  for (const known of KNOWN_CONFLICTS) {
+    const [pkg1, pkg2] = known.packages;
+    if (newPackageNames.includes(pkg1) && newPackageNames.includes(pkg2)) {
+      conflicts.push({
+        package1: pkg1,
+        package2: pkg2,
+        reason: known.reason,
+        severity: "warning",
+        suggestion: known.suggestion
+      });
+    }
+  }
+  if (runtime === "python") {
+    const venvPath = join4(path, ".venv");
+    if (existsSync3(venvPath)) {
+      try {
+        const pipPath = join4(venvPath, "bin", "pip");
+        const packageSpecs = newPackages.map(
+          (p) => p.version ? `${p.name}==${p.version}` : p.name
+        );
+        const result = await execa3(
+          pipPath,
+          ["install", "--dry-run", ...packageSpecs],
+          { cwd: path, reject: false }
+        );
+        if (result.exitCode !== 0 && result.stderr) {
+          if (result.stderr.includes("ResolutionImpossible") || result.stderr.includes("incompatible")) {
+            conflicts.push({
+              package1: "new packages",
+              package2: "existing packages",
+              reason: "Package versions are incompatible",
+              severity: "error",
+              suggestion: "Review package version requirements"
+            });
+          }
+        }
+      } catch {
+      }
+    }
+  } else {
+    try {
+      const packageSpecs = newPackages.map(
+        (p) => p.version ? `${p.name}@${p.version}` : p.name
+      );
+      const result = await execa3(
+        "npm",
+        ["install", "--dry-run", ...packageSpecs],
+        { cwd: path, reject: false }
+      );
+      if (result.exitCode !== 0 && result.stderr) {
+        if (result.stderr.includes("ERESOLVE") || result.stderr.includes("conflict")) {
+          conflicts.push({
+            package1: "new packages",
+            package2: "existing packages",
+            reason: "Dependency resolution conflict",
+            severity: "error",
+            suggestion: "Review peer dependencies"
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  for (const conflict of conflicts) {
+    if (conflict.package1 !== "unknown" && conflict.package2 !== "unknown") {
+      suggestions.push({
+        conflictId: randomUUID2(),
+        strategy: "separate-env",
+        packages: [],
+        description: `Create separate environment for ${conflict.package1} and ${conflict.package2}`,
+        friendlyDescription: "Use different projects for these packages",
+        automated: false,
+        risk: "safe"
+      });
+    }
+  }
+  return {
+    willConflict: conflicts.length > 0,
+    conflicts,
+    suggestions
+  };
+}
+async function resolveConflicts(path, runtime, conflicts, onProgress) {
+  const resolved = [];
+  const remaining = [];
+  onProgress?.("Analyzing conflicts...");
+  for (const conflict of conflicts) {
+    if (conflict.package1 === "PIL" && conflict.package2 === "pillow") {
+      onProgress?.("Removing deprecated PIL package...");
+      try {
+        if (runtime === "python") {
+          const pipPath = join4(path, ".venv", "bin", "pip");
+          await execa3(pipPath, ["uninstall", "-y", "PIL"], { cwd: path });
+          resolved.push(`Removed ${conflict.package1}`);
+        }
+      } catch {
+        remaining.push(conflict);
+      }
+    } else if (conflict.package1 === "tensorflow" && conflict.package2 === "tensorflow-gpu") {
+      onProgress?.("Removing deprecated tensorflow-gpu...");
+      try {
+        if (runtime === "python") {
+          const pipPath = join4(path, ".venv", "bin", "pip");
+          await execa3(pipPath, ["uninstall", "-y", "tensorflow-gpu"], { cwd: path });
+          resolved.push(`Removed ${conflict.package2}`);
+        }
+      } catch {
+        remaining.push(conflict);
+      }
+    } else if (conflict.package1 === "sklearn" && conflict.package2 === "scikit-learn") {
+      onProgress?.("Removing deprecated sklearn...");
+      try {
+        if (runtime === "python") {
+          const pipPath = join4(path, ".venv", "bin", "pip");
+          await execa3(pipPath, ["uninstall", "-y", "sklearn"], { cwd: path });
+          resolved.push(`Removed ${conflict.package1}`);
+        }
+      } catch {
+        remaining.push(conflict);
+      }
+    } else if (conflict.package1 === "tslint" && conflict.package2 === "eslint") {
+      onProgress?.("Removing deprecated tslint...");
+      try {
+        if (runtime === "node") {
+          await execa3("npm", ["uninstall", "tslint"], { cwd: path });
+          resolved.push(`Removed ${conflict.package1}`);
+        }
+      } catch {
+        remaining.push(conflict);
+      }
+    } else if (conflict.package1 === "node-sass" && conflict.package2 === "sass") {
+      onProgress?.("Removing deprecated node-sass...");
+      try {
+        if (runtime === "node") {
+          await execa3("npm", ["uninstall", "node-sass"], { cwd: path });
+          resolved.push(`Removed ${conflict.package1}`);
+        }
+      } catch {
+        remaining.push(conflict);
+      }
+    } else {
+      remaining.push(conflict);
+    }
+  }
+  return {
+    success: remaining.length === 0,
+    resolved,
+    remaining
+  };
+}
 var Komodo = class {
   hardware;
   ai = null;
@@ -5417,18 +5878,43 @@ var Komodo = class {
         aiAnalysis
       };
     }
-    if (dryRun) {
-      return {
-        success: true,
-        resolution,
-        hardware: this.hardware,
-        aiAnalysis
-      };
+    if (resolution.packages.length > 0 && existsSync4(targetPath)) {
+      onProgress?.("Checking for potential conflicts...");
+      try {
+        const preCheck = await checkPreInstallConflicts(
+          targetPath,
+          resolution.runtime,
+          resolution.packages
+        );
+        if (preCheck.willConflict) {
+          for (const conflict of preCheck.conflicts) {
+            const warningMsg = `Warning: ${conflict.package1} and ${conflict.package2} may conflict - ${conflict.reason}`;
+            onWarning?.(warningMsg);
+            resolution.warnings.push(warningMsg);
+          }
+          const criticalConflicts = preCheck.conflicts.filter((c) => c.severity === "error");
+          if (criticalConflicts.length > 0) {
+            resolution.explanations.push(
+              `Found ${criticalConflicts.length} potential conflict(s). Installation may fail or cause issues.`
+            );
+          }
+        }
+      } catch (error) {
+        onWarning?.("Could not check for conflicts, proceeding anyway");
+      }
+    }
+    if (dryRun) {
+      return {
+        success: true,
+        resolution,
+        hardware: this.hardware,
+        aiAnalysis
+      };
     }
-    if (!existsSync3(targetPath)) {
+    if (!existsSync4(targetPath)) {
       await mkdir3(targetPath, { recursive: true });
     }
-    const environmentId = randomUUID2();
+    const environmentId = randomUUID3();
     const environmentName = aiAnalysis?.goal ?? intent.slice(0, 50);
     const environment = {
       id: environmentId,
@@ -5591,127 +6077,2618 @@ var GpuTypeSchema = external_exports.enum(["nvidia", "amd", "apple-silicon", "in
 var OsSchema = external_exports.enum(["darwin", "linux", "windows"]);
 var ArchSchema = external_exports.enum(["x64", "arm64"]);
 var RuntimeSchema = external_exports.enum(["python", "node"]);
-var KNOWN_CONFLICTS = [
-  {
-    packages: ["tensorflow", "torch"],
-    reason: "Both use significant GPU memory and may conflict",
-    suggestion: "Use separate environments for TensorFlow and PyTorch projects"
-  },
-  {
-    packages: ["numpy", "jax"],
-    reason: "JAX includes its own numpy-like API that may conflict",
-    suggestion: "Use jax.numpy instead of importing both"
-  }
+var KNOWN_VULNERABILITIES = {
+  "torch": [
+    { versions: "<1.13.0", severity: "high", description: "Arbitrary code execution via pickle deserialization", fix: ">=2.0.0" }
+  ],
+  "numpy": [
+    { versions: "<1.22.0", severity: "medium", description: "Buffer overflow in array operations", fix: ">=1.22.0" }
+  ],
+  "pillow": [
+    { versions: "<9.0.0", severity: "high", description: "Multiple image parsing vulnerabilities", fix: ">=10.0.0" }
+  ],
+  "requests": [
+    { versions: "<2.31.0", severity: "medium", description: "Potential credential leak in redirects", fix: ">=2.31.0" }
+  ],
+  "urllib3": [
+    { versions: "<2.0.0", severity: "medium", description: "Cookie handling vulnerability", fix: ">=2.0.0" }
+  ],
+  "django": [
+    { versions: "<4.2.0", severity: "high", description: "SQL injection and XSS vulnerabilities", fix: ">=4.2.0" }
+  ],
+  "flask": [
+    { versions: "<2.3.0", severity: "medium", description: "Security header improvements needed", fix: ">=2.3.0" }
+  ],
+  "lodash": [
+    { versions: "<4.17.21", severity: "high", description: "Prototype pollution vulnerability", fix: ">=4.17.21" }
+  ],
+  "axios": [
+    { versions: "<1.6.0", severity: "medium", description: "SSRF vulnerability", fix: ">=1.6.0" }
+  ],
+  "express": [
+    { versions: "<4.19.0", severity: "medium", description: "Open redirect vulnerability", fix: ">=4.19.0" }
+  ]
+};
+var HEAVY_PACKAGES = {
+  "moment": { alternative: "dayjs", savingsMb: 280, note: "dayjs is 2KB vs moment's 300KB, same API" },
+  "lodash": { alternative: "lodash-es or native", savingsMb: 70, note: "Use lodash-es for tree-shaking or native JS methods" },
+  "jquery": { alternative: "native DOM APIs", savingsMb: 85, note: "Modern browsers don't need jQuery" },
+  "underscore": { alternative: "lodash-es or native", savingsMb: 20, note: "lodash is a superset with better performance" },
+  "request": { alternative: "axios or fetch", savingsMb: 50, note: "request is deprecated, use axios or native fetch" },
+  "bluebird": { alternative: "native Promises", savingsMb: 80, note: "Native Promises are now performant enough" }
+};
+var CONFLICT_PAIRS = [
+  ["tensorflow", "torch", "Both are heavy ML frameworks - pick one unless you need both"],
+  ["tensorflow-gpu", "tensorflow", "Use tensorflow>=2.0 which includes GPU support"],
+  ["opencv-python", "opencv-python-headless", "Use headless version for servers"],
+  ["pillow", "PIL", "PIL is deprecated, Pillow is the maintained fork"]
 ];
-async function getInstalledPackages(path, runtime) {
-  if (runtime === "python") {
-    return getPythonPackages(path);
-  } else {
-    return getNodePackages(path);
+function compareVersions(v1, v2) {
+  const parts1 = v1.replace(/[^0-9.]/g, "").split(".").map(Number);
+  const parts2 = v2.replace(/[^0-9.]/g, "").split(".").map(Number);
+  for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+    const p1 = parts1[i] || 0;
+    const p2 = parts2[i] || 0;
+    if (p1 < p2) return -1;
+    if (p1 > p2) return 1;
+  }
+  return 0;
+}
+function checkVersionConstraint(version, constraint) {
+  const cleanVersion = version.replace(/[^0-9.]/g, "");
+  if (constraint.startsWith("<")) {
+    const targetVersion = constraint.slice(1);
+    return compareVersions(cleanVersion, targetVersion) < 0;
+  }
+  if (constraint.startsWith(">=")) {
+    const targetVersion = constraint.slice(2);
+    return compareVersions(cleanVersion, targetVersion) >= 0;
+  }
+  if (constraint.startsWith("<=")) {
+    const targetVersion = constraint.slice(2);
+    return compareVersions(cleanVersion, targetVersion) <= 0;
+  }
+  if (constraint.startsWith(">")) {
+    const targetVersion = constraint.slice(1);
+    return compareVersions(cleanVersion, targetVersion) > 0;
   }
+  return false;
 }
-async function getPythonPackages(path) {
-  const venvPath = join5(path, ".venv");
-  if (!existsSync4(venvPath)) {
-    return [];
+function runDoctor(packages, hardware, options = {}) {
+  const {
+    checkSecurity = true,
+    checkPerformance = true,
+    checkOutdated = true,
+    checkUnused = true
+  } = options;
+  const issues = [];
+  let vulnerabilityCount = 0;
+  let outdatedCount = 0;
+  let unusedCount = 0;
+  if (checkSecurity) {
+    for (const pkg of packages) {
+      const vulns = KNOWN_VULNERABILITIES[pkg.name.toLowerCase()];
+      if (vulns) {
+        for (const vuln of vulns) {
+          if (checkVersionConstraint(pkg.version, vuln.versions)) {
+            vulnerabilityCount++;
+            issues.push({
+              id: `vuln-${pkg.name}-${vuln.severity}`,
+              severity: vuln.severity === "high" ? "critical" : "warning",
+              category: "security",
+              title: `Security vulnerability in ${pkg.name}`,
+              description: vuln.description,
+              package: pkg.name,
+              fix: {
+                type: "upgrade",
+                packages: [`${pkg.name}${vuln.fix}`],
+                description: `Upgrade to ${pkg.name}${vuln.fix}`,
+                automated: true
+              },
+              learnMore: `https://security.snyk.io/package/pip/${pkg.name}`
+            });
+          }
+        }
+      }
+    }
   }
-  try {
-    const pipPath = join5(venvPath, "bin", "pip");
-    const result = await execa3(pipPath, ["list", "--format=json"], { cwd: path });
-    const packages = JSON.parse(result.stdout);
-    return packages.map((pkg) => ({
-      name: pkg.name,
-      version: pkg.version
-    }));
-  } catch {
-    try {
-      const result = await execa3(
-        "uv",
-        ["pip", "list", "--format=json", "--python", join5(venvPath, "bin", "python")],
-        { cwd: path }
+  if (checkPerformance) {
+    for (const pkg of packages) {
+      const heavy = HEAVY_PACKAGES[pkg.name.toLowerCase()];
+      if (heavy) {
+        issues.push({
+          id: `perf-${pkg.name}`,
+          severity: "suggestion",
+          category: "performance",
+          title: `${pkg.name} has a lighter alternative`,
+          description: heavy.note,
+          package: pkg.name,
+          fix: {
+            type: "install",
+            packages: [heavy.alternative.split(" ")[0] || heavy.alternative],
+            description: `Consider replacing with ${heavy.alternative} (saves ~${heavy.savingsMb}KB)`,
+            automated: false
+          }
+        });
+      }
+    }
+    const packageNames = packages.map((p) => p.name.toLowerCase());
+    for (const [pkg1, pkg2, reason] of CONFLICT_PAIRS) {
+      if (packageNames.includes(pkg1) && packageNames.includes(pkg2)) {
+        issues.push({
+          id: `dup-${pkg1}-${pkg2}`,
+          severity: "warning",
+          category: "performance",
+          title: `Potentially redundant packages: ${pkg1} + ${pkg2}`,
+          description: reason,
+          fix: {
+            type: "uninstall",
+            description: `Consider removing one of these packages`,
+            automated: false
+          }
+        });
+      }
+    }
+    if (hardware.gpu === "none") {
+      const gpuPackages = packages.filter(
+        (p) => p.name.toLowerCase().includes("cuda") || p.name.toLowerCase().includes("-gpu") || p.name.toLowerCase().includes("cudf")
       );
-      const packages = JSON.parse(result.stdout);
-      return packages.map((pkg) => ({
-        name: pkg.name,
-        version: pkg.version
-      }));
-    } catch {
-      return [];
+      for (const pkg of gpuPackages) {
+        issues.push({
+          id: `hw-${pkg.name}`,
+          severity: "warning",
+          category: "compatibility",
+          title: `GPU package on CPU-only system`,
+          description: `${pkg.name} requires a GPU but none was detected`,
+          package: pkg.name,
+          fix: {
+            type: "uninstall",
+            packages: [pkg.name],
+            description: `Remove ${pkg.name} or switch to CPU version`,
+            automated: true
+          }
+        });
+      }
+    }
+    if (hardware.totalMemoryGb < 8) {
+      const heavyMLPackages = packages.filter(
+        (p) => ["tensorflow", "torch", "pytorch", "transformers", "jax"].includes(p.name.toLowerCase())
+      );
+      if (heavyMLPackages.length > 0) {
+        issues.push({
+          id: "hw-memory-ml",
+          severity: "warning",
+          category: "compatibility",
+          title: "Heavy ML packages with limited RAM",
+          description: `You have ${hardware.totalMemoryGb}GB RAM but ML packages typically need 8GB+`,
+          fix: {
+            type: "config",
+            description: "Consider using cloud instances or reducing model sizes",
+            automated: false
+          }
+        });
+      }
     }
   }
-}
-async function getNodePackages(path) {
-  const packageJsonPath = join5(path, "package.json");
-  if (!existsSync4(packageJsonPath)) {
-    return [];
+  const conflicts = detectConflicts(packages);
+  for (const conflict of conflicts) {
+    issues.push({
+      id: `conflict-${conflict.package1}-${conflict.package2}`,
+      severity: conflict.severity === "error" ? "critical" : "warning",
+      category: "compatibility",
+      title: `Conflict: ${conflict.package1} and ${conflict.package2}`,
+      description: conflict.reason,
+      fix: conflict.suggestion ? {
+        type: "command",
+        command: conflict.suggestion,
+        description: conflict.suggestion,
+        automated: false
+      } : void 0
+    });
   }
-  try {
-    const content = await readFile4(packageJsonPath, "utf-8");
-    const packageJson = JSON.parse(content);
-    const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
-    const packages = [];
-    for (const [name, version] of Object.entries(deps)) {
-      packages.push({
-        name,
-        version: String(version).replace(/^[\^~]/, "")
-      });
+  if (checkOutdated) {
+    const oldVersionIndicators = ["0.", "1.0", "1.1", "1.2"];
+    for (const pkg of packages) {
+      if (oldVersionIndicators.some((v) => pkg.version.startsWith(v))) {
+        outdatedCount++;
+        issues.push({
+          id: `outdated-${pkg.name}`,
+          severity: "info",
+          category: "outdated",
+          title: `${pkg.name} may be outdated`,
+          description: `Version ${pkg.version} - consider checking for updates`,
+          package: pkg.name,
+          fix: {
+            type: "upgrade",
+            packages: [pkg.name],
+            description: `Run: pip install --upgrade ${pkg.name}`,
+            automated: true
+          }
+        });
+      }
     }
-    return packages;
-  } catch {
-    return [];
   }
+  const criticalCount = issues.filter((i) => i.severity === "critical").length;
+  const warningCount = issues.filter((i) => i.severity === "warning").length;
+  const suggestionCount = issues.filter((i) => i.severity === "suggestion" || i.severity === "info").length;
+  let score = 100;
+  score -= criticalCount * 20;
+  score -= warningCount * 10;
+  score -= suggestionCount * 2;
+  score = Math.max(0, Math.min(100, score));
+  const grade = score >= 90 ? "A" : score >= 80 ? "B" : score >= 70 ? "C" : score >= 60 ? "D" : "F";
+  const recommendations = [];
+  if (vulnerabilityCount > 0) {
+    recommendations.push(`Fix ${vulnerabilityCount} security vulnerabilities immediately`);
+  }
+  if (criticalCount > 0) {
+    recommendations.push(`Address ${criticalCount} critical issues`);
+  }
+  if (hardware.gpu !== "none" && !packages.some((p) => p.name.toLowerCase().includes("cuda"))) {
+    recommendations.push("You have a GPU - consider installing CUDA packages for acceleration");
+  }
+  if (packages.length > 50) {
+    recommendations.push("Large number of packages - consider auditing for unused dependencies");
+  }
+  return {
+    timestamp: /* @__PURE__ */ new Date(),
+    score,
+    grade,
+    issues,
+    summary: {
+      critical: criticalCount,
+      warnings: warningCount,
+      suggestions: suggestionCount,
+      packagesScanned: packages.length,
+      vulnerabilities: vulnerabilityCount,
+      outdated: outdatedCount,
+      unused: unusedCount
+    },
+    hardware,
+    recommendations
+  };
 }
-function detectConflicts(packages) {
-  const conflicts = [];
-  const packageNames = packages.map((p) => p.name.toLowerCase());
-  for (const known of KNOWN_CONFLICTS) {
-    const [pkg1, pkg2] = known.packages;
-    if (packageNames.includes(pkg1) && packageNames.includes(pkg2)) {
-      conflicts.push({
-        package1: pkg1,
-        package2: pkg2,
-        reason: known.reason,
-        severity: "warning",
-        suggestion: known.suggestion
-      });
+function formatDoctorReport(report, colorize = true) {
+  const lines = [];
+  const colors = {
+    reset: colorize ? "\x1B[0m" : "",
+    red: colorize ? "\x1B[31m" : "",
+    yellow: colorize ? "\x1B[33m" : "",
+    green: colorize ? "\x1B[32m" : "",
+    blue: colorize ? "\x1B[34m" : "",
+    cyan: colorize ? "\x1B[36m" : "",
+    bold: colorize ? "\x1B[1m" : "",
+    dim: colorize ? "\x1B[2m" : ""
+  };
+  lines.push("");
+  lines.push(`${colors.bold}Komodo Doctor Report${colors.reset}`);
+  lines.push(`${colors.dim}${report.timestamp.toLocaleString()}${colors.reset}`);
+  lines.push("");
+  const gradeColor = report.grade === "A" ? colors.green : report.grade === "B" ? colors.green : report.grade === "C" ? colors.yellow : colors.red;
+  lines.push(`${colors.bold}Health Score: ${gradeColor}${report.score}/100 (${report.grade})${colors.reset}`);
+  lines.push("");
+  lines.push(`${colors.bold}Summary${colors.reset}`);
+  lines.push(`  Packages scanned: ${report.summary.packagesScanned}`);
+  if (report.summary.critical > 0) {
+    lines.push(`  ${colors.red}Critical issues: ${report.summary.critical}${colors.reset}`);
+  }
+  if (report.summary.warnings > 0) {
+    lines.push(`  ${colors.yellow}Warnings: ${report.summary.warnings}${colors.reset}`);
+  }
+  if (report.summary.vulnerabilities > 0) {
+    lines.push(`  ${colors.red}Vulnerabilities: ${report.summary.vulnerabilities}${colors.reset}`);
+  }
+  lines.push(`  Suggestions: ${report.summary.suggestions}`);
+  lines.push("");
+  const criticalIssues = report.issues.filter((i) => i.severity === "critical");
+  const warningIssues = report.issues.filter((i) => i.severity === "warning");
+  const infoIssues = report.issues.filter((i) => i.severity === "info" || i.severity === "suggestion");
+  if (criticalIssues.length > 0) {
+    lines.push(`${colors.red}${colors.bold}Critical Issues${colors.reset}`);
+    for (const issue of criticalIssues) {
+      lines.push(`  ${colors.red}\u2716${colors.reset} ${issue.title}`);
+      lines.push(`    ${colors.dim}${issue.description}${colors.reset}`);
+      if (issue.fix) {
+        lines.push(`    ${colors.cyan}Fix: ${issue.fix.description}${colors.reset}`);
+      }
     }
+    lines.push("");
   }
-  return conflicts;
+  if (warningIssues.length > 0) {
+    lines.push(`${colors.yellow}${colors.bold}Warnings${colors.reset}`);
+    for (const issue of warningIssues) {
+      lines.push(`  ${colors.yellow}\u26A0${colors.reset} ${issue.title}`);
+      lines.push(`    ${colors.dim}${issue.description}${colors.reset}`);
+      if (issue.fix) {
+        lines.push(`    ${colors.cyan}Fix: ${issue.fix.description}${colors.reset}`);
+      }
+    }
+    lines.push("");
+  }
+  if (infoIssues.length > 0) {
+    lines.push(`${colors.blue}${colors.bold}Suggestions${colors.reset}`);
+    for (const issue of infoIssues.slice(0, 5)) {
+      lines.push(`  ${colors.blue}\u2139${colors.reset} ${issue.title}`);
+      if (issue.fix) {
+        lines.push(`    ${colors.dim}${issue.fix.description}${colors.reset}`);
+      }
+    }
+    if (infoIssues.length > 5) {
+      lines.push(`  ${colors.dim}...and ${infoIssues.length - 5} more suggestions${colors.reset}`);
+    }
+    lines.push("");
+  }
+  if (report.recommendations.length > 0) {
+    lines.push(`${colors.bold}Recommendations${colors.reset}`);
+    for (const rec of report.recommendations) {
+      lines.push(`  ${colors.green}\u2192${colors.reset} ${rec}`);
+    }
+    lines.push("");
+  }
+  lines.push(`${colors.dim}System: ${report.hardware.os} | ${report.hardware.gpuName || report.hardware.gpu} | ${report.hardware.totalMemoryGb}GB RAM${colors.reset}`);
+  return lines.join("\n");
 }
-function analyzeHealth(packages, conflicts) {
-  const issues = [];
-  let score = 100;
-  for (const conflict of conflicts) {
-    issues.push({
-      type: "conflict",
-      severity: conflict.severity,
-      title: `${conflict.package1} and ${conflict.package2} may conflict`,
-      description: conflict.reason,
-      fix: conflict.suggestion,
-      autoFixable: false
+var COMMON_DEPENDENCIES = {
+  "torch": ["numpy", "typing-extensions", "sympy", "networkx", "jinja2", "filelock"],
+  "torchvision": ["torch", "numpy", "pillow", "requests"],
+  "tensorflow": ["numpy", "protobuf", "absl-py", "grpcio", "h5py", "keras"],
+  "transformers": ["torch", "numpy", "tokenizers", "safetensors", "huggingface-hub", "regex", "requests", "tqdm"],
+  "pandas": ["numpy", "python-dateutil", "pytz", "tzdata"],
+  "numpy": [],
+  "scikit-learn": ["numpy", "scipy", "joblib", "threadpoolctl"],
+  "matplotlib": ["numpy", "pillow", "pyparsing", "cycler", "kiwisolver", "fonttools", "packaging"],
+  "requests": ["urllib3", "certifi", "charset-normalizer", "idna"],
+  "flask": ["werkzeug", "jinja2", "itsdangerous", "click", "blinker"],
+  "django": ["asgiref", "sqlparse", "tzdata"],
+  "fastapi": ["starlette", "pydantic", "typing-extensions"],
+  "react": [],
+  "next": ["react", "react-dom"],
+  "express": [],
+  "axios": [],
+  "lodash": []
+};
+function buildDependencyTree(packages) {
+  const nodes = /* @__PURE__ */ new Map();
+  const packageNames = new Set(packages.map((p) => p.name.toLowerCase()));
+  for (const pkg of packages) {
+    const name = pkg.name.toLowerCase();
+    const deps = COMMON_DEPENDENCIES[name] || [];
+    const filteredDeps = deps.filter((d) => packageNames.has(d.toLowerCase()));
+    nodes.set(name, {
+      name: pkg.name,
+      version: pkg.version,
+      depth: 0,
+      dependencies: [],
+      dependents: [],
+      size: estimatePackageSize(pkg.name)
     });
-    score -= conflict.severity === "error" ? 20 : 10;
   }
-  const commonOutdated = ["requests", "axios", "lodash"];
   for (const pkg of packages) {
-    if (commonOutdated.includes(pkg.name.toLowerCase())) {
+    const name = pkg.name.toLowerCase();
+    const node = nodes.get(name);
+    const deps = COMMON_DEPENDENCIES[name] || [];
+    for (const depName of deps) {
+      const depNode = nodes.get(depName.toLowerCase());
+      if (depNode) {
+        node.dependencies.push(depNode);
+        depNode.dependents.push(pkg.name);
+      }
+    }
+  }
+  const rootPackages = [...nodes.values()].filter((n) => n.dependents.length === 0);
+  let maxDepth = 0;
+  function setDepths(node, depth, visited) {
+    if (visited.has(node.name.toLowerCase())) return;
+    visited.add(node.name.toLowerCase());
+    node.depth = Math.max(node.depth, depth);
+    maxDepth = Math.max(maxDepth, depth);
+    for (const dep of node.dependencies) {
+      setDepths(dep, depth + 1, visited);
+    }
+  }
+  for (const root of rootPackages) {
+    setDepths(root, 0, /* @__PURE__ */ new Set());
+  }
+  const conflicts = [];
+  const depVersions = /* @__PURE__ */ new Map();
+  for (const node of nodes.values()) {
+    if (!depVersions.has(node.name)) {
+      depVersions.set(node.name, /* @__PURE__ */ new Set());
     }
+    depVersions.get(node.name).add(node.version);
   }
   return {
-    healthy: issues.filter((i) => i.severity === "error").length === 0,
-    issues,
-    score: Math.max(0, score)
+    root: rootPackages[0]?.name || "project",
+    nodes,
+    totalPackages: packages.length,
+    maxDepth,
+    conflicts
   };
 }
-
-export {
-  __require,
-  __commonJS,
-  __toESM,
-  loadState,
-  KomodoChat,
-  Komodo,
-  getInstalledPackages,
-  detectConflicts,
-  analyzeHealth
+function estimatePackageSize(name) {
+  const sizes = {
+    "torch": 85e4,
+    "tensorflow": 55e4,
+    "transformers": 45e3,
+    "numpy": 15e3,
+    "pandas": 12e3,
+    "scipy": 35e3,
+    "matplotlib": 8e3,
+    "pillow": 3e3,
+    "scikit-learn": 25e3,
+    "opencv-python": 45e3,
+    "requests": 500,
+    "flask": 800,
+    "django": 8e3,
+    "fastapi": 400,
+    "react": 150,
+    "next": 5e3,
+    "express": 200,
+    "lodash": 1500,
+    "axios": 100
+  };
+  return sizes[name.toLowerCase()] || 500;
+}
+function visualizeTree(tree, options = {}) {
+  const { maxDepth = 5, showSizes = true, colorize = true } = options;
+  const colors = {
+    reset: colorize ? "\x1B[0m" : "",
+    red: colorize ? "\x1B[31m" : "",
+    yellow: colorize ? "\x1B[33m" : "",
+    green: colorize ? "\x1B[32m" : "",
+    blue: colorize ? "\x1B[34m" : "",
+    cyan: colorize ? "\x1B[36m" : "",
+    dim: colorize ? "\x1B[2m" : "",
+    bold: colorize ? "\x1B[1m" : ""
+  };
+  const lines = [];
+  const visited = /* @__PURE__ */ new Set();
+  const roots = [...tree.nodes.values()].filter((n) => n.dependents.length === 0);
+  function formatSize(kb) {
+    if (kb >= 1e3) return `${(kb / 1e3).toFixed(1)}MB`;
+    return `${kb}KB`;
+  }
+  function drawNode(node, prefix, isLast, depth) {
+    if (depth > maxDepth) return;
+    if (visited.has(node.name.toLowerCase())) {
+      lines.push(`${prefix}${isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 "}${colors.dim}${node.name} (circular)${colors.reset}`);
+      return;
+    }
+    visited.add(node.name.toLowerCase());
+    const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    const sizeStr = showSizes && node.size ? ` ${colors.dim}(${formatSize(node.size)})${colors.reset}` : "";
+    const conflictStr = node.isConflict ? ` ${colors.red}\u26A0 conflicts with ${node.conflictWith}${colors.reset}` : "";
+    const nameColor = node.dependencies.length > 0 ? colors.cyan : colors.green;
+    lines.push(`${prefix}${connector}${nameColor}${node.name}${colors.reset}@${colors.dim}${node.version}${colors.reset}${sizeStr}${conflictStr}`);
+    const newPrefix = prefix + (isLast ? "    " : "\u2502   ");
+    const deps = node.dependencies;
+    for (let i = 0; i < deps.length; i++) {
+      const dep = deps[i];
+      if (dep) drawNode(dep, newPrefix, i === deps.length - 1, depth + 1);
+    }
+  }
+  lines.push(`${colors.bold}Dependency Tree${colors.reset}`);
+  lines.push(`${colors.dim}${tree.totalPackages} packages, max depth ${tree.maxDepth}${colors.reset}`);
+  lines.push("");
+  for (let i = 0; i < roots.length; i++) {
+    const root = roots[i];
+    if (!root) continue;
+    lines.push(`${colors.bold}${root.name}${colors.reset}@${root.version}`);
+    const deps = root.dependencies;
+    for (let j = 0; j < deps.length; j++) {
+      const dep = deps[j];
+      if (dep) drawNode(dep, "", j === deps.length - 1, 1);
+    }
+    if (i < roots.length - 1) lines.push("");
+  }
+  const orphans = [...tree.nodes.values()].filter(
+    (n) => n.dependencies.length === 0 && n.dependents.length === 0
+  );
+  if (orphans.length > 0 && orphans.length < tree.totalPackages) {
+    lines.push("");
+    lines.push(`${colors.dim}Standalone packages:${colors.reset}`);
+    for (const orphan of orphans.slice(0, 10)) {
+      lines.push(`  ${orphan.name}@${orphan.version}`);
+    }
+    if (orphans.length > 10) {
+      lines.push(`  ${colors.dim}...and ${orphans.length - 10} more${colors.reset}`);
+    }
+  }
+  const directDeps = roots.reduce((sum, r) => sum + r.dependencies.length, 0);
+  const transitiveDeps = tree.totalPackages - roots.length - directDeps;
+  const sortedBySize = [...tree.nodes.values()].filter((n) => n.size).sort((a, b) => (b.size || 0) - (a.size || 0)).slice(0, 5);
+  return {
+    ascii: lines.join("\n"),
+    json: {
+      roots: roots.map((r) => ({
+        name: r.name,
+        version: r.version,
+        dependencies: r.dependencies.map((d) => d.name)
+      })),
+      totalPackages: tree.totalPackages,
+      maxDepth: tree.maxDepth
+    },
+    stats: {
+      totalPackages: tree.totalPackages,
+      directDependencies: directDeps,
+      transitiveDependencies: Math.max(0, transitiveDeps),
+      maxDepth: tree.maxDepth,
+      largestPackages: sortedBySize.map((n) => ({ name: n.name, size: n.size || 0 }))
+    }
+  };
+}
+function compareVersions2(v1, v2) {
+  const parts1 = v1.replace(/[^0-9.]/g, "").split(".").map(Number);
+  const parts2 = v2.replace(/[^0-9.]/g, "").split(".").map(Number);
+  for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+    const p1 = parts1[i] || 0;
+    const p2 = parts2[i] || 0;
+    if (p1 < p2) return -1;
+    if (p1 > p2) return 1;
+  }
+  return 0;
+}
+function diffPackages(oldPackages, newPackages) {
+  const changes = [];
+  const riskReasons = [];
+  const oldMap = new Map(oldPackages.map((p) => [p.name.toLowerCase(), p]));
+  const newMap = new Map(newPackages.map((p) => [p.name.toLowerCase(), p]));
+  for (const [name, newPkg] of newMap) {
+    const oldPkg = oldMap.get(name);
+    if (!oldPkg) {
+      changes.push({
+        name: newPkg.name,
+        type: "added",
+        newVersion: newPkg.version
+      });
+    } else if (oldPkg.version !== newPkg.version) {
+      const cmp = compareVersions2(oldPkg.version, newPkg.version);
+      changes.push({
+        name: newPkg.name,
+        type: cmp < 0 ? "upgraded" : "downgraded",
+        oldVersion: oldPkg.version,
+        newVersion: newPkg.version
+      });
+    } else {
+      changes.push({
+        name: newPkg.name,
+        type: "unchanged",
+        oldVersion: oldPkg.version,
+        newVersion: newPkg.version
+      });
+    }
+  }
+  for (const [name, oldPkg] of oldMap) {
+    if (!newMap.has(name)) {
+      changes.push({
+        name: oldPkg.name,
+        type: "removed",
+        oldVersion: oldPkg.version
+      });
+    }
+  }
+  const summary = {
+    added: changes.filter((c) => c.type === "added").length,
+    removed: changes.filter((c) => c.type === "removed").length,
+    upgraded: changes.filter((c) => c.type === "upgraded").length,
+    downgraded: changes.filter((c) => c.type === "downgraded").length,
+    unchanged: changes.filter((c) => c.type === "unchanged").length
+  };
+  let riskLevel = "safe";
+  const criticalPackages = ["torch", "tensorflow", "numpy", "pandas", "react", "vue", "angular"];
+  const majorChanges = changes.filter((c) => {
+    if (c.type === "upgraded" || c.type === "downgraded") {
+      const oldMajor = parseInt(c.oldVersion?.split(".")[0] || "0");
+      const newMajor = parseInt(c.newVersion?.split(".")[0] || "0");
+      return oldMajor !== newMajor;
+    }
+    return false;
+  });
+  if (majorChanges.length > 0) {
+    riskLevel = "moderate";
+    for (const change of majorChanges) {
+      riskReasons.push(`Major version change: ${change.name} ${change.oldVersion} \u2192 ${change.newVersion}`);
+    }
+  }
+  const criticalChanges = changes.filter(
+    (c) => criticalPackages.includes(c.name.toLowerCase()) && (c.type === "removed" || c.type === "downgraded")
+  );
+  if (criticalChanges.length > 0) {
+    riskLevel = "risky";
+    for (const change of criticalChanges) {
+      if (change.type === "removed") {
+        riskReasons.push(`Critical package removed: ${change.name}`);
+      } else {
+        riskReasons.push(`Critical package downgraded: ${change.name} ${change.oldVersion} \u2192 ${change.newVersion}`);
+      }
+    }
+  }
+  if (summary.removed > 5) {
+    riskLevel = riskLevel === "safe" ? "moderate" : riskLevel;
+    riskReasons.push(`${summary.removed} packages removed`);
+  }
+  return {
+    from: "old",
+    to: "new",
+    timestamp: /* @__PURE__ */ new Date(),
+    changes: changes.filter((c) => c.type !== "unchanged"),
+    summary,
+    riskLevel,
+    riskReasons
+  };
+}
+function formatDiff(diff, colorize = true) {
+  const colors = {
+    reset: colorize ? "\x1B[0m" : "",
+    red: colorize ? "\x1B[31m" : "",
+    yellow: colorize ? "\x1B[33m" : "",
+    green: colorize ? "\x1B[32m" : "",
+    blue: colorize ? "\x1B[34m" : "",
+    cyan: colorize ? "\x1B[36m" : "",
+    dim: colorize ? "\x1B[2m" : "",
+    bold: colorize ? "\x1B[1m" : ""
+  };
+  const lines = [];
+  lines.push(`${colors.bold}Environment Diff${colors.reset}`);
+  lines.push(`${colors.dim}${diff.from} \u2192 ${diff.to}${colors.reset}`);
+  lines.push("");
+  const riskColor = diff.riskLevel === "safe" ? colors.green : diff.riskLevel === "moderate" ? colors.yellow : colors.red;
+  const riskIcon = diff.riskLevel === "safe" ? "\u2713" : diff.riskLevel === "moderate" ? "\u26A0" : "\u2716";
+  lines.push(`${riskColor}${riskIcon} Risk: ${diff.riskLevel.toUpperCase()}${colors.reset}`);
+  if (diff.riskReasons.length > 0) {
+    for (const reason of diff.riskReasons) {
+      lines.push(`  ${colors.dim}\u2022 ${reason}${colors.reset}`);
+    }
+  }
+  lines.push("");
+  lines.push(`${colors.bold}Summary${colors.reset}`);
+  if (diff.summary.added > 0) {
+    lines.push(`  ${colors.green}+ ${diff.summary.added} added${colors.reset}`);
+  }
+  if (diff.summary.removed > 0) {
+    lines.push(`  ${colors.red}- ${diff.summary.removed} removed${colors.reset}`);
+  }
+  if (diff.summary.upgraded > 0) {
+    lines.push(`  ${colors.cyan}\u2191 ${diff.summary.upgraded} upgraded${colors.reset}`);
+  }
+  if (diff.summary.downgraded > 0) {
+    lines.push(`  ${colors.yellow}\u2193 ${diff.summary.downgraded} downgraded${colors.reset}`);
+  }
+  lines.push(`  ${colors.dim}= ${diff.summary.unchanged} unchanged${colors.reset}`);
+  lines.push("");
+  if (diff.changes.length > 0) {
+    lines.push(`${colors.bold}Changes${colors.reset}`);
+    const added = diff.changes.filter((c) => c.type === "added");
+    const removed = diff.changes.filter((c) => c.type === "removed");
+    const upgraded = diff.changes.filter((c) => c.type === "upgraded");
+    const downgraded = diff.changes.filter((c) => c.type === "downgraded");
+    if (added.length > 0) {
+      for (const change of added) {
+        lines.push(`  ${colors.green}+ ${change.name}@${change.newVersion}${colors.reset}`);
+      }
+    }
+    if (removed.length > 0) {
+      for (const change of removed) {
+        lines.push(`  ${colors.red}- ${change.name}@${change.oldVersion}${colors.reset}`);
+      }
+    }
+    if (upgraded.length > 0) {
+      for (const change of upgraded) {
+        lines.push(`  ${colors.cyan}\u2191 ${change.name} ${change.oldVersion} \u2192 ${change.newVersion}${colors.reset}`);
+      }
+    }
+    if (downgraded.length > 0) {
+      for (const change of downgraded) {
+        lines.push(`  ${colors.yellow}\u2193 ${change.name} ${change.oldVersion} \u2192 ${change.newVersion}${colors.reset}`);
+      }
+    }
+  } else {
+    lines.push(`${colors.dim}No changes detected${colors.reset}`);
+  }
+  return lines.join("\n");
+}
+var PACKAGE_SIZES = {
+  "torch": 85e4,
+  "tensorflow": 55e4,
+  "transformers": 45e3,
+  "numpy": 15e3,
+  "pandas": 12e3,
+  "scipy": 35e3,
+  "matplotlib": 8e3,
+  "pillow": 3e3,
+  "scikit-learn": 25e3,
+  "opencv-python": 45e3,
+  "opencv-python-headless": 25e3,
+  "requests": 500,
+  "flask": 800,
+  "django": 8e3,
+  "fastapi": 400,
+  "moment": 300,
+  "dayjs": 2,
+  "lodash": 1500,
+  "lodash-es": 500,
+  "jquery": 85,
+  "axios": 100,
+  "react": 150,
+  "next": 5e3,
+  "express": 200,
+  "bluebird": 80,
+  "underscore": 20,
+  "request": 500
+};
+var ALTERNATIVES = {
+  "moment": { replacement: "dayjs", savingsPercent: 99, note: "Same API, 2KB vs 300KB" },
+  "lodash": { replacement: "lodash-es", savingsPercent: 70, note: "Tree-shakeable, or use native methods" },
+  "request": { replacement: "axios", savingsPercent: 80, note: "request is deprecated" },
+  "bluebird": { replacement: "native Promise", savingsPercent: 100, note: "Native Promises are performant now" },
+  "underscore": { replacement: "lodash-es", savingsPercent: 50, note: "lodash is more complete" },
+  "jquery": { replacement: "native DOM", savingsPercent: 100, note: "Modern browsers don't need jQuery" },
+  "opencv-python": { replacement: "opencv-python-headless", savingsPercent: 45, note: "For servers without display" }
+};
+var DUPLICATE_GROUPS = [
+  ["moment", "dayjs", "date-fns", "luxon"],
+  ["lodash", "underscore", "ramda"],
+  ["axios", "got", "node-fetch", "request", "superagent"],
+  ["express", "koa", "fastify", "hapi"],
+  ["tensorflow", "torch", "jax"],
+  ["pytest", "nose", "unittest2"],
+  ["opencv-python", "opencv-python-headless", "opencv-contrib-python"]
+];
+function getPackageSize(name) {
+  return PACKAGE_SIZES[name.toLowerCase()] || 500;
+}
+function analyzeOptimizations(packages, hardware, options = {}) {
+  const { aggressive = false, targetSizeReductionPercent = 20 } = options;
+  const suggestions = [];
+  const unusedPackages = [];
+  const duplicateFunctionality = [];
+  const hardwareOptimizations = [];
+  const packageNames = packages.map((p) => p.name.toLowerCase());
+  let currentSizeKb = packages.reduce((sum, p) => sum + getPackageSize(p.name), 0);
+  let potentialSavingsKb = 0;
+  for (const pkg of packages) {
+    const alt = ALTERNATIVES[pkg.name.toLowerCase()];
+    if (alt) {
+      const currentSize = getPackageSize(pkg.name);
+      const savings = Math.floor(currentSize * (alt.savingsPercent / 100));
+      potentialSavingsKb += savings;
+      suggestions.push({
+        type: "replace",
+        package: pkg.name,
+        reason: alt.note,
+        savingsKb: savings,
+        replacement: alt.replacement,
+        command: alt.replacement.includes("native") ? `pip uninstall ${pkg.name}` : `pip uninstall ${pkg.name} && pip install ${alt.replacement}`,
+        confidence: "high",
+        impact: "test-required"
+      });
+    }
+  }
+  for (const group of DUPLICATE_GROUPS) {
+    const installed = group.filter((p) => packageNames.includes(p.toLowerCase()));
+    if (installed.length > 1) {
+      const sorted = installed.sort((a, b) => getPackageSize(a) - getPackageSize(b));
+      const keep = sorted[0];
+      const remove = sorted.slice(1);
+      const savings = remove.reduce((sum, p) => sum + getPackageSize(p), 0);
+      potentialSavingsKb += savings;
+      duplicateFunctionality.push({
+        packages: installed,
+        recommendation: `Keep ${keep}, consider removing: ${remove.join(", ")}`
+      });
+      for (const pkg of remove) {
+        suggestions.push({
+          type: "remove",
+          package: pkg,
+          reason: `Duplicate functionality with ${keep}`,
+          savingsKb: getPackageSize(pkg),
+          command: `pip uninstall ${pkg}`,
+          confidence: "medium",
+          impact: "test-required"
+        });
+      }
+    }
+  }
+  if (hardware.gpu === "none") {
+    const gpuPackages = packages.filter(
+      (p) => p.name.toLowerCase().includes("cuda") || p.name.toLowerCase().includes("-gpu") || p.name.toLowerCase() === "tensorflow-gpu"
+    );
+    for (const pkg of gpuPackages) {
+      const size = getPackageSize(pkg.name);
+      potentialSavingsKb += size;
+      suggestions.push({
+        type: "remove",
+        package: pkg.name,
+        reason: "GPU package on CPU-only system",
+        savingsKb: size,
+        command: `pip uninstall ${pkg.name}`,
+        confidence: "high",
+        impact: "safe"
+      });
+      hardwareOptimizations.push(`Remove ${pkg.name} - no GPU detected`);
+    }
+    if (packageNames.includes("torch") && hardware.totalMemoryGb < 8) {
+      hardwareOptimizations.push("Consider using torch CPU-only build with reduced memory footprint");
+    }
+  }
+  if (hardware.totalMemoryGb < 8) {
+    const heavyPackages = packages.filter(
+      (p) => getPackageSize(p.name) > 1e5
+    );
+    if (heavyPackages.length > 2) {
+      hardwareOptimizations.push(
+        `System has ${hardware.totalMemoryGb}GB RAM - consider reducing number of heavy ML frameworks`
+      );
+    }
+  }
+  const likelyDevPackages = packages.filter(
+    (p) => p.name.toLowerCase().includes("test") || p.name.toLowerCase().includes("lint") || p.name.toLowerCase().includes("format") || p.name.toLowerCase().includes("debug") || ["pytest", "black", "flake8", "mypy", "pylint", "isort", "coverage", "tox"].includes(p.name.toLowerCase())
+  );
+  if (likelyDevPackages.length > 0 && aggressive) {
+    for (const pkg of likelyDevPackages) {
+      suggestions.push({
+        type: "remove",
+        package: pkg.name,
+        reason: "Likely dev dependency - remove in production",
+        savingsKb: getPackageSize(pkg.name),
+        command: `pip uninstall ${pkg.name}`,
+        confidence: "low",
+        impact: "safe"
+      });
+    }
+  }
+  suggestions.sort((a, b) => b.savingsKb - a.savingsKb);
+  return {
+    currentSizeKb,
+    potentialSavingsKb,
+    suggestions,
+    unusedPackages,
+    duplicateFunctionality,
+    hardwareOptimizations
+  };
+}
+function formatOptimizationReport(report, colorize = true) {
+  const colors = {
+    reset: colorize ? "\x1B[0m" : "",
+    red: colorize ? "\x1B[31m" : "",
+    yellow: colorize ? "\x1B[33m" : "",
+    green: colorize ? "\x1B[32m" : "",
+    blue: colorize ? "\x1B[34m" : "",
+    cyan: colorize ? "\x1B[36m" : "",
+    dim: colorize ? "\x1B[2m" : "",
+    bold: colorize ? "\x1B[1m" : ""
+  };
+  const lines = [];
+  function formatSize(kb) {
+    if (kb >= 1e3) return `${(kb / 1e3).toFixed(1)}MB`;
+    return `${kb}KB`;
+  }
+  lines.push(`${colors.bold}Komodo Optimizer Report${colors.reset}`);
+  lines.push("");
+  const savingsPercent = (report.potentialSavingsKb / report.currentSizeKb * 100).toFixed(1);
+  lines.push(`${colors.bold}Size Analysis${colors.reset}`);
+  lines.push(`  Current size: ${formatSize(report.currentSizeKb)}`);
+  lines.push(`  ${colors.green}Potential savings: ${formatSize(report.potentialSavingsKb)} (${savingsPercent}%)${colors.reset}`);
+  lines.push("");
+  if (report.hardwareOptimizations.length > 0) {
+    lines.push(`${colors.bold}Hardware Optimizations${colors.reset}`);
+    for (const opt of report.hardwareOptimizations) {
+      lines.push(`  ${colors.cyan}\u2192${colors.reset} ${opt}`);
+    }
+    lines.push("");
+  }
+  if (report.duplicateFunctionality.length > 0) {
+    lines.push(`${colors.yellow}${colors.bold}Duplicate Functionality Detected${colors.reset}`);
+    for (const dup of report.duplicateFunctionality) {
+      lines.push(`  ${colors.yellow}\u26A0${colors.reset} ${dup.packages.join(", ")}`);
+      lines.push(`    ${colors.dim}${dup.recommendation}${colors.reset}`);
+    }
+    lines.push("");
+  }
+  if (report.suggestions.length > 0) {
+    lines.push(`${colors.bold}Optimization Suggestions${colors.reset}`);
+    lines.push("");
+    const highConf = report.suggestions.filter((s) => s.confidence === "high");
+    const medConf = report.suggestions.filter((s) => s.confidence === "medium");
+    const lowConf = report.suggestions.filter((s) => s.confidence === "low");
+    if (highConf.length > 0) {
+      lines.push(`${colors.green}High Confidence${colors.reset}`);
+      for (const sug of highConf.slice(0, 5)) {
+        const impactColor = sug.impact === "safe" ? colors.green : sug.impact === "test-required" ? colors.yellow : colors.red;
+        lines.push(`  ${sug.type.toUpperCase()} ${colors.bold}${sug.package}${colors.reset}`);
+        lines.push(`    ${colors.dim}${sug.reason}${colors.reset}`);
+        lines.push(`    Saves: ${colors.green}${formatSize(sug.savingsKb)}${colors.reset} | Impact: ${impactColor}${sug.impact}${colors.reset}`);
+        lines.push(`    ${colors.cyan}$ ${sug.command}${colors.reset}`);
+        lines.push("");
+      }
+    }
+    if (medConf.length > 0 && highConf.length < 5) {
+      lines.push(`${colors.yellow}Medium Confidence${colors.reset}`);
+      for (const sug of medConf.slice(0, 3)) {
+        lines.push(`  ${sug.type.toUpperCase()} ${colors.bold}${sug.package}${colors.reset}`);
+        lines.push(`    ${colors.dim}${sug.reason}${colors.reset}`);
+        lines.push(`    Saves: ${colors.green}${formatSize(sug.savingsKb)}${colors.reset}`);
+        lines.push("");
+      }
+    }
+    if (report.suggestions.length > 8) {
+      lines.push(`${colors.dim}...and ${report.suggestions.length - 8} more suggestions${colors.reset}`);
+    }
+  } else {
+    lines.push(`${colors.green}\u2713 No major optimization opportunities found${colors.reset}`);
+  }
+  return lines.join("\n");
+}
+function generateOptimizationScript(suggestions, safeOnly = true) {
+  const filtered = safeOnly ? suggestions.filter((s) => s.impact === "safe" && s.confidence === "high") : suggestions;
+  if (filtered.length === 0) {
+    return "# No safe optimizations to apply automatically";
+  }
+  const lines = [
+    "#!/bin/bash",
+    "# Komodo Optimization Script",
+    `# Generated: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    "",
+    "set -e",
+    ""
+  ];
+  for (const sug of filtered) {
+    lines.push(`# ${sug.type}: ${sug.package} (saves ${Math.round(sug.savingsKb / 1e3)}MB)`);
+    lines.push(`# Reason: ${sug.reason}`);
+    lines.push(sug.command);
+    lines.push("");
+  }
+  lines.push('echo "Optimization complete!"');
+  return lines.join("\n");
+}
+var TEMPLATES = [
+  // ML/AI Templates
+  {
+    id: "pytorch-basic",
+    name: "PyTorch Starter",
+    description: "Basic PyTorch setup for deep learning",
+    category: "ml",
+    runtime: "python",
+    packages: [
+      { name: "torch", note: "Core PyTorch framework" },
+      { name: "torchvision", note: "Image datasets and transforms" },
+      { name: "numpy", note: "Numerical computing" },
+      { name: "matplotlib", optional: true, note: "Visualization" },
+      { name: "tqdm", optional: true, note: "Progress bars" }
+    ],
+    minMemoryGb: 8,
+    tags: ["pytorch", "deep-learning", "ai", "neural-networks"]
+  },
+  {
+    id: "pytorch-nlp",
+    name: "PyTorch NLP",
+    description: "Natural Language Processing with PyTorch and Transformers",
+    category: "ml",
+    runtime: "python",
+    packages: [
+      { name: "torch" },
+      { name: "transformers", note: "Hugging Face Transformers" },
+      { name: "tokenizers", note: "Fast tokenization" },
+      { name: "datasets", note: "Hugging Face datasets" },
+      { name: "sentencepiece", optional: true },
+      { name: "sacremoses", optional: true }
+    ],
+    minMemoryGb: 16,
+    tags: ["nlp", "transformers", "bert", "gpt", "language-models"]
+  },
+  {
+    id: "tensorflow-basic",
+    name: "TensorFlow Starter",
+    description: "TensorFlow 2.x for machine learning",
+    category: "ml",
+    runtime: "python",
+    packages: [
+      { name: "tensorflow", note: "TensorFlow 2.x with Keras" },
+      { name: "numpy" },
+      { name: "pandas", optional: true },
+      { name: "matplotlib", optional: true },
+      { name: "tensorboard", optional: true, note: "Training visualization" }
+    ],
+    minMemoryGb: 8,
+    tags: ["tensorflow", "keras", "deep-learning", "ai"]
+  },
+  {
+    id: "computer-vision",
+    name: "Computer Vision",
+    description: "Image processing and computer vision",
+    category: "ml",
+    runtime: "python",
+    packages: [
+      { name: "torch" },
+      { name: "torchvision" },
+      { name: "opencv-python-headless", note: "OpenCV for servers" },
+      { name: "pillow", note: "Image processing" },
+      { name: "albumentations", optional: true, note: "Image augmentation" },
+      { name: "timm", optional: true, note: "PyTorch Image Models" }
+    ],
+    minMemoryGb: 8,
+    requiresGpu: true,
+    tags: ["vision", "images", "opencv", "cnn"]
+  },
+  {
+    id: "llm-local",
+    name: "Local LLM",
+    description: "Run large language models locally with llama.cpp",
+    category: "ml",
+    runtime: "python",
+    packages: [
+      { name: "llama-cpp-python", note: "llama.cpp Python bindings" },
+      { name: "huggingface-hub", note: "Download models" },
+      { name: "gradio", optional: true, note: "Web UI" }
+    ],
+    minMemoryGb: 16,
+    tags: ["llm", "llama", "local-ai", "chatbot"]
+  },
+  // Data Science Templates
+  {
+    id: "data-analysis",
+    name: "Data Analysis",
+    description: "Data analysis and visualization toolkit",
+    category: "data",
+    runtime: "python",
+    packages: [
+      { name: "pandas", note: "Data manipulation" },
+      { name: "numpy", note: "Numerical computing" },
+      { name: "matplotlib", note: "Basic plotting" },
+      { name: "seaborn", note: "Statistical visualization" },
+      { name: "scipy", optional: true, note: "Scientific computing" },
+      { name: "jupyter", optional: true, note: "Interactive notebooks" }
+    ],
+    tags: ["data", "analytics", "visualization", "pandas"]
+  },
+  {
+    id: "data-engineering",
+    name: "Data Engineering",
+    description: "Data pipelines and processing",
+    category: "data",
+    runtime: "python",
+    packages: [
+      { name: "pandas" },
+      { name: "polars", note: "Fast DataFrames" },
+      { name: "pyarrow", note: "Columnar data format" },
+      { name: "duckdb", note: "Embedded analytics DB" },
+      { name: "sqlalchemy", note: "Database toolkit" },
+      { name: "boto3", optional: true, note: "AWS SDK" }
+    ],
+    tags: ["etl", "pipelines", "databases", "big-data"]
+  },
+  // Web Development Templates
+  {
+    id: "nextjs-app",
+    name: "Next.js App",
+    description: "Modern React with Next.js",
+    category: "web",
+    runtime: "node",
+    packages: [
+      { name: "next", note: "Next.js framework" },
+      { name: "react" },
+      { name: "react-dom" },
+      { name: "typescript", optional: true },
+      { name: "tailwindcss", optional: true, note: "Utility CSS" },
+      { name: "@types/react", optional: true }
+    ],
+    setupCommands: ["npx create-next-app@latest"],
+    tags: ["react", "nextjs", "frontend", "ssr"]
+  },
+  {
+    id: "react-spa",
+    name: "React SPA",
+    description: "Single-page React application with Vite",
+    category: "web",
+    runtime: "node",
+    packages: [
+      { name: "react" },
+      { name: "react-dom" },
+      { name: "vite", note: "Fast build tool" },
+      { name: "react-router-dom", optional: true },
+      { name: "zustand", optional: true, note: "State management" }
+    ],
+    setupCommands: ["npm create vite@latest -- --template react-ts"],
+    tags: ["react", "spa", "vite", "frontend"]
+  },
+  // API Templates
+  {
+    id: "fastapi",
+    name: "FastAPI",
+    description: "Modern Python API with FastAPI",
+    category: "api",
+    runtime: "python",
+    packages: [
+      { name: "fastapi", note: "Web framework" },
+      { name: "uvicorn", note: "ASGI server" },
+      { name: "pydantic", note: "Data validation" },
+      { name: "python-multipart", optional: true, note: "Form data" },
+      { name: "sqlalchemy", optional: true, note: "Database ORM" },
+      { name: "httpx", optional: true, note: "HTTP client" }
+    ],
+    tags: ["api", "rest", "async", "python"]
+  },
+  {
+    id: "flask-api",
+    name: "Flask API",
+    description: "Lightweight Python web API",
+    category: "api",
+    runtime: "python",
+    packages: [
+      { name: "flask", note: "Web framework" },
+      { name: "flask-cors", optional: true },
+      { name: "flask-sqlalchemy", optional: true },
+      { name: "gunicorn", note: "Production server" },
+      { name: "python-dotenv", optional: true }
+    ],
+    tags: ["api", "flask", "rest", "python"]
+  },
+  {
+    id: "express-api",
+    name: "Express API",
+    description: "Node.js REST API with Express",
+    category: "api",
+    runtime: "node",
+    packages: [
+      { name: "express", note: "Web framework" },
+      { name: "cors" },
+      { name: "helmet", note: "Security headers" },
+      { name: "dotenv", note: "Environment variables" },
+      { name: "prisma", optional: true, note: "Database ORM" }
+    ],
+    tags: ["api", "express", "nodejs", "rest"]
+  },
+  // Full Stack Templates
+  {
+    id: "fullstack-python",
+    name: "Full Stack Python",
+    description: "FastAPI backend + React frontend",
+    category: "web",
+    runtime: "mixed",
+    packages: [
+      { name: "fastapi" },
+      { name: "uvicorn" },
+      { name: "sqlalchemy" },
+      { name: "react" },
+      { name: "vite" },
+      { name: "axios", note: "HTTP client" }
+    ],
+    tags: ["fullstack", "fastapi", "react"]
+  },
+  // DevOps Templates
+  {
+    id: "automation",
+    name: "Automation & Scripting",
+    description: "Python automation toolkit",
+    category: "devops",
+    runtime: "python",
+    packages: [
+      { name: "requests", note: "HTTP requests" },
+      { name: "beautifulsoup4", note: "HTML parsing" },
+      { name: "selenium", optional: true, note: "Browser automation" },
+      { name: "paramiko", optional: true, note: "SSH" },
+      { name: "schedule", optional: true, note: "Job scheduling" },
+      { name: "click", note: "CLI framework" }
+    ],
+    tags: ["automation", "scripting", "cli", "devops"]
+  }
+];
+function getTemplateById(id) {
+  return TEMPLATES.find((t) => t.id === id);
+}
+function searchTemplates(query) {
+  const lower = query.toLowerCase();
+  return TEMPLATES.filter(
+    (t) => t.name.toLowerCase().includes(lower) || t.description.toLowerCase().includes(lower) || t.tags.some((tag) => tag.includes(lower)) || t.packages.some((p) => p.name.toLowerCase().includes(lower))
+  );
+}
+function formatTemplateList(templates, colorize = true) {
+  const colors = {
+    reset: colorize ? "\x1B[0m" : "",
+    bold: colorize ? "\x1B[1m" : "",
+    dim: colorize ? "\x1B[2m" : "",
+    cyan: colorize ? "\x1B[36m" : "",
+    green: colorize ? "\x1B[32m" : "",
+    yellow: colorize ? "\x1B[33m" : ""
+  };
+  const lines = [];
+  const categories = [...new Set(templates.map((t) => t.category))];
+  for (const category of categories) {
+    const categoryTemplates = templates.filter((t) => t.category === category);
+    const categoryName = category.charAt(0).toUpperCase() + category.slice(1);
+    lines.push(`${colors.bold}${categoryName}${colors.reset}`);
+    for (const template of categoryTemplates) {
+      const requirements = [];
+      if (template.minMemoryGb) requirements.push(`${template.minMemoryGb}GB+ RAM`);
+      if (template.requiresGpu) requirements.push("GPU");
+      lines.push(`  ${colors.cyan}${template.id}${colors.reset} - ${template.name}`);
+      lines.push(`    ${colors.dim}${template.description}${colors.reset}`);
+      if (requirements.length > 0) {
+        lines.push(`    ${colors.yellow}Requires: ${requirements.join(", ")}${colors.reset}`);
+      }
+      lines.push(`    ${colors.dim}Packages: ${template.packages.filter((p) => !p.optional).map((p) => p.name).join(", ")}${colors.reset}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function getInstallCommandsForTemplate(template) {
+  const commands = [];
+  if (template.runtime === "python" || template.runtime === "mixed") {
+    const pythonPackages = template.packages.filter((p) => !p.optional).map((p) => p.version ? `${p.name}==${p.version}` : p.name);
+    if (pythonPackages.length > 0) {
+      commands.push(`pip install ${pythonPackages.join(" ")}`);
+    }
+  }
+  if (template.runtime === "node" || template.runtime === "mixed") {
+    const nodePackages = template.packages.filter((p) => !p.optional).map((p) => p.version ? `${p.name}@${p.version}` : p.name);
+    if (nodePackages.length > 0) {
+      commands.push(`npm install ${nodePackages.join(" ")}`);
+    }
+  }
+  if (template.setupCommands) {
+    commands.push(...template.setupCommands);
+  }
+  return commands;
+}
+var PACKAGE_DATABASE = {
+  // ML/AI Packages
+  "torch": {
+    summary: "PyTorch - Deep learning framework",
+    description: "PyTorch is an open-source machine learning library developed by Meta AI. It provides tensor computation with GPU acceleration and a tape-based automatic differentiation system for building neural networks.",
+    category: "Machine Learning",
+    useCases: [
+      "Deep learning model training",
+      "Computer vision applications",
+      "Natural language processing",
+      "Reinforcement learning",
+      "Research and prototyping"
+    ],
+    commonlyUsedWith: ["torchvision", "numpy", "transformers", "tqdm", "tensorboard"],
+    alternatives: [
+      { name: "tensorflow", note: "Google's ML framework, more production-focused" },
+      { name: "jax", note: "Google's newer framework, good for research" }
+    ],
+    documentation: "https://pytorch.org/docs/",
+    popularity: "very-high",
+    maintenance: "active"
+  },
+  "tensorflow": {
+    summary: "TensorFlow - End-to-end ML platform",
+    description: "TensorFlow is Google's open-source platform for machine learning. TensorFlow 2.x includes Keras as the high-level API, making it easier to build and train models.",
+    category: "Machine Learning",
+    useCases: [
+      "Production ML deployment",
+      "Mobile ML (TensorFlow Lite)",
+      "Web ML (TensorFlow.js)",
+      "Large-scale distributed training"
+    ],
+    commonlyUsedWith: ["keras", "numpy", "tensorboard", "tensorflow-hub"],
+    alternatives: [
+      { name: "torch", note: "More Pythonic, popular in research" },
+      { name: "jax", note: "Newer Google framework" }
+    ],
+    documentation: "https://www.tensorflow.org/api_docs",
+    popularity: "very-high",
+    maintenance: "active"
+  },
+  "transformers": {
+    summary: "Hugging Face Transformers - State-of-the-art NLP",
+    description: "Provides thousands of pretrained models for natural language processing, computer vision, audio, and multimodal tasks. Easy to fine-tune and deploy.",
+    category: "Machine Learning",
+    useCases: [
+      "Text classification",
+      "Named entity recognition",
+      "Question answering",
+      "Text generation",
+      "Translation"
+    ],
+    commonlyUsedWith: ["torch", "tokenizers", "datasets", "accelerate"],
+    alternatives: [
+      { name: "spacy", note: "Faster for production NLP pipelines" },
+      { name: "flair", note: "Simpler API for NLP" }
+    ],
+    documentation: "https://huggingface.co/docs/transformers",
+    popularity: "very-high",
+    maintenance: "active"
+  },
+  // Data Science
+  "numpy": {
+    summary: "NumPy - Fundamental array computing",
+    description: "The fundamental package for scientific computing in Python. Provides support for large, multi-dimensional arrays and matrices, along with mathematical functions.",
+    category: "Data Science",
+    useCases: [
+      "Numerical computations",
+      "Array manipulation",
+      "Linear algebra",
+      "Random number generation",
+      "Foundation for other libraries"
+    ],
+    commonlyUsedWith: ["pandas", "scipy", "matplotlib", "scikit-learn"],
+    alternatives: [
+      { name: "cupy", note: "GPU-accelerated NumPy" },
+      { name: "jax.numpy", note: "Auto-diff enabled NumPy" }
+    ],
+    documentation: "https://numpy.org/doc/",
+    popularity: "very-high",
+    maintenance: "active"
+  },
+  "pandas": {
+    summary: "Pandas - Data analysis and manipulation",
+    description: "Powerful data structures for data analysis, time series, and statistics. The DataFrame is the primary data structure, similar to a spreadsheet or SQL table.",
+    category: "Data Science",
+    useCases: [
+      "Data cleaning and preparation",
+      "Exploratory data analysis",
+      "Time series analysis",
+      "CSV/Excel file handling",
+      "Data transformation"
+    ],
+    commonlyUsedWith: ["numpy", "matplotlib", "seaborn", "scikit-learn"],
+    alternatives: [
+      { name: "polars", note: "Faster, Rust-based alternative" },
+      { name: "dask", note: "Parallel computing for large datasets" }
+    ],
+    documentation: "https://pandas.pydata.org/docs/",
+    popularity: "very-high",
+    maintenance: "active"
+  },
+  // Web Frameworks
+  "fastapi": {
+    summary: "FastAPI - Modern Python web framework",
+    description: "High-performance web framework for building APIs with Python 3.7+. Based on standard Python type hints, automatic API documentation, and async support.",
+    category: "Web Framework",
+    useCases: [
+      "REST API development",
+      "Microservices",
+      "Real-time applications",
+      "ML model serving"
+    ],
+    commonlyUsedWith: ["uvicorn", "pydantic", "sqlalchemy", "httpx"],
+    alternatives: [
+      { name: "flask", note: "Simpler, more flexible" },
+      { name: "django", note: "Full-featured, batteries included" }
+    ],
+    documentation: "https://fastapi.tiangolo.com/",
+    popularity: "very-high",
+    maintenance: "active"
+  },
+  "flask": {
+    summary: "Flask - Lightweight web framework",
+    description: "Micro web framework that doesn't require particular tools or libraries. Keeps the core simple but extensible through plugins.",
+    category: "Web Framework",
+    useCases: [
+      "Simple web applications",
+      "REST APIs",
+      "Prototyping",
+      "Microservices"
+    ],
+    commonlyUsedWith: ["werkzeug", "jinja2", "flask-sqlalchemy", "gunicorn"],
+    alternatives: [
+      { name: "fastapi", note: "Modern, async, auto-docs" },
+      { name: "django", note: "Full-featured framework" }
+    ],
+    documentation: "https://flask.palletsprojects.com/",
+    popularity: "very-high",
+    maintenance: "active"
+  },
+  "django": {
+    summary: "Django - Full-featured web framework",
+    description: "High-level Python web framework that encourages rapid development. Includes ORM, admin interface, authentication, and more out of the box.",
+    category: "Web Framework",
+    useCases: [
+      "Full-stack web applications",
+      "Content management systems",
+      "E-commerce platforms",
+      "Admin interfaces"
+    ],
+    commonlyUsedWith: ["django-rest-framework", "celery", "redis", "postgresql"],
+    alternatives: [
+      { name: "flask", note: "Lighter weight, more flexible" },
+      { name: "fastapi", note: "API-focused, async" }
+    ],
+    documentation: "https://docs.djangoproject.com/",
+    popularity: "very-high",
+    maintenance: "active"
+  },
+  // Node.js packages
+  "react": {
+    summary: "React - UI component library",
+    description: "JavaScript library for building user interfaces. Uses a component-based architecture and virtual DOM for efficient updates.",
+    category: "Frontend",
+    useCases: [
+      "Single-page applications",
+      "Component libraries",
+      "Mobile apps (React Native)",
+      "Server-side rendering"
+    ],
+    commonlyUsedWith: ["react-dom", "react-router-dom", "redux", "next"],
+    alternatives: [
+      { name: "vue", note: "Easier learning curve" },
+      { name: "svelte", note: "Compile-time framework, smaller bundles" }
+    ],
+    documentation: "https://react.dev/",
+    popularity: "very-high",
+    maintenance: "active"
+  },
+  "next": {
+    summary: "Next.js - React framework",
+    description: "Production-ready React framework with server-side rendering, static site generation, API routes, and more.",
+    category: "Frontend Framework",
+    useCases: [
+      "Server-side rendered apps",
+      "Static websites",
+      "Full-stack applications",
+      "E-commerce sites"
+    ],
+    commonlyUsedWith: ["react", "tailwindcss", "prisma", "vercel"],
+    alternatives: [
+      { name: "remix", note: "Web standards focused" },
+      { name: "gatsby", note: "Static site generator" }
+    ],
+    documentation: "https://nextjs.org/docs",
+    popularity: "very-high",
+    maintenance: "active"
+  },
+  "express": {
+    summary: "Express - Node.js web framework",
+    description: "Minimal and flexible Node.js web application framework providing robust features for web and mobile applications.",
+    category: "Backend Framework",
+    useCases: [
+      "REST APIs",
+      "Web servers",
+      "Middleware-based apps",
+      "Backend services"
+    ],
+    commonlyUsedWith: ["cors", "helmet", "mongoose", "passport"],
+    alternatives: [
+      { name: "fastify", note: "Faster, lower overhead" },
+      { name: "koa", note: "Modern, lighter weight" }
+    ],
+    documentation: "https://expressjs.com/",
+    popularity: "very-high",
+    maintenance: "stable"
+  },
+  // Utilities
+  "requests": {
+    summary: "Requests - HTTP for humans",
+    description: "Elegant and simple HTTP library for Python. Makes HTTP requests intuitive with a clean API.",
+    category: "Networking",
+    useCases: [
+      "API consumption",
+      "Web scraping",
+      "File downloads",
+      "REST client"
+    ],
+    commonlyUsedWith: ["beautifulsoup4", "lxml", "urllib3"],
+    alternatives: [
+      { name: "httpx", note: "Async support, HTTP/2" },
+      { name: "aiohttp", note: "Async HTTP client/server" }
+    ],
+    documentation: "https://requests.readthedocs.io/",
+    popularity: "very-high",
+    maintenance: "active"
+  },
+  "axios": {
+    summary: "Axios - HTTP client",
+    description: "Promise-based HTTP client for the browser and Node.js. Supports request/response interceptors and automatic JSON parsing.",
+    category: "Networking",
+    useCases: [
+      "API requests",
+      "Form submissions",
+      "File uploads",
+      "REST client"
+    ],
+    commonlyUsedWith: ["react", "vue", "typescript"],
+    alternatives: [
+      { name: "fetch", note: "Native browser API" },
+      { name: "got", note: "Node.js focused" }
+    ],
+    documentation: "https://axios-http.com/docs/intro",
+    popularity: "very-high",
+    maintenance: "active"
+  },
+  // Deprecated/Legacy
+  "moment": {
+    summary: "Moment.js - Date library (Legacy)",
+    description: "Date manipulation library. Now in maintenance mode - the team recommends using alternatives for new projects.",
+    category: "Utilities",
+    useCases: [
+      "Date parsing",
+      "Date formatting",
+      "Date manipulation"
+    ],
+    commonlyUsedWith: ["moment-timezone"],
+    alternatives: [
+      { name: "dayjs", note: "2KB, same API - recommended" },
+      { name: "date-fns", note: "Modular, tree-shakeable" },
+      { name: "luxon", note: "By Moment team, modern" }
+    ],
+    warnings: [
+      "Moment.js is in maintenance mode",
+      "Large bundle size (300KB)",
+      "Not tree-shakeable"
+    ],
+    documentation: "https://momentjs.com/docs/",
+    popularity: "high",
+    maintenance: "minimal"
+  },
+  "request": {
+    summary: "Request - HTTP client (Deprecated)",
+    description: "Simplified HTTP request client. DEPRECATED - no longer maintained.",
+    category: "Networking",
+    useCases: ["Legacy HTTP requests"],
+    commonlyUsedWith: [],
+    alternatives: [
+      { name: "axios", note: "Modern, Promise-based" },
+      { name: "got", note: "Modern Node.js client" },
+      { name: "node-fetch", note: "Fetch API for Node" }
+    ],
+    warnings: [
+      "DEPRECATED - do not use for new projects",
+      "No security updates"
+    ],
+    documentation: "https://github.com/request/request",
+    popularity: "medium",
+    maintenance: "deprecated"
+  }
+};
+function explainPackage(name) {
+  const normalizedName = name.toLowerCase();
+  const info = PACKAGE_DATABASE[normalizedName];
+  if (!info) {
+    return null;
+  }
+  const runtime = ["torch", "tensorflow", "numpy", "pandas", "fastapi", "flask", "django", "requests"].includes(normalizedName) ? "python" : "node";
+  return {
+    name,
+    ...info,
+    installCommand: runtime === "python" ? `pip install ${name}` : `npm install ${name}`
+  };
+}
+function formatExplanation(explanation, colorize = true) {
+  const colors = {
+    reset: colorize ? "\x1B[0m" : "",
+    bold: colorize ? "\x1B[1m" : "",
+    dim: colorize ? "\x1B[2m" : "",
+    cyan: colorize ? "\x1B[36m" : "",
+    green: colorize ? "\x1B[32m" : "",
+    yellow: colorize ? "\x1B[33m" : "",
+    red: colorize ? "\x1B[31m" : "",
+    blue: colorize ? "\x1B[34m" : ""
+  };
+  const lines = [];
+  lines.push(`${colors.bold}${explanation.name}${colors.reset} ${colors.dim}(${explanation.category})${colors.reset}`);
+  lines.push(`${colors.cyan}${explanation.summary}${colors.reset}`);
+  lines.push("");
+  lines.push(explanation.description);
+  lines.push("");
+  const popColor = explanation.popularity === "very-high" ? colors.green : colors.yellow;
+  const maintColor = explanation.maintenance === "active" ? colors.green : explanation.maintenance === "stable" ? colors.blue : explanation.maintenance === "deprecated" ? colors.red : colors.yellow;
+  lines.push(`${colors.dim}Popularity:${colors.reset} ${popColor}${explanation.popularity}${colors.reset} | ${colors.dim}Maintenance:${colors.reset} ${maintColor}${explanation.maintenance}${colors.reset}`);
+  lines.push("");
+  if (explanation.warnings && explanation.warnings.length > 0) {
+    lines.push(`${colors.red}${colors.bold}Warnings${colors.reset}`);
+    for (const warning of explanation.warnings) {
+      lines.push(`  ${colors.red}\u26A0${colors.reset} ${warning}`);
+    }
+    lines.push("");
+  }
+  lines.push(`${colors.bold}Use Cases${colors.reset}`);
+  for (const useCase of explanation.useCases) {
+    lines.push(`  ${colors.green}\u2022${colors.reset} ${useCase}`);
+  }
+  lines.push("");
+  if (explanation.commonlyUsedWith.length > 0) {
+    lines.push(`${colors.bold}Commonly Used With${colors.reset}`);
+    lines.push(`  ${explanation.commonlyUsedWith.join(", ")}`);
+    lines.push("");
+  }
+  if (explanation.alternatives.length > 0) {
+    lines.push(`${colors.bold}Alternatives${colors.reset}`);
+    for (const alt of explanation.alternatives) {
+      lines.push(`  ${colors.cyan}${alt.name}${colors.reset} - ${colors.dim}${alt.note}${colors.reset}`);
+    }
+    lines.push("");
+  }
+  lines.push(`${colors.bold}Install${colors.reset}`);
+  lines.push(`  ${colors.cyan}$ ${explanation.installCommand}${colors.reset}`);
+  lines.push("");
+  lines.push(`${colors.dim}Documentation: ${explanation.documentation}${colors.reset}`);
+  return lines.join("\n");
+}
+function parseGitHubUrl(url) {
+  const patterns = [
+    /github\.com\/([^\/]+)\/([^\/]+?)(?:\.git)?(?:\/tree\/([^\/]+))?$/,
+    /github\.com\/([^\/]+)\/([^\/]+?)(?:\.git)?$/
+  ];
+  for (const pattern of patterns) {
+    const match = url.match(pattern);
+    if (match && match[1] && match[2]) {
+      return {
+        owner: match[1],
+        repo: match[2].replace(/\.git$/, ""),
+        branch: match[3]
+      };
+    }
+  }
+  return null;
+}
+function parseRequirementsTxt(content) {
+  const packages = [];
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("-")) {
+      continue;
+    }
+    const match = trimmed.match(/^([a-zA-Z0-9_-]+)(?:\[.*\])?(?:([<>=!~]+)(.+))?$/);
+    if (match && match[1]) {
+      packages.push({
+        name: match[1],
+        version: match[3]?.trim()
+      });
+    }
+  }
+  return { packages, source: "requirements.txt" };
+}
+function parsePackageJson(content) {
+  const packages = [];
+  try {
+    const pkg = JSON.parse(content);
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    for (const [name, version] of Object.entries(deps)) {
+      packages.push({
+        name,
+        version: String(version).replace(/^[\^~]/, "")
+      });
+    }
+  } catch {
+  }
+  return { packages, source: "package.json" };
+}
+function parsePyprojectToml(content) {
+  const packages = [];
+  const depsMatch = content.match(/dependencies\s*=\s*\[([\s\S]*?)\]/);
+  if (depsMatch && depsMatch[1]) {
+    const depsContent = depsMatch[1];
+    const depLines = depsContent.match(/"([^"]+)"|'([^']+)'/g);
+    if (depLines) {
+      for (const dep of depLines) {
+        const cleanDep = dep.replace(/["']/g, "").trim();
+        const match = cleanDep.match(/^([a-zA-Z0-9_-]+)(?:\[.*\])?(?:([<>=!~]+)(.+))?$/);
+        if (match && match[1]) {
+          packages.push({
+            name: match[1],
+            version: match[3]?.trim()
+          });
+        }
+      }
+    }
+  }
+  return { packages, source: "pyproject.toml" };
+}
+function parseSetupPy(content) {
+  const packages = [];
+  const requiresMatch = content.match(/install_requires\s*=\s*\[([\s\S]*?)\]/);
+  if (requiresMatch && requiresMatch[1]) {
+    const requiresContent = requiresMatch[1];
+    const depLines = requiresContent.match(/"([^"]+)"|'([^']+)'/g);
+    if (depLines) {
+      for (const dep of depLines) {
+        const cleanDep = dep.replace(/["']/g, "").trim();
+        const match = cleanDep.match(/^([a-zA-Z0-9_-]+)/);
+        if (match && match[1]) {
+          packages.push({ name: match[1] });
+        }
+      }
+    }
+  }
+  return { packages, source: "setup.py" };
+}
+function analyzeRepoStructure(files) {
+  const packages = [];
+  const setupCommands = [];
+  const envVars = [];
+  const notes = [];
+  let runtime = "unknown";
+  let confidence = "low";
+  const hasPython = "requirements.txt" in files || "pyproject.toml" in files || "setup.py" in files;
+  const hasNode = "package.json" in files;
+  if (hasPython && hasNode) {
+    runtime = "mixed";
+  } else if (hasPython) {
+    runtime = "python";
+  } else if (hasNode) {
+    runtime = "node";
+  }
+  if (files["requirements.txt"]) {
+    const parsed = parseRequirementsTxt(files["requirements.txt"]);
+    packages.push(...parsed.packages.map((p) => ({ ...p, source: "requirements.txt" })));
+    setupCommands.push("pip install -r requirements.txt");
+    confidence = "high";
+  }
+  if (files["pyproject.toml"]) {
+    const parsed = parsePyprojectToml(files["pyproject.toml"]);
+    packages.push(...parsed.packages.map((p) => ({ ...p, source: "pyproject.toml" })));
+    if (!setupCommands.some((c) => c.includes("pip"))) {
+      setupCommands.push("pip install -e .");
+    }
+    confidence = "high";
+  }
+  if (files["setup.py"] && packages.length === 0) {
+    const parsed = parseSetupPy(files["setup.py"]);
+    packages.push(...parsed.packages.map((p) => ({ ...p, source: "setup.py" })));
+    setupCommands.push("pip install -e .");
+    confidence = "medium";
+  }
+  if (files["package.json"]) {
+    const parsed = parsePackageJson(files["package.json"]);
+    packages.push(...parsed.packages.map((p) => ({ ...p, source: "package.json" })));
+    if (files["pnpm-lock.yaml"]) {
+      setupCommands.push("pnpm install");
+    } else if (files["yarn.lock"]) {
+      setupCommands.push("yarn install");
+    } else {
+      setupCommands.push("npm install");
+    }
+    confidence = "high";
+  }
+  if (files[".env.example"] || files[".env.sample"]) {
+    const envContent = files[".env.example"] || files[".env.sample"] || "";
+    const envMatches = envContent.match(/^([A-Z_]+)=/gm);
+    if (envMatches) {
+      envVars.push(...envMatches.map((m) => m.replace("=", "")));
+    }
+    notes.push("This project uses environment variables - check .env.example");
+  }
+  if (files["Dockerfile"] || files["docker-compose.yml"]) {
+    notes.push("Docker setup available - you can use `docker-compose up` instead");
+  }
+  if (files["README.md"]) {
+    if (files["README.md"].includes("pip install")) {
+      notes.push("Check README.md for additional setup instructions");
+    }
+  }
+  const uniquePackages = /* @__PURE__ */ new Map();
+  for (const pkg of packages) {
+    if (!uniquePackages.has(pkg.name.toLowerCase())) {
+      uniquePackages.set(pkg.name.toLowerCase(), pkg);
+    }
+  }
+  return {
+    url: "",
+    name: "",
+    runtime,
+    packages: Array.from(uniquePackages.values()),
+    setupCommands,
+    envVars,
+    notes,
+    confidence
+  };
+}
+function formatRepoAnalysis(analysis, colorize = true) {
+  const colors = {
+    reset: colorize ? "\x1B[0m" : "",
+    bold: colorize ? "\x1B[1m" : "",
+    dim: colorize ? "\x1B[2m" : "",
+    cyan: colorize ? "\x1B[36m" : "",
+    green: colorize ? "\x1B[32m" : "",
+    yellow: colorize ? "\x1B[33m" : ""
+  };
+  const lines = [];
+  lines.push(`${colors.bold}Repository Analysis: ${analysis.name}${colors.reset}`);
+  lines.push(`${colors.dim}${analysis.url}${colors.reset}`);
+  lines.push("");
+  const runtimeLabel = {
+    python: "Python",
+    node: "Node.js",
+    mixed: "Python + Node.js",
+    unknown: "Unknown"
+  }[analysis.runtime];
+  lines.push(`${colors.bold}Runtime:${colors.reset} ${runtimeLabel}`);
+  lines.push(`${colors.bold}Confidence:${colors.reset} ${analysis.confidence}`);
+  lines.push("");
+  if (analysis.packages.length > 0) {
+    lines.push(`${colors.bold}Dependencies (${analysis.packages.length})${colors.reset}`);
+    const bySource = /* @__PURE__ */ new Map();
+    for (const pkg of analysis.packages) {
+      if (!bySource.has(pkg.source)) {
+        bySource.set(pkg.source, []);
+      }
+      bySource.get(pkg.source).push(pkg);
+    }
+    for (const [source, pkgs] of bySource) {
+      lines.push(`  ${colors.cyan}${source}:${colors.reset}`);
+      const displayed = pkgs.slice(0, 10);
+      for (const pkg of displayed) {
+        const version = pkg.version ? `@${pkg.version}` : "";
+        lines.push(`    ${pkg.name}${colors.dim}${version}${colors.reset}`);
+      }
+      if (pkgs.length > 10) {
+        lines.push(`    ${colors.dim}...and ${pkgs.length - 10} more${colors.reset}`);
+      }
+    }
+    lines.push("");
+  }
+  if (analysis.setupCommands.length > 0) {
+    lines.push(`${colors.bold}Setup Commands${colors.reset}`);
+    for (const cmd of analysis.setupCommands) {
+      lines.push(`  ${colors.cyan}$ ${cmd}${colors.reset}`);
+    }
+    lines.push("");
+  }
+  if (analysis.envVars.length > 0) {
+    lines.push(`${colors.yellow}${colors.bold}Environment Variables Required${colors.reset}`);
+    for (const envVar of analysis.envVars.slice(0, 5)) {
+      lines.push(`  ${colors.yellow}\u2022${colors.reset} ${envVar}`);
+    }
+    if (analysis.envVars.length > 5) {
+      lines.push(`  ${colors.dim}...and ${analysis.envVars.length - 5} more${colors.reset}`);
+    }
+    lines.push("");
+  }
+  if (analysis.notes.length > 0) {
+    lines.push(`${colors.bold}Notes${colors.reset}`);
+    for (const note of analysis.notes) {
+      lines.push(`  ${colors.green}\u2192${colors.reset} ${note}`);
+    }
+  }
+  return lines.join("\n");
+}
+var PACKAGE_CATEGORIES = {
+  "torch": "ML/AI",
+  "tensorflow": "ML/AI",
+  "transformers": "ML/AI",
+  "scikit-learn": "ML/AI",
+  "numpy": "Data Science",
+  "pandas": "Data Science",
+  "matplotlib": "Data Science",
+  "seaborn": "Data Science",
+  "scipy": "Data Science",
+  "fastapi": "Web Backend",
+  "flask": "Web Backend",
+  "django": "Web Backend",
+  "express": "Web Backend",
+  "react": "Web Frontend",
+  "vue": "Web Frontend",
+  "next": "Web Frontend",
+  "angular": "Web Frontend",
+  "requests": "Networking",
+  "httpx": "Networking",
+  "axios": "Networking",
+  "pytest": "Testing",
+  "jest": "Testing",
+  "black": "Dev Tools",
+  "eslint": "Dev Tools",
+  "prettier": "Dev Tools"
+};
+var PACKAGE_SIZES2 = {
+  "torch": 85e4,
+  "tensorflow": 55e4,
+  "transformers": 45e3,
+  "numpy": 15e3,
+  "pandas": 12e3,
+  "scipy": 35e3,
+  "matplotlib": 8e3,
+  "scikit-learn": 25e3,
+  "opencv-python": 45e3,
+  "pillow": 3e3,
+  "requests": 500,
+  "flask": 800,
+  "django": 8e3,
+  "fastapi": 400,
+  "react": 150,
+  "next": 5e3,
+  "express": 200,
+  "lodash": 1500,
+  "axios": 100
+};
+function getPackageSize2(name) {
+  return PACKAGE_SIZES2[name.toLowerCase()] || 500;
+}
+function getPackageCategory(name) {
+  return PACKAGE_CATEGORIES[name.toLowerCase()] || "Other";
+}
+function analyzeEnvironment(packages, snapshots) {
+  const stats = calculateStats(packages);
+  const timeline = snapshots ? buildTimeline(snapshots) : void 0;
+  const recommendations = [];
+  const achievements = [];
+  const warnings = [];
+  if (stats.technicalDebtScore > 50) {
+    recommendations.push("High technical debt detected - consider updating outdated packages");
+  }
+  if (stats.totalPackages > 100) {
+    recommendations.push("Large number of packages - audit for unused dependencies");
+  }
+  const largestPkg = stats.largestPackages[0];
+  if (stats.largestPackages.length > 0 && largestPkg && largestPkg.sizeKb > 5e5) {
+    recommendations.push(`${largestPkg.name} is very large - ensure it's necessary`);
+  }
+  const mlPackages = packages.filter((p) => getPackageCategory(p.name) === "ML/AI");
+  if (mlPackages.length > 2) {
+    recommendations.push("Multiple ML frameworks detected - consider consolidating");
+  }
+  if (stats.technicalDebtScore < 20) {
+    achievements.push("Low technical debt - great maintenance!");
+  }
+  if (stats.totalPackages < 20) {
+    achievements.push("Minimal dependencies - clean project structure");
+  }
+  if (timeline && timeline.averageChangesPerWeek > 1) {
+    achievements.push("Active maintenance - regular updates");
+  }
+  if (stats.technicalDebtScore > 70) {
+    warnings.push("Critical technical debt - multiple packages need updates");
+  }
+  for (const reason of stats.technicalDebtReasons) {
+    warnings.push(reason);
+  }
+  return {
+    stats,
+    timeline,
+    recommendations,
+    achievements,
+    warnings
+  };
+}
+function calculateStats(packages) {
+  const totalPackages = packages.length;
+  let totalSizeKb = 0;
+  const runtimeBreakdown = { python: 0, node: 0 };
+  const categoryBreakdown = {};
+  const technicalDebtReasons = [];
+  let debtScore = 0;
+  const pythonIndicators = ["torch", "numpy", "pandas", "flask", "django", "fastapi", "requests"];
+  const nodeIndicators = ["react", "vue", "next", "express", "lodash", "axios"];
+  for (const pkg of packages) {
+    const name = pkg.name.toLowerCase();
+    const size = getPackageSize2(name);
+    totalSizeKb += size;
+    const category = getPackageCategory(name);
+    categoryBreakdown[category] = (categoryBreakdown[category] || 0) + 1;
+    if (pythonIndicators.includes(name)) {
+      runtimeBreakdown["python"] = (runtimeBreakdown["python"] || 0) + 1;
+    } else if (nodeIndicators.includes(name)) {
+      runtimeBreakdown["node"] = (runtimeBreakdown["node"] || 0) + 1;
+    }
+    const majorVersion = parseInt(pkg.version.split(".")[0] || "0");
+    if (majorVersion === 0) {
+      debtScore += 2;
+    }
+    if (majorVersion < 2 && ["torch", "tensorflow", "react"].includes(name)) {
+      debtScore += 10;
+      technicalDebtReasons.push(`${pkg.name} v${pkg.version} is significantly outdated`);
+    }
+  }
+  debtScore = Math.min(100, Math.max(0, debtScore));
+  const sortedBySize = [...packages].map((p) => ({ name: p.name, sizeKb: getPackageSize2(p.name) })).sort((a, b) => b.sizeKb - a.sizeKb).slice(0, 5);
+  const updateFrequency = totalPackages > 50 ? "frequent" : totalPackages > 20 ? "regular" : "rare";
+  return {
+    totalPackages,
+    totalSizeKb,
+    runtimeBreakdown,
+    categoryBreakdown,
+    largestPackages: sortedBySize,
+    updateFrequency,
+    technicalDebtScore: debtScore,
+    technicalDebtReasons
+  };
+}
+function buildTimeline(snapshots) {
+  const sorted = [...snapshots].sort(
+    (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+  );
+  const timelineEntries = sorted.map((s) => ({
+    id: s.id,
+    date: new Date(s.createdAt),
+    packageCount: s.packages.length,
+    description: s.description,
+    changeType: determineChangeType(s.description)
+  }));
+  const now = /* @__PURE__ */ new Date();
+  const oneWeekAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1e3);
+  const recentChanges = timelineEntries.filter((t) => t.date > oneWeekAgo);
+  const packageChanges = /* @__PURE__ */ new Map();
+  for (let i = 0; i < sorted.length - 1; i++) {
+    const currentSnapshot = sorted[i];
+    const previousSnapshot = sorted[i + 1];
+    if (!currentSnapshot || !previousSnapshot) continue;
+    const current = new Set(currentSnapshot.packages.map((p) => p.name));
+    const previous = new Set(previousSnapshot.packages.map((p) => p.name));
+    for (const pkg of current) {
+      if (!previous.has(pkg)) {
+        packageChanges.set(pkg, (packageChanges.get(pkg) || 0) + 1);
+      }
+    }
+  }
+  const mostChanged = [...packageChanges.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([name]) => name);
+  return {
+    snapshots: timelineEntries,
+    averageChangesPerWeek: recentChanges.length,
+    lastChange: timelineEntries[0]?.date,
+    mostFrequentlyChanged: mostChanged
+  };
+}
+function determineChangeType(description) {
+  const lower = description.toLowerCase();
+  if (lower.includes("rollback") || lower.includes("revert")) return "rollback";
+  if (lower.includes("remove") || lower.includes("uninstall")) return "remove";
+  if (lower.includes("update") || lower.includes("upgrade")) return "update";
+  return "install";
+}
+function formatInsights(insights, colorize = true) {
+  const colors = {
+    reset: colorize ? "\x1B[0m" : "",
+    bold: colorize ? "\x1B[1m" : "",
+    dim: colorize ? "\x1B[2m" : "",
+    cyan: colorize ? "\x1B[36m" : "",
+    green: colorize ? "\x1B[32m" : "",
+    yellow: colorize ? "\x1B[33m" : "",
+    red: colorize ? "\x1B[31m" : "",
+    blue: colorize ? "\x1B[34m" : ""
+  };
+  const lines = [];
+  function formatSize(kb) {
+    if (kb >= 1e6) return `${(kb / 1e6).toFixed(1)}GB`;
+    if (kb >= 1e3) return `${(kb / 1e3).toFixed(1)}MB`;
+    return `${kb}KB`;
+  }
+  lines.push(`${colors.bold}Environment Analytics${colors.reset}`);
+  lines.push("");
+  lines.push(`${colors.bold}Overview${colors.reset}`);
+  lines.push(`  Packages: ${colors.cyan}${insights.stats.totalPackages}${colors.reset}`);
+  lines.push(`  Total Size: ${colors.cyan}${formatSize(insights.stats.totalSizeKb)}${colors.reset}`);
+  const debtColor = insights.stats.technicalDebtScore < 30 ? colors.green : insights.stats.technicalDebtScore < 60 ? colors.yellow : colors.red;
+  lines.push(`  Technical Debt: ${debtColor}${insights.stats.technicalDebtScore}/100${colors.reset}`);
+  lines.push("");
+  if (Object.keys(insights.stats.categoryBreakdown).length > 0) {
+    lines.push(`${colors.bold}Categories${colors.reset}`);
+    const sortedCategories = Object.entries(insights.stats.categoryBreakdown).sort((a, b) => b[1] - a[1]);
+    for (const [category, count] of sortedCategories) {
+      const bar = "\u2588".repeat(Math.min(20, Math.ceil(count / insights.stats.totalPackages * 40)));
+      lines.push(`  ${category.padEnd(15)} ${colors.cyan}${bar}${colors.reset} ${count}`);
+    }
+    lines.push("");
+  }
+  if (insights.stats.largestPackages.length > 0) {
+    lines.push(`${colors.bold}Largest Packages${colors.reset}`);
+    for (const pkg of insights.stats.largestPackages) {
+      lines.push(`  ${pkg.name.padEnd(20)} ${colors.dim}${formatSize(pkg.sizeKb)}${colors.reset}`);
+    }
+    lines.push("");
+  }
+  if (insights.timeline) {
+    lines.push(`${colors.bold}Activity${colors.reset}`);
+    lines.push(`  Changes this week: ${insights.timeline.averageChangesPerWeek}`);
+    if (insights.timeline.lastChange) {
+      lines.push(`  Last change: ${insights.timeline.lastChange.toLocaleDateString()}`);
+    }
+    if (insights.timeline.mostFrequentlyChanged.length > 0) {
+      lines.push(`  Most changed: ${insights.timeline.mostFrequentlyChanged.join(", ")}`);
+    }
+    lines.push("");
+  }
+  if (insights.achievements.length > 0) {
+    lines.push(`${colors.green}${colors.bold}Achievements${colors.reset}`);
+    for (const achievement of insights.achievements) {
+      lines.push(`  ${colors.green}\u2605${colors.reset} ${achievement}`);
+    }
+    lines.push("");
+  }
+  if (insights.warnings.length > 0) {
+    lines.push(`${colors.yellow}${colors.bold}Warnings${colors.reset}`);
+    for (const warning of insights.warnings) {
+      lines.push(`  ${colors.yellow}\u26A0${colors.reset} ${warning}`);
+    }
+    lines.push("");
+  }
+  if (insights.recommendations.length > 0) {
+    lines.push(`${colors.bold}Recommendations${colors.reset}`);
+    for (const rec of insights.recommendations) {
+      lines.push(`  ${colors.cyan}\u2192${colors.reset} ${rec}`);
+    }
+  }
+  return lines.join("\n");
+}
+async function diagnoseEnvironment(path, runtime, onProgress) {
+  const id = randomUUID4();
+  const problems = [];
+  let detectedRuntime = null;
+  onProgress?.("Scanning environment...");
+  if (!runtime) {
+    if (existsSync5(join6(path, ".venv")) || existsSync5(join6(path, "requirements.txt"))) {
+      detectedRuntime = "python";
+    } else if (existsSync5(join6(path, "node_modules")) || existsSync5(join6(path, "package.json"))) {
+      detectedRuntime = "node";
+    }
+  } else {
+    detectedRuntime = runtime;
+  }
+  if (!detectedRuntime) {
+    problems.push({
+      id: randomUUID4(),
+      severity: "critical",
+      category: "missing-env",
+      title: "No environment detected",
+      friendlyTitle: "No project setup found",
+      description: "Could not detect a Python or Node.js environment",
+      technicalDetail: "No .venv, node_modules, requirements.txt, or package.json found"
+    });
+    return {
+      id,
+      timestamp: /* @__PURE__ */ new Date(),
+      runtime: "python",
+      // default fallback
+      status: "missing",
+      problems,
+      repairPlan: [],
+      estimatedTime: "Unknown",
+      confidence: 0
+    };
+  }
+  onProgress?.(`Checking ${detectedRuntime} environment...`);
+  const envExists = await checkEnvironmentExists(path, detectedRuntime, problems);
+  if (envExists) {
+    await checkRuntimeFunctional(path, detectedRuntime, problems, onProgress);
+  }
+  if (envExists) {
+    await checkDependencyConflicts(path, detectedRuntime, problems, onProgress);
+  }
+  if (envExists) {
+    await checkLockfileDrift(path, detectedRuntime, problems, onProgress);
+  }
+  if (envExists) {
+    await checkKnownConflicts(path, detectedRuntime, problems, onProgress);
+  }
+  const hasSnapshot = await checkSnapshotAvailable(path, onProgress);
+  const criticalCount = problems.filter((p) => p.severity === "critical").length;
+  const warningCount = problems.filter((p) => p.severity === "warning").length;
+  let status;
+  if (criticalCount > 0) {
+    status = "broken";
+  } else if (warningCount > 0) {
+    status = "degraded";
+  } else if (problems.length === 0) {
+    status = "healthy";
+  } else {
+    status = "degraded";
+  }
+  const repairPlan = createRepairPlan({
+    id,
+    timestamp: /* @__PURE__ */ new Date(),
+    runtime: detectedRuntime,
+    status,
+    problems,
+    repairPlan: [],
+    estimatedTime: "",
+    confidence: 0
+  });
+  const estimatedTime = estimateRepairTime(repairPlan);
+  const confidence = calculateConfidence(problems, hasSnapshot);
+  return {
+    id,
+    timestamp: /* @__PURE__ */ new Date(),
+    runtime: detectedRuntime,
+    status,
+    problems,
+    repairPlan,
+    estimatedTime,
+    confidence
+  };
+}
+function createRepairPlan(diagnosis) {
+  const steps = [];
+  let order = 1;
+  const missingEnv = diagnosis.problems.find((p) => p.category === "missing-env");
+  if (missingEnv) {
+    steps.push({
+      id: randomUUID4(),
+      order: order++,
+      action: "recreate-venv",
+      description: `Create new ${diagnosis.runtime} virtual environment`,
+      friendlyDescription: "Setting up your project from scratch...",
+      automated: true,
+      risk: "safe"
+    });
+    return steps;
+  }
+  const corruptVenv = diagnosis.problems.find((p) => p.category === "corrupt-venv");
+  if (corruptVenv) {
+    steps.push({
+      id: randomUUID4(),
+      order: order++,
+      action: "recreate-venv",
+      description: `Recreate corrupted ${diagnosis.runtime} environment`,
+      friendlyDescription: "Rebuilding your project setup...",
+      automated: true,
+      risk: "moderate"
+    });
+    return steps;
+  }
+  const hasSnapshotProblem = diagnosis.problems.some(
+    (p) => p.category === "broken-deps" || p.category === "version-conflict"
+  );
+  if (hasSnapshotProblem) {
+    steps.push({
+      id: randomUUID4(),
+      order: order++,
+      action: "restore-snapshot",
+      description: "Restore from last known working state",
+      friendlyDescription: "Going back to when things were working...",
+      automated: true,
+      risk: "safe"
+    });
+  }
+  const versionConflicts = diagnosis.problems.filter(
+    (p) => p.category === "version-conflict"
+  );
+  for (const conflict of versionConflicts) {
+    steps.push({
+      id: randomUUID4(),
+      order: order++,
+      action: "resolve-conflicts",
+      description: conflict.description,
+      friendlyDescription: "Fixing incompatible package versions...",
+      automated: true,
+      risk: "moderate"
+    });
+  }
+  const staleLockfile = diagnosis.problems.find((p) => p.category === "stale-lockfile");
+  if (staleLockfile) {
+    steps.push({
+      id: randomUUID4(),
+      order: order++,
+      action: "reinstall-deps",
+      description: "Reinstall packages from lockfile",
+      friendlyDescription: "Updating your packages...",
+      automated: true,
+      risk: "safe"
+    });
+  }
+  return steps;
+}
+async function executeRepair(path, diagnosis, options) {
+  const { autoBackup = true, dryRun = false, onProgress } = options || {};
+  const { repairPlan, runtime } = diagnosis;
+  if (repairPlan.length === 0) {
+    return {
+      success: true,
+      stepsCompleted: 0,
+      stepsTotal: 0,
+      problemsFixed: [],
+      problemsRemaining: []
+    };
+  }
+  let snapshotId;
+  const problemsFixed = [];
+  const problemsRemaining = [];
+  let stepsCompleted = 0;
+  if (autoBackup && !dryRun) {
+    try {
+      const state = await loadState(path);
+      if (state.activeEnvironmentId) {
+        const env = state.environments.find((e) => e.id === state.activeEnvironmentId);
+        if (env) {
+          const snapshot = await createSnapshot(
+            path,
+            env,
+            "Pre-repair backup"
+          );
+          snapshotId = snapshot.id;
+        }
+      }
+    } catch {
+    }
+  }
+  for (const step of repairPlan) {
+    if (dryRun) {
+      onProgress?.(step, "starting");
+      onProgress?.(step, "complete");
+      stepsCompleted++;
+      continue;
+    }
+    try {
+      onProgress?.(step, "starting");
+      switch (step.action) {
+        case "recreate-venv":
+          await recreateEnvironment(path, runtime);
+          problemsFixed.push("Recreated environment");
+          break;
+        case "restore-snapshot":
+          await restoreFromSnapshot(path, runtime);
+          problemsFixed.push("Restored from backup");
+          break;
+        case "reinstall-deps":
+          await reinstallDependencies(path, runtime);
+          problemsFixed.push("Reinstalled dependencies");
+          break;
+        case "resolve-conflicts":
+          await resolveConflicts2(path, runtime);
+          problemsFixed.push("Resolved conflicts");
+          break;
+        default:
+          break;
+      }
+      onProgress?.(step, "complete");
+      stepsCompleted++;
+    } catch (error) {
+      onProgress?.(step, "failed");
+      problemsRemaining.push(
+        error instanceof Error ? error.message : "Unknown error"
+      );
+    }
+  }
+  return {
+    success: stepsCompleted === repairPlan.length,
+    stepsCompleted,
+    stepsTotal: repairPlan.length,
+    snapshotId,
+    problemsFixed,
+    problemsRemaining
+  };
+}
+async function checkEnvironmentExists(path, runtime, problems) {
+  if (runtime === "python") {
+    const venvPath = join6(path, ".venv");
+    if (!existsSync5(venvPath)) {
+      problems.push({
+        id: randomUUID4(),
+        severity: "critical",
+        category: "missing-env",
+        title: "Virtual environment missing",
+        friendlyTitle: "Project setup is missing",
+        description: "No .venv directory found",
+        technicalDetail: `Expected ${venvPath} to exist`
+      });
+      return false;
+    }
+  } else {
+    const nodeModulesPath = join6(path, "node_modules");
+    if (!existsSync5(nodeModulesPath)) {
+      problems.push({
+        id: randomUUID4(),
+        severity: "critical",
+        category: "missing-env",
+        title: "node_modules missing",
+        friendlyTitle: "Dependencies not installed",
+        description: "No node_modules directory found",
+        technicalDetail: `Expected ${nodeModulesPath} to exist`
+      });
+      return false;
+    }
+  }
+  return true;
+}
+async function checkRuntimeFunctional(path, runtime, problems, onProgress) {
+  onProgress?.("Checking if runtime is functional...");
+  try {
+    if (runtime === "python") {
+      const pythonPath = join6(path, ".venv", "bin", "python");
+      await execa4(pythonPath, ["--version"], { cwd: path });
+    } else {
+      await execa4("node", ["--version"], { cwd: path });
+    }
+  } catch {
+    problems.push({
+      id: randomUUID4(),
+      severity: "critical",
+      category: "corrupt-venv",
+      title: `${runtime} runtime not functional`,
+      friendlyTitle: "Something is broken",
+      description: `Cannot invoke ${runtime} from environment`,
+      technicalDetail: runtime === "python" ? "Python executable in .venv/bin/python is not working" : "Node.js is not accessible"
+    });
+  }
+}
+async function checkDependencyConflicts(path, runtime, problems, onProgress) {
+  onProgress?.("Checking for dependency conflicts...");
+  try {
+    if (runtime === "python") {
+      const pipPath = join6(path, ".venv", "bin", "pip");
+      const result = await execa4(pipPath, ["check"], { cwd: path, reject: false });
+      if (result.exitCode !== 0 && result.stdout) {
+        const lines = result.stdout.split("\n").filter((l) => l.trim());
+        for (const line of lines) {
+          if (line.includes("requires") || line.includes("incompatible")) {
+            problems.push({
+              id: randomUUID4(),
+              severity: "critical",
+              category: "broken-deps",
+              title: "Dependency conflict detected",
+              friendlyTitle: "Packages don't work together",
+              description: line,
+              technicalDetail: "pip check failed"
+            });
+          }
+        }
+      }
+    } else {
+      const result = await execa4("npm", ["ls", "--json"], {
+        cwd: path,
+        reject: false
+      });
+      if (result.stdout) {
+        try {
+          const output = JSON.parse(result.stdout);
+          if (output.problems && output.problems.length > 0) {
+            for (const problem of output.problems) {
+              problems.push({
+                id: randomUUID4(),
+                severity: "warning",
+                category: "broken-deps",
+                title: "Dependency issue detected",
+                friendlyTitle: "Package issue found",
+                description: String(problem),
+                technicalDetail: "npm ls reported issues"
+              });
+            }
+          }
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+}
+async function checkLockfileDrift(path, runtime, problems, onProgress) {
+  onProgress?.("Checking lockfile consistency...");
+  try {
+    if (runtime === "python") {
+      const lockfilePath = join6(path, "requirements.lock");
+      if (existsSync5(lockfilePath)) {
+        const installed = await getInstalledPackages(path, runtime);
+        if (installed.length === 0) {
+          problems.push({
+            id: randomUUID4(),
+            severity: "warning",
+            category: "stale-lockfile",
+            title: "Lockfile exists but no packages installed",
+            friendlyTitle: "Packages need to be installed",
+            description: "requirements.lock exists but environment is empty"
+          });
+        }
+      }
+    } else {
+      const lockfilePath = join6(path, "package-lock.json");
+      if (existsSync5(lockfilePath)) {
+        const nodeModulesPath = join6(path, "node_modules");
+        if (!existsSync5(nodeModulesPath)) {
+          problems.push({
+            id: randomUUID4(),
+            severity: "warning",
+            category: "stale-lockfile",
+            title: "Lockfile exists but node_modules missing",
+            friendlyTitle: "Dependencies need installation",
+            description: "package-lock.json exists but node_modules is missing"
+          });
+        }
+      }
+    }
+  } catch {
+  }
+}
+async function checkKnownConflicts(path, runtime, problems, onProgress) {
+  onProgress?.("Checking for known conflicts...");
+  try {
+    const installed = await getInstalledPackages(path, runtime);
+    const conflicts = detectConflicts(installed);
+    for (const conflict of conflicts) {
+      const severity = conflict.severity === "error" ? "critical" : conflict.severity;
+      problems.push({
+        id: randomUUID4(),
+        severity,
+        category: "version-conflict",
+        title: `${conflict.package1} conflicts with ${conflict.package2}`,
+        friendlyTitle: "Incompatible packages detected",
+        description: conflict.reason,
+        technicalDetail: conflict.suggestion
+      });
+    }
+  } catch {
+  }
+}
+async function checkSnapshotAvailable(path, onProgress) {
+  onProgress?.("Checking for backups...");
+  try {
+    const state = await loadState(path);
+    if (state.activeEnvironmentId) {
+      const snapshot = await getLatestSnapshot(path, state.activeEnvironmentId);
+      return snapshot !== null;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+async function recreateEnvironment(path, runtime) {
+  if (runtime === "python") {
+    const venvPath = join6(path, ".venv");
+    if (existsSync5(venvPath)) {
+      await execa4("rm", ["-rf", venvPath], { cwd: path });
+    }
+    await execa4("python3", ["-m", "venv", ".venv"], { cwd: path });
+  } else {
+    await execa4("npm", ["install"], { cwd: path });
+  }
+}
+async function restoreFromSnapshot(path, runtime) {
+  const state = await loadState(path);
+  if (!state.activeEnvironmentId) {
+    throw new Error("No active environment found");
+  }
+  const snapshot = await getLatestSnapshot(path, state.activeEnvironmentId);
+  if (!snapshot) {
+    throw new Error("No snapshot available");
+  }
+  if (runtime === "python") {
+    await restorePythonEnvironment(path, snapshot.lockfileContent);
+  } else {
+    await restoreNodeEnvironment(path, snapshot.lockfileContent);
+  }
+}
+async function reinstallDependencies(path, runtime) {
+  if (runtime === "python") {
+    const lockfilePath = join6(path, "requirements.lock");
+    if (existsSync5(lockfilePath)) {
+      const pipPath = join6(path, ".venv", "bin", "pip");
+      await execa4(pipPath, ["install", "-r", "requirements.lock"], { cwd: path });
+    }
+  } else {
+    await execa4("npm", ["ci"], { cwd: path });
+  }
+}
+async function resolveConflicts2(path, runtime) {
+  await reinstallDependencies(path, runtime);
+}
+function estimateRepairTime(steps) {
+  if (steps.length === 0) return "None needed";
+  if (steps.length === 1) return "~1 minute";
+  if (steps.length <= 3) return "~2 minutes";
+  return "~5 minutes";
+}
+function calculateConfidence(problems, hasSnapshot) {
+  if (problems.length === 0) return 1;
+  const criticalCount = problems.filter((p) => p.severity === "critical").length;
+  if (criticalCount > 2) return hasSnapshot ? 0.7 : 0.5;
+  if (criticalCount > 0) return hasSnapshot ? 0.85 : 0.7;
+  return 0.9;
+}
+
+export {
+  __require,
+  __commonJS,
+  __toESM,
+  loadState,
+  KomodoChat,
+  getInstalledPackages,
+  detectConflicts,
+  analyzeHealth,
+  detectRealConflicts,
+  resolveConflicts,
+  Komodo,
+  runDoctor,
+  formatDoctorReport,
+  buildDependencyTree,
+  visualizeTree,
+  diffPackages,
+  formatDiff,
+  analyzeOptimizations,
+  formatOptimizationReport,
+  generateOptimizationScript,
+  TEMPLATES,
+  getTemplateById,
+  searchTemplates,
+  formatTemplateList,
+  getInstallCommandsForTemplate,
+  explainPackage,
+  formatExplanation,
+  parseGitHubUrl,
+  analyzeRepoStructure,
+  formatRepoAnalysis,
+  analyzeEnvironment,
+  formatInsights,
+  diagnoseEnvironment,
+  executeRepair
 };