komodo-cli 2.0.6 → 2.1.1

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

@@ -4791,7 +4791,14 @@ async function installNodePackages(envPath, packages, onProgress) {
   try {
     for (const spec of packageSpecs) {
       onProgress?.(`Installing ${spec}...`);
-      const args = packageManager === "yarn" ? ["add", spec] : ["install", spec];
+      let args;
+      if (packageManager === "yarn") {
+        args = ["add", spec];
+      } else if (packageManager === "pnpm") {
+        args = ["add", spec];
+      } else {
+        args = ["install", "--legacy-peer-deps", spec];
+      }
       await execa2(packageManager, args, { cwd: envPath });
       installedPackages.push(spec);
     }
@@ -4931,10 +4938,402 @@ async function listSnapshots(basePath, environmentId) {
   }
   return state.snapshots;
 }
+var DEFAULT_MODEL = "llama-3.3-70b";
+var DEFAULT_MAX_TOKENS = 2048;
+var DEFAULT_TEMPERATURE = 0.2;
+var CerebrasAI = class {
+  apiKey;
+  model;
+  maxTokens;
+  temperature;
+  baseUrl = "https://api.cerebras.ai/v1";
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.model = config.model ?? DEFAULT_MODEL;
+    this.maxTokens = config.maxTokens ?? DEFAULT_MAX_TOKENS;
+    this.temperature = config.temperature ?? DEFAULT_TEMPERATURE;
+  }
+  /**
+   * Make a chat completion request to Cerebras API
+   */
+  async chatCompletion(messages) {
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({
+        model: this.model,
+        messages,
+        max_tokens: this.maxTokens,
+        temperature: this.temperature,
+        top_p: 1
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Cerebras API error: ${response.status} - ${error}`);
+    }
+    const data = await response.json();
+    return data.choices[0]?.message?.content ?? "";
+  }
+  /**
+   * Analyze user intent and return comprehensive package recommendations
+   */
+  async analyzeIntent(userIntent, hardware) {
+    const systemPrompt = this.buildSystemPrompt(hardware);
+    const userPrompt = this.buildUserPrompt(userIntent, hardware);
+    const messages = [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: userPrompt }
+    ];
+    const response = await this.chatCompletion(messages);
+    return this.parseAIResponse(response);
+  }
+  /**
+   * Build comprehensive system prompt for the AI
+   */
+  buildSystemPrompt(hardware) {
+    return `You are Komodo AI, an expert software environment setup assistant. Your job is to understand what the user wants to build and recommend the exact packages and setup they need.
+
+You are knowledgeable about:
+- Python packages (PyPI): ML/AI frameworks (PyTorch, TensorFlow, JAX, transformers, langchain), web frameworks (FastAPI, Django, Flask), data science (pandas, numpy, scikit-learn), and all common Python packages
+- Node.js packages (npm): React, Vue, Next.js, Express, NestJS, and all frontend/backend JavaScript libraries
+- Hardware optimization: You know which packages work best with different GPUs (NVIDIA CUDA, AMD ROCm, Apple Metal) and CPUs
+- Version compatibility: You know which package versions work well together
+
+CRITICAL RULES:
+1. Always respond with valid JSON only - no markdown, no explanations outside the JSON
+2. Be thorough - include ALL necessary packages for a complete working setup
+3. Consider the user's hardware when recommending packages
+4. Include dev dependencies if relevant (pytest, eslint, prettier, etc.)
+5. Recommend specific versions when compatibility matters
+6. If the request is ambiguous, make reasonable assumptions and explain them
+
+USER'S HARDWARE:
+- OS: ${hardware.os}
+- Architecture: ${hardware.arch}
+- GPU: ${hardware.gpu}${hardware.gpuName ? ` (${hardware.gpuName})` : ""}${hardware.cudaVersion ? `, CUDA ${hardware.cudaVersion}` : ""}
+- RAM: ${hardware.totalMemoryGb}GB
+- CPU Cores: ${hardware.cpuCores}
+
+Based on this hardware, optimize package recommendations accordingly.`;
+  }
+  /**
+   * Build the user prompt with context
+   */
+  buildUserPrompt(intent, hardware) {
+    return `The user wants to: "${intent}"
+
+Analyze this request and respond with a JSON object in this exact format:
+{
+  "goal": "A short, clear name for what they're building (e.g., 'ML Training Pipeline', 'Next.js Blog')",
+  "description": "A brief description of the project and what it will do",
+  "runtime": "python" or "node",
+  "packages": [
+    {
+      "name": "package-name",
+      "version": "specific version or 'latest'",
+      "reason": "Why this package is needed",
+      "optional": false,
+      "alternatives": ["alternative-package"] // optional field
+    }
+  ],
+  "setupSteps": [
+    "Step 1 description",
+    "Step 2 description"
+  ],
+  "warnings": [
+    "Any warnings about compatibility, memory requirements, etc."
+  ],
+  "tips": [
+    "Helpful tips for using the setup"
+  ],
+  "confidence": 0.95
+}
+
+IMPORTANT:
+- Include ALL packages needed for a complete, working setup
+- Order packages by importance (core packages first)
+- For Python ML on Apple Silicon, use standard torch (Metal support is built-in)
+- For Python ML on NVIDIA, recommend torch with CUDA
+- For web projects, include necessary build tools and dev dependencies
+- If the request mentions specific technologies, include those
+- If the request is vague, include a sensible default stack
+
+Respond ONLY with the JSON object, nothing else.`;
+  }
+  /**
+   * Parse the AI response into structured data
+   */
+  parseAIResponse(response) {
+    let cleaned = response.trim();
+    if (cleaned.startsWith("```json")) {
+      cleaned = cleaned.slice(7);
+    } else if (cleaned.startsWith("```")) {
+      cleaned = cleaned.slice(3);
+    }
+    if (cleaned.endsWith("```")) {
+      cleaned = cleaned.slice(0, -3);
+    }
+    cleaned = cleaned.trim();
+    try {
+      const parsed = JSON.parse(cleaned);
+      return {
+        goal: parsed.goal || "Project Setup",
+        description: parsed.description || "",
+        runtime: this.normalizeRuntime(parsed.runtime),
+        packages: this.normalizePackages(parsed.packages || []),
+        setupSteps: Array.isArray(parsed.setupSteps) ? parsed.setupSteps : [],
+        warnings: Array.isArray(parsed.warnings) ? parsed.warnings : [],
+        tips: Array.isArray(parsed.tips) ? parsed.tips : [],
+        confidence: typeof parsed.confidence === "number" ? parsed.confidence : 0.8
+      };
+    } catch (error) {
+      console.error("Failed to parse AI response:", error);
+      console.error("Raw response:", response);
+      return {
+        goal: "Project Setup",
+        description: "AI analysis failed - using fallback",
+        runtime: "python",
+        packages: [],
+        setupSteps: [],
+        warnings: ["AI response parsing failed - please try again with a clearer description"],
+        tips: [],
+        confidence: 0
+      };
+    }
+  }
+  /**
+   * Normalize runtime string to valid Runtime type
+   */
+  normalizeRuntime(runtime) {
+    const lower = (runtime || "").toLowerCase();
+    if (lower === "node" || lower === "nodejs" || lower === "javascript" || lower === "js") {
+      return "node";
+    }
+    return "python";
+  }
+  /**
+   * Normalize and validate package recommendations
+   */
+  normalizePackages(packages) {
+    if (!Array.isArray(packages)) return [];
+    return packages.filter((pkg) => typeof pkg === "object" && pkg !== null).map((pkg) => ({
+      name: String(pkg["name"] || ""),
+      version: String(pkg["version"] || "latest"),
+      reason: String(pkg["reason"] || "Required dependency"),
+      optional: Boolean(pkg["optional"]),
+      alternatives: Array.isArray(pkg["alternatives"]) ? pkg["alternatives"].map(String) : void 0
+    })).filter((pkg) => pkg.name.length > 0);
+  }
+  /**
+   * Convert AI recommendations to ResolvedPackage format for Komodo
+   */
+  convertToResolvedPackages(recommendations, runtime) {
+    return recommendations.filter((pkg) => !pkg.optional).map((pkg) => ({
+      name: pkg.name,
+      version: pkg.version,
+      runtime,
+      reason: pkg.reason
+    }));
+  }
+};
+var KomodoChat = class {
+  apiKey;
+  model;
+  baseUrl = "https://api.cerebras.ai/v1";
+  conversationHistory = [];
+  context = null;
+  constructor(apiKey, model = "llama-3.3-70b") {
+    this.apiKey = apiKey;
+    this.model = model;
+  }
+  /**
+   * Set the current environment context
+   */
+  setContext(context) {
+    this.context = context;
+    this.conversationHistory = [];
+  }
+  /**
+   * Clear conversation history
+   */
+  clearHistory() {
+    this.conversationHistory = [];
+  }
+  /**
+   * Send a message and get AI response
+   */
+  async chat(userMessage) {
+    if (!this.context) {
+      return {
+        message: "No environment context set. Please run 'komodo list' or set up a project first."
+      };
+    }
+    const systemPrompt = this.buildSystemPrompt();
+    this.conversationHistory.push({
+      role: "user",
+      content: userMessage
+    });
+    const messages = [
+      { role: "system", content: systemPrompt },
+      ...this.conversationHistory
+    ];
+    try {
+      const response = await this.callAPI(messages);
+      this.conversationHistory.push({
+        role: "assistant",
+        content: response
+      });
+      return this.parseResponse(response);
+    } catch (error) {
+      return {
+        message: `Error communicating with AI: ${error instanceof Error ? error.message : "Unknown error"}`
+      };
+    }
+  }
+  /**
+   * Get a quick analysis of the current environment
+   */
+  async analyzeEnvironment() {
+    return this.chat("Analyze my current environment. What's installed, are there any issues, and what do you recommend?");
+  }
+  /**
+   * Get suggestions for what to do next
+   */
+  async getSuggestions() {
+    return this.chat("Based on what I have installed, what are some things I could build or add next?");
+  }
+  /**
+   * Ask about a specific package
+   */
+  async askAboutPackage(packageName) {
+    return this.chat(`Tell me about ${packageName}. Is it installed? Are there any issues with it? Should I update it?`);
+  }
+  /**
+   * Get help fixing conflicts
+   */
+  async getConflictHelp() {
+    return this.chat("I have some package conflicts. Can you explain what's wrong and how to fix them?");
+  }
+  buildSystemPrompt() {
+    const ctx = this.context;
+    const installedList = ctx.installedPackages.length > 0 ? ctx.installedPackages.map((p) => `  - ${p.name}@${p.version}`).join("\n") : "  (none)";
+    const conflictsList = ctx.conflicts.length > 0 ? ctx.conflicts.map((c) => `  - ${c.package1} vs ${c.package2}: ${c.reason}`).join("\n") : "  (none)";
+    const issuesList = ctx.healthIssues.length > 0 ? ctx.healthIssues.map((i) => `  - [${i.severity}] ${i.title}: ${i.description}`).join("\n") : "  (none)";
+    return `You are Komodo AI, a helpful assistant for managing software development environments. You help users understand their installed packages, resolve conflicts, and make smart decisions about their project dependencies.
+
+CURRENT ENVIRONMENT:
+- Project: ${ctx.environmentName || "Unknown"}
+- Path: ${ctx.projectPath}
+- Runtime: ${ctx.runtime || "Not set"}
+- Hardware: ${ctx.hardware.os} ${ctx.hardware.arch}, ${ctx.hardware.gpu !== "none" ? ctx.hardware.gpuName || ctx.hardware.gpu : "CPU only"}, ${ctx.hardware.totalMemoryGb}GB RAM
+
+INSTALLED PACKAGES (${ctx.installedPackages.length}):
+${installedList}
+
+CONFLICTS (${ctx.conflicts.length}):
+${conflictsList}
+
+HEALTH ISSUES (${ctx.healthIssues.length}):
+${issuesList}
+
+YOUR ROLE:
+1. Answer questions about the installed packages and environment
+2. Explain conflicts and suggest resolutions
+3. Recommend packages to add, update, or remove
+4. Provide guidance on best practices
+5. Suggest what the user could build with their current setup
+
+RESPONSE FORMAT:
+Always respond in a helpful, conversational tone. When suggesting actions, be specific about what commands to run or packages to install/remove.
+
+If you recommend installing, removing, or updating packages, include a JSON block at the end of your response in this format:
+\`\`\`json
+{
+  "actions": [
+    {"type": "install", "packages": ["package1", "package2"]},
+    {"type": "remove", "packages": ["old-package"]},
+    {"type": "update", "packages": [{"name": "pkg", "to": "2.0.0"}]}
+  ]
+}
+\`\`\`
+
+Only include the JSON block if you're recommending specific package changes.`;
+  }
+  async callAPI(messages) {
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({
+        model: this.model,
+        messages,
+        max_tokens: 2048,
+        temperature: 0.3,
+        top_p: 1
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`API error: ${response.status}`);
+    }
+    const data = await response.json();
+    return data.choices[0]?.message?.content ?? "";
+  }
+  parseResponse(response) {
+    const result = {
+      message: response
+    };
+    const jsonMatch = response.match(/```json\s*([\s\S]*?)\s*```/);
+    if (jsonMatch && jsonMatch[1]) {
+      try {
+        const actions = JSON.parse(jsonMatch[1]);
+        if (actions.actions) {
+          result.actions = actions.actions;
+          result.packages = {
+            toInstall: [],
+            toRemove: [],
+            toUpdate: []
+          };
+          for (const action of actions.actions) {
+            if (action.type === "install" && action.packages) {
+              result.packages.toInstall.push(...action.packages);
+            } else if (action.type === "remove" && action.packages) {
+              result.packages.toRemove.push(...action.packages);
+            } else if (action.type === "update" && action.packages) {
+              result.packages.toUpdate.push(...action.packages);
+            }
+          }
+        }
+        result.message = response.replace(/```json\s*[\s\S]*?\s*```/, "").trim();
+      } catch {
+      }
+    }
+    const suggestionMatch = response.match(/(?:suggestions?|recommend|could|try)[:.]?\s*\n((?:\s*[-•*]\s*.+\n?)+)/i);
+    if (suggestionMatch && suggestionMatch[1]) {
+      result.suggestions = suggestionMatch[1].split("\n").map((s) => s.replace(/^\s*[-•*]\s*/, "").trim()).filter((s) => s.length > 0);
+    }
+    return result;
+  }
+};
 var Komodo = class {
   hardware;
-  constructor() {
+  ai = null;
+  constructor(apiKey) {
     this.hardware = detectHardware();
+    if (apiKey) {
+      this.ai = new CerebrasAI({ apiKey });
+    }
+  }
+  /**
+   * Initialize or update the AI service with an API key
+   */
+  setApiKey(apiKey) {
+    this.ai = new CerebrasAI({ apiKey });
   }
   getHardware() {
     return this.hardware;
@@ -4948,13 +5347,61 @@ var Komodo = class {
   resolve(intent) {
     return resolveIntent(intent, this.hardware);
   }
+  /**
+   * Use AI to analyze intent - returns detailed recommendations
+   */
+  async analyzeWithAI(intent, apiKey) {
+    const ai = apiKey ? new CerebrasAI({ apiKey }) : this.ai;
+    if (!ai) {
+      throw new Error("AI not initialized. Provide an API key or call setApiKey() first.");
+    }
+    return ai.analyzeIntent(intent, this.hardware);
+  }
   async install(options) {
-    const { intent, path: basePath = process.cwd(), dryRun, onProgress, onExplanation, onWarning } = options;
+    const {
+      intent,
+      path: basePath = process.cwd(),
+      dryRun,
+      useAI = true,
+      apiKey,
+      onProgress,
+      onExplanation,
+      onWarning,
+      onTip
+    } = options;
     const targetPath = resolve(basePath);
-    onProgress?.("Parsing intent...");
-    const parsed = this.parseIntent(intent);
-    onProgress?.("Resolving packages for your hardware...");
-    const resolution = this.resolve(parsed);
+    let aiAnalysis;
+    let resolution;
+    const effectiveApiKey = apiKey || process.env["CEREBRAS_API_KEY"];
+    const shouldUseAI = useAI && effectiveApiKey;
+    if (shouldUseAI) {
+      try {
+        onProgress?.("Understanding what you need...");
+        const ai = new CerebrasAI({ apiKey: effectiveApiKey });
+        aiAnalysis = await ai.analyzeIntent(intent, this.hardware);
+        resolution = {
+          packages: ai.convertToResolvedPackages(aiAnalysis.packages, aiAnalysis.runtime),
+          runtime: aiAnalysis.runtime,
+          pythonVersion: aiAnalysis.runtime === "python" ? "3.11" : void 0,
+          nodeVersion: aiAnalysis.runtime === "node" ? "20" : void 0,
+          warnings: aiAnalysis.warnings,
+          explanations: [aiAnalysis.description, ...aiAnalysis.setupSteps]
+        };
+        for (const tip of aiAnalysis.tips) {
+          onTip?.(tip);
+        }
+        onProgress?.(`Setting up: ${aiAnalysis.goal}`);
+      } catch (error) {
+        onProgress?.("AI analysis unavailable, using smart templates...");
+        const parsed = this.parseIntent(intent);
+        resolution = this.resolve(parsed);
+      }
+    } else {
+      onProgress?.("Parsing intent...");
+      const parsed = this.parseIntent(intent);
+      onProgress?.("Resolving packages for your hardware...");
+      resolution = this.resolve(parsed);
+    }
     for (const explanation of resolution.explanations) {
       onExplanation?.(explanation);
     }
@@ -4966,23 +5413,26 @@ var Komodo = class {
         success: false,
         error: "Could not determine packages for this intent. Try being more specific.",
         resolution,
-        hardware: this.hardware
+        hardware: this.hardware,
+        aiAnalysis
       };
     }
     if (dryRun) {
       return {
         success: true,
         resolution,
-        hardware: this.hardware
+        hardware: this.hardware,
+        aiAnalysis
       };
     }
     if (!existsSync3(targetPath)) {
       await mkdir3(targetPath, { recursive: true });
     }
     const environmentId = randomUUID2();
+    const environmentName = aiAnalysis?.goal ?? intent.slice(0, 50);
     const environment = {
       id: environmentId,
-      name: parsed.goal,
+      name: environmentName,
       createdAt: /* @__PURE__ */ new Date(),
       runtime: resolution.runtime,
       path: targetPath,
@@ -5002,7 +5452,8 @@ var Komodo = class {
             success: false,
             error: envResult.error,
             resolution,
-            hardware: this.hardware
+            hardware: this.hardware,
+            aiAnalysis
           };
         }
         const installResult = await installPythonPackages(
@@ -5015,7 +5466,8 @@ var Komodo = class {
             success: false,
             error: installResult.error,
             resolution,
-            hardware: this.hardware
+            hardware: this.hardware,
+            aiAnalysis
           };
         }
         onProgress?.("Saving lockfile...");
@@ -5032,7 +5484,8 @@ var Komodo = class {
             success: false,
             error: envResult.error,
             resolution,
-            hardware: this.hardware
+            hardware: this.hardware,
+            aiAnalysis
           };
         }
         const installResult = await installNodePackages(
@@ -5045,7 +5498,8 @@ var Komodo = class {
             success: false,
             error: installResult.error,
             resolution,
-            hardware: this.hardware
+            hardware: this.hardware,
+            aiAnalysis
           };
         }
         onProgress?.("Saving lockfile...");
@@ -5057,19 +5511,21 @@ var Komodo = class {
       state.activeEnvironmentId = environment.id;
       await saveState(targetPath, state);
       onProgress?.("Creating snapshot for rollback...");
-      await createSnapshot(targetPath, environment, "Initial install");
+      await createSnapshot(targetPath, environment, aiAnalysis?.goal ?? "Initial install");
       return {
         success: true,
         environment,
         resolution,
-        hardware: this.hardware
+        hardware: this.hardware,
+        aiAnalysis
       };
     } catch (error) {
       return {
         success: false,
         error: error instanceof Error ? error.message : "Installation failed",
         resolution,
-        hardware: this.hardware
+        hardware: this.hardware,
+        aiAnalysis
       };
     }
   }
@@ -5253,6 +5709,7 @@ export {
   __commonJS,
   __toESM,
   loadState,
+  KomodoChat,
   Komodo,
   getInstalledPackages,
   detectConflicts,

package/dist/index.js

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
 import {
   Komodo,
+  KomodoChat,
   analyzeHealth,
   detectConflicts,
   getInstalledPackages,
   loadState
-} from "./chunk-NTFP7K7V.js";
+} from "./chunk-VHGNG7AW.js";
 
 // src/index.ts
 import { Command } from "commander";
@@ -16,7 +17,10 @@ import * as readline from "readline";
 import { createRequire } from "module";
 var require2 = createRequire(import.meta.url);
 var packageJson = require2("../package.json");
-var komodo = new Komodo();
+var DEFAULT_API_KEY = "csk-m4vcnx94p854xmvnhxx38chwmxxwtffpnymk2ewexktk3962";
+var API_KEY = process.env.CEREBRAS_API_KEY || DEFAULT_API_KEY;
+var komodo = new Komodo(API_KEY);
+var chat = new KomodoChat(API_KEY);
 var program = new Command();
 program.name("komodo").description("The simple way to set up your project").version(packageJson.version);
 var gradientColors = [
@@ -68,13 +72,90 @@ function formatGpu(hardware) {
   }
   return "CPU";
 }
+async function updateChatContext(projectPath) {
+  const hardware = komodo.getHardware();
+  const state = await loadState(projectPath);
+  let installedPackages = [];
+  let conflicts = [];
+  let healthIssues = [];
+  let runtime;
+  let environmentName;
+  if (state.activeEnvironmentId) {
+    const activeEnv = state.environments.find((e) => e.id === state.activeEnvironmentId);
+    if (activeEnv) {
+      runtime = activeEnv.runtime;
+      environmentName = activeEnv.name;
+      installedPackages = await getInstalledPackages(projectPath, activeEnv.runtime);
+      conflicts = detectConflicts(installedPackages);
+      const health = analyzeHealth(installedPackages, conflicts);
+      healthIssues = health.issues;
+    }
+  }
+  const context = {
+    hardware,
+    runtime,
+    installedPackages,
+    conflicts,
+    healthIssues,
+    projectPath,
+    environmentName
+  };
+  chat.setContext(context);
+  return { installedPackages, conflicts, healthIssues, runtime, environmentName };
+}
+function isAIQuestion(input) {
+  const lowerInput = input.toLowerCase();
+  if (input.endsWith("?")) return true;
+  const questionWords = ["what", "why", "how", "when", "where", "which", "who", "can", "could", "should", "would", "is", "are", "do", "does", "tell me", "explain", "show me", "help me"];
+  if (questionWords.some((w) => lowerInput.startsWith(w))) return true;
+  const envKeywords = ["installed", "packages", "conflicts", "issues", "problems", "wrong", "fix", "update", "upgrade", "remove", "alternatives", "suggest", "recommend", "analyze", "status"];
+  if (envKeywords.some((k) => lowerInput.includes(k))) return true;
+  return false;
+}
+function displayAIResponse(response) {
+  console.log();
+  console.log(chalk.hex("#b4ffb4")(response.message));
+  if (response.suggestions && response.suggestions.length > 0) {
+    console.log();
+    console.log(chalk.hex("#87cefa")("  Suggestions:"));
+    response.suggestions.forEach((s) => {
+      console.log(chalk.hex("#87cefa")(`    \u2022 ${s}`));
+    });
+  }
+  if (response.packages) {
+    if (response.packages.toInstall && response.packages.toInstall.length > 0) {
+      console.log();
+      console.log(chalk.hex("#5aff5a")("  Packages to install:"));
+      response.packages.toInstall.forEach((p) => {
+        console.log(chalk.hex("#5aff5a")(`    + ${p}`));
+      });
+    }
+    if (response.packages.toRemove && response.packages.toRemove.length > 0) {
+      console.log();
+      console.log(chalk.yellow("  Packages to remove:"));
+      response.packages.toRemove.forEach((p) => {
+        console.log(chalk.yellow(`    - ${p}`));
+      });
+    }
+    if (response.packages.toUpdate && response.packages.toUpdate.length > 0) {
+      console.log();
+      console.log(chalk.hex("#87cefa")("  Packages to update:"));
+      response.packages.toUpdate.forEach((p) => {
+        console.log(chalk.hex("#87cefa")(`    \u2191 ${p.name}: ${p.from} \u2192 ${p.to}`));
+      });
+    }
+  }
+  console.log();
+}
 async function startInteractiveMode(projectPath) {
   printBanner();
   const hardware = komodo.getHardware();
   console.log(chalk.hex("#b4ffb4").dim(`  ${formatOs(hardware.os)} \xB7 ${formatGpu(hardware)} \xB7 ${hardware.totalMemoryGb}GB memory`));
   console.log();
-  console.log(chalk.hex("#96ff96").dim("  Commands: ") + chalk.hex("#d2ffd2")("undo") + chalk.dim(" \xB7 ") + chalk.hex("#d2ffd2")("list") + chalk.dim(" \xB7 ") + chalk.hex("#d2ffd2")("check") + chalk.dim(" \xB7 ") + chalk.hex("#d2ffd2")("ui") + chalk.dim(" \xB7 ") + chalk.hex("#d2ffd2")("exit"));
+  console.log(chalk.hex("#96ff96").dim("  Commands: ") + chalk.hex("#d2ffd2")("undo") + chalk.dim(" \xB7 ") + chalk.hex("#d2ffd2")("list") + chalk.dim(" \xB7 ") + chalk.hex("#d2ffd2")("check") + chalk.dim(" \xB7 ") + chalk.hex("#d2ffd2")("ask") + chalk.dim(" \xB7 ") + chalk.hex("#d2ffd2")("exit"));
+  console.log(chalk.dim("  Or just ask anything in natural language!"));
   console.log();
+  await updateChatContext(projectPath);
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout
@@ -101,15 +182,18 @@ async function startInteractiveMode(projectPath) {
       }
       if (trimmed === "help" || trimmed === "?") {
         console.log();
-        console.log(chalk.hex("#a5ffa5")("  Just type what you want to build:"));
+        console.log(chalk.hex("#a5ffa5")("  Just type what you want to build or ask anything:"));
         console.log(chalk.dim('    "build a website"'));
-        console.log(chalk.dim('    "train an AI model"'));
-        console.log(chalk.dim('    "analyze some data"'));
+        console.log(chalk.dim('    "what packages are installed?"'));
+        console.log(chalk.dim('    "are there any conflicts?"'));
+        console.log(chalk.dim('    "suggest alternatives to express"'));
         console.log();
         console.log(chalk.hex("#a5ffa5")("  Commands:"));
         console.log(`    ${chalk.hex("#d2ffd2")("undo")}      Undo last change`);
         console.log(`    ${chalk.hex("#d2ffd2")("list")}      See what's installed`);
         console.log(`    ${chalk.hex("#d2ffd2")("check")}     Check for problems`);
+        console.log(`    ${chalk.hex("#d2ffd2")("ask")}       Start AI conversation`);
+        console.log(`    ${chalk.hex("#d2ffd2")("analyze")}   AI analysis of environment`);
         console.log(`    ${chalk.hex("#d2ffd2")("ui")}        Open visual dashboard`);
         console.log(`    ${chalk.hex("#d2ffd2")("history")}   See past changes`);
         console.log(`    ${chalk.hex("#d2ffd2")("clear")}     Clear screen`);
@@ -120,6 +204,7 @@ async function startInteractiveMode(projectPath) {
       }
       if (trimmed === "undo") {
         await handleUndo(projectPath);
+        await updateChatContext(projectPath);
         prompt();
         return;
       }
@@ -143,6 +228,41 @@ async function startInteractiveMode(projectPath) {
         prompt();
         return;
       }
+      if (trimmed === "analyze" || trimmed === "analyse") {
+        const spinner = ora(chalk.hex("#b4ffb4")("Analyzing your environment...")).start();
+        await updateChatContext(projectPath);
+        const response = await chat.analyzeEnvironment();
+        spinner.stop();
+        displayAIResponse(response);
+        prompt();
+        return;
+      }
+      if (trimmed === "ask" || trimmed.startsWith("ask ")) {
+        const question = trimmed === "ask" ? "" : trimmed.slice(4).trim();
+        if (!question) {
+          console.log();
+          console.log(chalk.hex("#b4ffb4")("  Ask me anything about your environment!"));
+          console.log(chalk.dim("    Example: ask what should I install for a REST API?"));
+          console.log();
+        } else {
+          const spinner = ora(chalk.hex("#b4ffb4")("Thinking...")).start();
+          await updateChatContext(projectPath);
+          const response = await chat.chat(question);
+          spinner.stop();
+          displayAIResponse(response);
+        }
+        prompt();
+        return;
+      }
+      if (isAIQuestion(trimmed)) {
+        const spinner = ora(chalk.hex("#b4ffb4")("Thinking...")).start();
+        await updateChatContext(projectPath);
+        const response = await chat.chat(trimmed);
+        spinner.stop();
+        displayAIResponse(response);
+        prompt();
+        return;
+      }
       await handleInstall(trimmed, projectPath);
       prompt();
     });
@@ -154,10 +274,13 @@ async function handleInstall(intent, projectPath) {
   console.log();
   const explanations = [];
   const warnings = [];
+  const tips = [];
   const result = await komodo.install({
     intent,
     path: projectPath,
     dryRun: false,
+    useAI: true,
+    apiKey: API_KEY,
     onProgress: (message) => {
       const friendly = friendlyMessage(message);
       if (spinner.isSpinning) {
@@ -170,6 +293,9 @@ async function handleInstall(intent, projectPath) {
     },
     onWarning: (warning) => {
       warnings.push(friendlyWarning(warning));
+    },
+    onTip: (tip) => {
+      tips.push(tip);
     }
   });
   if (spinner.isSpinning) {
@@ -177,10 +303,18 @@ async function handleInstall(intent, projectPath) {
   }
   console.log();
   if (result.success) {
+    if (result.aiAnalysis) {
+      console.log(chalk.hex("#5aff5a").bold(`  \u2713 ${result.aiAnalysis.goal}`));
+      if (result.aiAnalysis.description) {
+        console.log(chalk.dim(`    ${result.aiAnalysis.description}`));
+      }
+      console.log();
+    }
     if (result.resolution && result.resolution.packages.length > 0) {
       console.log(chalk.hex("#a5ffa5")("  Set up:"));
       result.resolution.packages.forEach((pkg) => {
-        console.log(chalk.hex("#5aff5a")(`    \u2713 ${friendlyPackageName(pkg.name)}`));
+        const reason = pkg.reason ? chalk.dim(` - ${pkg.reason}`) : "";
+        console.log(chalk.hex("#5aff5a")(`    \u2713 ${friendlyPackageName(pkg.name)}`) + reason);
       });
       console.log();
     }
@@ -191,6 +325,13 @@ async function handleInstall(intent, projectPath) {
       });
       console.log();
     }
+    if (tips.length > 0) {
+      console.log(chalk.hex("#87cefa")("  Tips:"));
+      tips.forEach((t) => {
+        console.log(chalk.hex("#87cefa")(`    \u{1F4A1} ${t}`));
+      });
+      console.log();
+    }
     if (warnings.length > 0) {
       console.log(chalk.yellow("  Heads up:"));
       warnings.forEach((w) => {
@@ -318,7 +459,7 @@ async function handleUI(projectPath) {
   console.log();
   console.log(chalk.hex("#b4ffb4").dim("  Starting dashboard..."));
   try {
-    const { startServer } = await import("./server-SEUGSMGX.js");
+    const { startServer } = await import("./server-2Z47U3WP.js");
     await startServer(projectPath, port);
     console.log(chalk.hex("#5aff5a")(`  \u2713 Dashboard ready at ${chalk.bold(url)}`));
     console.log();
@@ -350,10 +491,13 @@ program.argument("[intent]", "What you want to build").option("-p, --path <path>
   }
   const explanations = [];
   const warnings = [];
+  const tips = [];
   const result = await komodo.install({
     intent,
     path: options.path,
     dryRun: options.preview,
+    useAI: true,
+    apiKey: API_KEY,
     onProgress: (message) => {
       const friendly = friendlyMessage(message);
       if (spinner.isSpinning) {
@@ -366,6 +510,9 @@ program.argument("[intent]", "What you want to build").option("-p, --path <path>
     },
     onWarning: (warning) => {
       warnings.push(friendlyWarning(warning));
+    },
+    onTip: (tip) => {
+      tips.push(tip);
     }
   });
   if (spinner.isSpinning) {
@@ -373,10 +520,32 @@ program.argument("[intent]", "What you want to build").option("-p, --path <path>
   }
   console.log();
   if (result.success) {
+    if (result.aiAnalysis) {
+      console.log(chalk.green.bold(`  \u2713 ${result.aiAnalysis.goal}`));
+      if (result.aiAnalysis.description) {
+        console.log(chalk.dim(`    ${result.aiAnalysis.description}`));
+      }
+      console.log();
+    }
     if (result.resolution && result.resolution.packages.length > 0) {
       console.log(chalk.bold("  Set up:"));
       result.resolution.packages.forEach((pkg) => {
-        console.log(chalk.green(`    \u2713 ${friendlyPackageName(pkg.name)}`));
+        const reason = pkg.reason ? chalk.dim(` - ${pkg.reason}`) : "";
+        console.log(chalk.green(`    \u2713 ${friendlyPackageName(pkg.name)}`) + reason);
+      });
+      console.log();
+    }
+    if (result.aiAnalysis && result.aiAnalysis.setupSteps.length > 0) {
+      console.log(chalk.dim("  Next steps:"));
+      result.aiAnalysis.setupSteps.forEach((step, i) => {
+        console.log(chalk.dim(`    ${i + 1}. ${step}`));
+      });
+      console.log();
+    }
+    if (tips.length > 0) {
+      console.log(chalk.hex("#87cefa")("  Tips:"));
+      tips.forEach((t) => {
+        console.log(chalk.hex("#87cefa")(`    \u{1F4A1} ${t}`));
       });
       console.log();
     }
@@ -437,7 +606,7 @@ program.command("ui").description("Open the visual dashboard").option("-p, --pat
   const url = `http://localhost:${port}`;
   console.log(chalk.dim("  Starting dashboard..."));
   try {
-    const { startServer } = await import("./server-SEUGSMGX.js");
+    const { startServer } = await import("./server-2Z47U3WP.js");
     await startServer(options.path, port);
     console.log();
     console.log(chalk.green(`  \u2713 Dashboard ready at ${chalk.bold(url)}`));

package/dist/{server-SEUGSMGX.js → server-2Z47U3WP.js}

@@ -7,7 +7,7 @@ import {
   detectConflicts,
   getInstalledPackages,
   loadState
-} from "./chunk-NTFP7K7V.js";
+} from "./chunk-VHGNG7AW.js";
 
 // ../../node_modules/.pnpm/reusify@1.1.0/node_modules/reusify/reusify.js
 var require_reusify = __commonJS({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "komodo-cli",
-  "version": "2.0.6",
+  "version": "2.1.1",
   "description": "The simple way to set up your project. Just say what you want to build.",
   "type": "module",
   "bin": {