komodo-cli 2.2.0 → 2.3.0

package/dist/{chunk-AR6QW5FH.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,6 +5878,31 @@ var Komodo = class {
         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,
@@ -5425,10 +5911,10 @@ var Komodo = class {
         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,118 +6077,6 @@ 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"
-  }
-];
-async function getInstalledPackages(path, runtime) {
-  if (runtime === "python") {
-    return getPythonPackages(path);
-  } else {
-    return getNodePackages(path);
-  }
-}
-async function getPythonPackages(path) {
-  const venvPath = join5(path, ".venv");
-  if (!existsSync4(venvPath)) {
-    return [];
-  }
-  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 }
-      );
-      const packages = JSON.parse(result.stdout);
-      return packages.map((pkg) => ({
-        name: pkg.name,
-        version: pkg.version
-      }));
-    } catch {
-      return [];
-    }
-  }
-}
-async function getNodePackages(path) {
-  const packageJsonPath = join5(path, "package.json");
-  if (!existsSync4(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)
-  };
-}
 var KNOWN_VULNERABILITIES = {
   "torch": [
     { versions: "<1.13.0", severity: "high", description: "Arbitrary code execution via pickle deserialization", fix: ">=2.0.0" }
@@ -7818,6 +8192,469 @@ function formatInsights(insights, colorize = true) {
   }
   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,
@@ -7825,10 +8662,12 @@ export {
   __toESM,
   loadState,
   KomodoChat,
-  Komodo,
   getInstalledPackages,
   detectConflicts,
   analyzeHealth,
+  detectRealConflicts,
+  resolveConflicts,
+  Komodo,
   runDoctor,
   formatDoctorReport,
   buildDependencyTree,
@@ -7849,5 +8688,7 @@ export {
   analyzeRepoStructure,
   formatRepoAnalysis,
   analyzeEnvironment,
-  formatInsights
+  formatInsights,
+  diagnoseEnvironment,
+  executeRepair
 };