komodo-cli 2.0.6 → 2.1.0

package/dist/{chunk-NTFP7K7V.js → chunk-5HD3OG64.js}

@@ -4931,10 +4931,222 @@ 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 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 +5160,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 +5226,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 +5265,8 @@ var Komodo = class {
             success: false,
             error: envResult.error,
             resolution,
-            hardware: this.hardware
+            hardware: this.hardware,
+            aiAnalysis
           };
         }
         const installResult = await installPythonPackages(
@@ -5015,7 +5279,8 @@ var Komodo = class {
             success: false,
             error: installResult.error,
             resolution,
-            hardware: this.hardware
+            hardware: this.hardware,
+            aiAnalysis
           };
         }
         onProgress?.("Saving lockfile...");
@@ -5032,7 +5297,8 @@ var Komodo = class {
             success: false,
             error: envResult.error,
             resolution,
-            hardware: this.hardware
+            hardware: this.hardware,
+            aiAnalysis
           };
         }
         const installResult = await installNodePackages(
@@ -5045,7 +5311,8 @@ var Komodo = class {
             success: false,
             error: installResult.error,
             resolution,
-            hardware: this.hardware
+            hardware: this.hardware,
+            aiAnalysis
           };
         }
         onProgress?.("Saving lockfile...");
@@ -5057,19 +5324,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
       };
     }
   }

package/dist/index.js

@@ -5,7 +5,7 @@ import {
   detectConflicts,
   getInstalledPackages,
   loadState
-} from "./chunk-NTFP7K7V.js";
+} from "./chunk-5HD3OG64.js";
 
 // src/index.ts
 import { Command } from "commander";
@@ -16,7 +16,9 @@ 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 program = new Command();
 program.name("komodo").description("The simple way to set up your project").version(packageJson.version);
 var gradientColors = [
@@ -154,10 +156,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 +175,9 @@ async function handleInstall(intent, projectPath) {
     },
     onWarning: (warning) => {
       warnings.push(friendlyWarning(warning));
+    },
+    onTip: (tip) => {
+      tips.push(tip);
     }
   });
   if (spinner.isSpinning) {
@@ -177,10 +185,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 +207,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 +341,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-JMI7KL56.js");
     await startServer(projectPath, port);
     console.log(chalk.hex("#5aff5a")(`  \u2713 Dashboard ready at ${chalk.bold(url)}`));
     console.log();
@@ -350,10 +373,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 +392,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 +402,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 +488,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-JMI7KL56.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-JMI7KL56.js}

@@ -7,7 +7,7 @@ import {
   detectConflicts,
   getInstalledPackages,
   loadState
-} from "./chunk-NTFP7K7V.js";
+} from "./chunk-5HD3OG64.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.0",
   "description": "The simple way to set up your project. Just say what you want to build.",
   "type": "module",
   "bin": {