@xaidenlabs/uso 1.1.81 → 1.1.83

package/README.md

@@ -10,6 +10,7 @@ USO is a zero-friction CLI toolchain that installs, manages, and runs your entir
 
 - [Installation](#installation)
 - [Quick Start](#quick-start)
+- [AI Agent (New)](#ai-agent-new)
 - [Stealth WSL Mode (Windows)](#stealth-wsl-mode-windows)
 - [Full Environment Setup](#full-environment-setup)
 - [Granular Installation](#granular-installation)
@@ -66,6 +67,48 @@ uso dev
 
 ---
 
+## AI Agent (New)
+
+USO isn't just a command runner — it's an **Autonomous AI Agent** that can write code, build programs, debug errors, and deploy. Powered by ReAct (Reason + Act) architecture, the agent thinks step-by-step and uses tools to accomplish your goals.
+
+### 1. Configure an LLM Provider
+
+The agent needs an LLM to think. It supports four providers out of the box:
+
+```bash
+# Option A: Local & Free (Ollama)
+# Install from ollama.com, then run:
+ollama pull llama3.1:8b
+
+# Option B: GitHub Models (Free with GitHub Account)
+uso agent-config --github-token <your-github-pat>
+
+# Option C: Gemini
+uso agent-config --gemini-key <your-api-key>
+
+# Option D: OpenAI
+uso agent-config --openai-key <your-api-key>
+```
+
+### 2. Give it a Goal
+
+Just tell the agent what you want to do. It will check your environment, plan a strategy, execute the commands, and automatically self-heal if any step fails.
+
+```bash
+# General environment fixing
+uso agent "Check my Solana development environment and fix any missing tools"
+
+# Build and test cycle
+uso agent "Build my program and run the tests. If tests fail, fix the errors."
+
+# Deployment
+uso agent "Deploy my staking program to devnet and airdrop SOL if I don't have enough."
+```
+
+The agent runs a continuous FSM loop (`plan` → `execute` → `validate` → `heal`), streaming its thoughts and actions directly to your terminal.
+
+---
+
 ## Stealth WSL Mode (Windows Only)
 
 **The recommended mode for Windows developers.** Stealth Mode deploys a hidden WSL2 Linux environment (the "Uso Engine") that runs all your tooling inside Linux while you stay in PowerShell.
@@ -397,6 +440,8 @@ npm uninstall -g @xaidenlabs/uso
 | `uso init rust` | `uso install rust` | Install Rust only |
 | `uso init solana` | `uso install solana` | Install Solana CLI only |
 | `uso init anchor` | `uso install anchor` | Install Anchor Framework only |
+| `uso agent <goal>` | — | Run the Autonomous AI Agent |
+| `uso agent-config` | — | Configure Agent LLM providers |
 | `uso doctor` | — | Diagnose environment |
 | `uso verify` | — | End-to-end verification build |
 | `uso create <name>` | — | Scaffold a new Anchor project |

package/bin/index.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 const { program } = require('commander');
 const { init } = require('../src/commands/init');
 const { doctor } = require('../src/commands/doctor');
@@ -6,6 +6,7 @@ const { verify } = require('../src/commands/verify');
 const { create } = require('../src/commands/create');
 const { build, test, deploy, clean, unblock, airdrop, address, balance, validator, dev } = require('../src/commands/workflow');
 const { uninstall } = require('../src/commands/uninstall');
+const { agent, agentConfig } = require('../src/commands/agent');
 
 program
     .name('uso')
@@ -101,4 +102,21 @@ program
     .description('Uninstall uso components (rust, solana, anchor) or all')
     .action(uninstall);
 
+program
+    .command('agent [goal...]')
+    .description('Start the AI Agent to accomplish a goal autonomously')
+    .option('--model <model>', 'LLM model to use (e.g., llama3.1:8b, gemini-2.0-flash, openai/gpt-4o)')
+    .option('--provider <provider>', 'Force a specific LLM provider (ollama, gemini, openai, github)')
+    .option('--max-loops <n>', 'Maximum reasoning iterations', '3')
+    .option('--verbose', 'Show full reasoning traces')
+    .action(agent);
+
+program
+    .command('agent-config')
+    .description('Configure API keys and preferences for the AI Agent')
+    .option('--gemini-key <key>', 'Set Gemini API key')
+    .option('--openai-key <key>', 'Set OpenAI API key')
+    .option('--github-token <token>', 'Set GitHub Models PAT token')
+    .action(agentConfig);
+
 program.parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xaidenlabs/uso",
-  "version": "1.1.81",
+  "version": "1.1.83",
   "description": "Universal Solana Development Toolchain. Native or Stealth WSL Mode. Build, test, and deploy without the friction.",
   "bin": {
     "uso": "bin/index.js"

package/src/commands/agent.js

@@ -0,0 +1,295 @@
+const os = require("os");
+const path = require("path");
+const chalk = require("chalk");
+const { log, spinner } = require("../utils/logger");
+
+/**
+ * `uso agent "<goal>"` — Run the AI Agent to accomplish a goal.
+ *
+ * This command handler:
+ *   1. Loads agent config from ~/.uso-agent.json
+ *   2. Resolves an LLM provider (Ollama → GitHub → Gemini → OpenAI)
+ *   3. Runs the ReAct FSM loop
+ *   4. Streams reasoning + actions to the terminal with styled output
+ */
+const agent = async (goalParts, options) => {
+  // Commander passes args differently depending on definition
+  const goalArray = Array.isArray(goalParts) ? goalParts : [goalParts];
+  const goal = goalArray.filter(Boolean).join(" ").trim();
+
+  if (!goal) {
+    log.error("❌ No goal provided.");
+    log.info('Usage: uso agent "Deploy my staking program to devnet"');
+    log.info('       uso agent "Check my environment and fix any issues"');
+    log.info('       uso agent "Build and test my program"');
+    return;
+  }
+
+  // Dynamic import of uso-core (ESM from CJS)
+  let UsoAgent, loadAgentConfig;
+  try {
+    const core = require("../../packages/uso-core/dist/cjs/index.js");
+    UsoAgent = core.UsoAgent;
+    loadAgentConfig = core.loadAgentConfig;
+  } catch (err) {
+    log.error("❌ uso-core agent module not found.");
+    log.warn(
+      "Run 'cd packages/uso-core && npm run build' to compile the agent.",
+    );
+    log.warn(`Detail: ${err.message}`);
+    return;
+  }
+
+  const config = loadAgentConfig();
+
+  // Override config from CLI flags
+  if (options.model) {
+    // Try to infer provider from model name
+    if (options.model.includes("/")) {
+      // GitHub Models format: "openai/gpt-4o-mini"
+      config.github = { ...config.github, model: options.model };
+    } else if (options.model.startsWith("gemini")) {
+      config.gemini = { ...config.gemini, model: options.model };
+    } else if (
+      options.model.startsWith("gpt") ||
+      options.model.startsWith("o1") ||
+      options.model.startsWith("o3")
+    ) {
+      config.openai = { ...config.openai, model: options.model };
+    } else {
+      config.ollama = { ...config.ollama, model: options.model };
+    }
+  }
+
+  const maxLoops = parseInt(options.maxLoops || "3", 10);
+
+  // ─── Banner ────────────────────────────────────────────────
+  console.log();
+  console.log(
+    chalk.bold.cyan("  ┌─────────────────────────────────────────┐"),
+  );
+  console.log(
+    chalk.bold.cyan("  │") +
+      chalk.bold.white("         USO Agent v1.0              ") +
+      chalk.bold.cyan("│"),
+  );
+  console.log(
+    chalk.bold.cyan("  │") +
+      chalk.dim("   Autonomous Solana DevOps Engine    ") +
+      chalk.bold.cyan("│"),
+  );
+  console.log(
+    chalk.bold.cyan("  └─────────────────────────────────────────┘"),
+  );
+  console.log();
+  console.log(chalk.dim("  Goal: ") + chalk.white.bold(goal));
+  console.log(chalk.dim("  Max iterations: ") + chalk.yellow(maxLoops));
+  console.log();
+
+  // ─── FSM Callbacks (render to terminal) ────────────────────
+  const callbacks = {
+    onPhaseChange: (phase, state) => {
+      const phases = {
+        planning: "🧠 Planning",
+        executing: "⚡ Executing",
+        validating: "✅ Validating",
+        healing: "🔧 Self-Healing",
+      };
+      if (phases[phase]) {
+        console.log(chalk.dim(`  ── ${phases[phase]} ──`));
+      }
+    },
+
+    onThought: (thought, state) => {
+      console.log(chalk.blue("  💭 ") + chalk.italic(thought));
+    },
+
+    onToolCall: (toolName, params, state) => {
+      const paramStr = Object.keys(params).length > 0
+        ? chalk.dim(` ${JSON.stringify(params).slice(0, 80)}`)
+        : "";
+      console.log(chalk.yellow("  🔧 ") + chalk.bold(toolName) + paramStr);
+    },
+
+    onObservation: (observation, success, state) => {
+      const lines = observation.split("\n").slice(0, 10);
+      const color = success ? chalk.green : chalk.red;
+      const icon = success ? "  ✅ " : "  ❌ ";
+
+      for (const line of lines) {
+        if (line.trim()) {
+          console.log(color(icon + line.trim().slice(0, 120)));
+        }
+      }
+      if (observation.split("\n").length > 10) {
+        console.log(chalk.dim("     ... (output truncated)"));
+      }
+    },
+
+    onIteration: (iteration, maxIterations, state) => {
+      console.log(
+        chalk.dim(`\n  ─── Iteration ${iteration}/${maxIterations} ───`),
+      );
+    },
+
+    onComplete: (summary, state) => {
+      console.log();
+      console.log(chalk.green.bold("  ✅ GOAL ACCOMPLISHED"));
+      console.log(chalk.green("  " + summary));
+      console.log();
+    },
+
+    onFailed: (reason, state) => {
+      console.log();
+      console.log(chalk.red.bold("  ❌ GOAL FAILED"));
+      console.log(chalk.red("  " + reason));
+      console.log();
+    },
+  };
+
+  // ─── Run Agent ─────────────────────────────────────────────
+  const spin = spinner("Resolving LLM provider...").start();
+
+  try {
+    const usoAgent = new UsoAgent(config);
+
+    // Resolve LLM first to show which provider is being used
+    const llmDiag = await usoAgent.diagnoseLlm();
+    const available = llmDiag.filter((d) => d.available);
+
+    if (available.length === 0) {
+      spin.fail("No LLM provider available.");
+      console.log();
+      log.error("The USO Agent needs at least one LLM to reason.");
+      console.log();
+      log.info("Options (pick any):");
+      log.info("  1. Install Ollama (free, local): https://ollama.com");
+      log.info("     Then run: ollama pull llama3.1:8b");
+      log.info(
+        "  2. uso agent-config --github-token <your-github-pat>",
+      );
+      log.info(
+        "  3. uso agent-config --gemini-key <your-api-key>",
+      );
+      log.info(
+        "  4. uso agent-config --openai-key <your-api-key>",
+      );
+      return;
+    }
+
+    spin.succeed(
+      `LLM: ${chalk.bold(available[0].name)} ${chalk.dim(`(${available.length} provider${available.length > 1 ? "s" : ""} available)`)}`,
+    );
+
+    // Run the agent
+    const result = await usoAgent.run({
+      goal,
+      provider: options.provider,
+      maxIterations: maxLoops,
+      verbose: !!options.verbose,
+      callbacks,
+    });
+
+    // ─── Summary ───────────────────────────────────────────
+    console.log(chalk.dim("  ─────────────────────────────────────────"));
+    console.log(
+      chalk.dim("  Provider: ") + chalk.white(result.llmProvider),
+    );
+    console.log(
+      chalk.dim("  Iterations: ") +
+        chalk.white(`${result.totalIterations}/${maxLoops}`),
+    );
+    console.log(
+      chalk.dim("  Duration: ") +
+        chalk.white(`${(result.durationMs / 1000).toFixed(1)}s`),
+    );
+    console.log(
+      chalk.dim("  Status: ") +
+        (result.success
+          ? chalk.green.bold("SUCCESS")
+          : chalk.red.bold("FAILED")),
+    );
+    console.log();
+
+    process.exitCode = result.success ? 0 : 1;
+  } catch (err) {
+    spin.fail("Agent failed to start.");
+    log.error(`Error: ${err.message}`);
+    process.exitCode = 1;
+  }
+};
+
+/**
+ * `uso agent-config` — Configure API keys and preferences.
+ */
+const agentConfig = async (options) => {
+  let setApiKey, loadAgentConfig, saveAgentConfig;
+  try {
+    const core = require("../../packages/uso-core/dist/cjs/index.js");
+    setApiKey = core.setApiKey;
+    loadAgentConfig = core.loadAgentConfig;
+    saveAgentConfig = core.saveAgentConfig;
+  } catch (err) {
+    log.error("❌ uso-core agent module not found.");
+    log.warn("Run 'cd packages/uso-core && npm run build' to compile.");
+    return;
+  }
+
+  // Set API keys from flags
+  if (options.geminiKey) {
+    setApiKey("gemini", options.geminiKey);
+    log.success("✅ Gemini API key saved.");
+  }
+  if (options.openaiKey) {
+    setApiKey("openai", options.openaiKey);
+    log.success("✅ OpenAI API key saved.");
+  }
+  if (options.githubToken) {
+    setApiKey("github", options.githubToken);
+    log.success("✅ GitHub Models token saved.");
+  }
+
+  // Show current config
+  if (!options.geminiKey && !options.openaiKey && !options.githubToken) {
+    const config = loadAgentConfig();
+    console.log();
+    console.log(chalk.bold("USO Agent Configuration"));
+    console.log(chalk.dim("Config file: ~/.uso-agent.json"));
+    console.log();
+    console.log(chalk.bold("LLM Providers:"));
+    console.log(
+      `  Ollama:    model=${chalk.cyan(config.ollama?.model || "llama3.1:8b")} url=${chalk.dim(config.ollama?.baseUrl || "http://localhost:11434")}`,
+    );
+    console.log(
+      `  GitHub:    model=${chalk.cyan(config.github?.model || "openai/gpt-4o-mini")} token=${config.github?.token ? chalk.green("SET") : chalk.red("NOT SET")}`,
+    );
+    console.log(
+      `  Gemini:    model=${chalk.cyan(config.gemini?.model || "gemini-2.0-flash")} key=${config.gemini?.apiKey ? chalk.green("SET") : chalk.red("NOT SET")}`,
+    );
+    console.log(
+      `  OpenAI:    model=${chalk.cyan(config.openai?.model || "gpt-4o-mini")} key=${config.openai?.apiKey ? chalk.green("SET") : chalk.red("NOT SET")}`,
+    );
+    console.log();
+    console.log(chalk.bold("Agent Settings:"));
+    console.log(
+      `  Max iterations: ${chalk.cyan(config.agent?.maxIterations || 3)}`,
+    );
+    console.log(
+      `  Confirm destructive: ${chalk.cyan(config.agent?.confirmDestructive ?? true)}`,
+    );
+    console.log();
+    console.log(chalk.dim("Set API keys:"));
+    console.log(
+      chalk.dim("  uso agent-config --gemini-key <key>"),
+    );
+    console.log(
+      chalk.dim("  uso agent-config --openai-key <key>"),
+    );
+    console.log(
+      chalk.dim("  uso agent-config --github-token <token>"),
+    );
+    console.log();
+  }
+};
+
+module.exports = { agent, agentConfig };

package/src/commands/uninstall.js

@@ -100,98 +100,6 @@ const uninstallAnchorComponents = (stealth) => {
   }
 
   log.success("Anchor removal steps completed.");
-};
-
-/**
- * Runs a command and attempts to elevate privileges if it fails with a permission error.
- */
-const runOrElevate = (
-  command,
-  description,
-  stealth = { enabled: false, distro: "Ubuntu" },
-) => {
-  if (stealth.enabled) {
-    const result = runInStealth(command, stealth, true);
-
-    if (result.code === 0) {
-      if (result.stdout) console.log(result.stdout);
-      return true;
-    }
-
-    if (result.stdout) console.log(result.stdout);
-    if (result.stderr) console.error(result.stderr);
-    log.error(`❌ Command failed in WSL: ${description}`);
-    return false;
-  }
-
-  // We run without silent:true initially to let the user see output,
-  // but detecting the error code is what matters.
-  // actually, to detect the specific string "os error 1314", we need to capture output.
-  // So we run silently first? Or we just run and if it fails, we assume it *might* be elevation if on Windows?
-  // Let's run synchronously and capture output.
-
-  const result = shell.exec(command, { silent: true });
-
-  if (result.code === 0) {
-    console.log(result.stdout);
-    return true;
-  }
-
-  // Print the error output to the user
-  console.log(result.stdout);
-  console.error(result.stderr);
-
-  const output = result.stderr + result.stdout;
-
-  // Check for common permission errors
-  // "os error 1314" is specific to Windows symlink privilege
-  if (
-    (output.includes("os error 1314") ||
-      output.includes("EPERM") ||
-      output.includes("permission denied")) &&
-    os.platform() === "win32"
-  ) {
-    log.warn(`⚠️  Permission denied during: ${description}`);
-    log.info("🛡️  Triggering Run as Administrator (UAC) to retry...");
-
-    // Construct PowerShell command to run cmd /c <command> as admin
-    // We need to be careful with quoting.
-    const escapedCommand = command.replace(/'/g, "''"); // Basic PowerShell escaping for single quotes
-    const elevateCmd = `powershell -Command "Start-Process -FilePath 'cmd.exe' -ArgumentList '/c ${escapedCommand}' -Verb RunAs -Wait"`;
-
-    const elevatedRun = shell.exec(elevateCmd);
-
-    if (elevatedRun.code === 0) {
-      log.success(`✅ ${description} completed (Elevated).`);
-      return true;
-    } else {
-      log.error(`❌ Elevated execution failed for: ${description}`);
-      return false;
-    }
-  }
-
-  log.error(`❌ Command failed: ${description}`);
-  return false;
-};
-
-const uninstall = async (component) => {
-  const stealth = getStealthContext();
-  log.header("🗑️  USO Uninstallation & Cleanup");
-  if (stealth.enabled) {
-    log.info(
-      `🐧 Stealth Mode detected. Uninstall targets WSL distro: ${stealth.distro}`,
-    );
-  }
-
-  if (component) {
-    component = component.toLowerCase();
-    log.info(`🎯 Targeted uninstallation: ${component}`);
-
-    if (component === "anchor") {
-      const anchorInstalled = commandExists("anchor", stealth);
-      if (anchorInstalled) {
-        log.info("Removing Anchor...");
-        uninstallAnchorComponents(stealth);
       } else {
         log.success("✅ Anchor is not installed.");
       }
@@ -362,6 +270,7 @@ const uninstall = async (component) => {
     }
   }
 
+<<<<<<< HEAD
   // 3.5 Remove WSL Distro (if stealth mode is active)
   if (stealth.enabled && os.platform() === "win32") {
     const removeWslDistro = await askQuestion(
@@ -391,6 +300,8 @@ const uninstall = async (component) => {
     }
   }
 
+=======
+>>>>>>> d47ca156cb2a252419c54c520c7fcd0f0c18c525
   // 4. WALLET REMOVAL (DANGER)
   const walletPath = path.join(os.homedir(), ".config", "solana", "id.json");
   const wslWalletPath = "$HOME/.config/solana/id.json";

package/src/platforms/wsl.js

@@ -41,74 +41,6 @@ run_with_progress() {
 }
 `.replace(/\r\n/g, "\n");
 
-/**
- * Installs the WSL Windows Feature via an elevated PowerShell UAC prompt.
- * This is needed when `wsl.exe` is not present on the system at all.
- * Returns true if WSL is now available after the attempt, false otherwise.
- */
-const installWslFeature = async () => {
-  log.warn(
-    "⚠️  WSL (Windows Subsystem for Linux) is not installed on this machine.",
-  );
-  log.info("🛡️  Administrator permission is required to install WSL.");
-  log.info(
-    "👉 A UAC (User Account Control) popup will appear — please click 'Yes' to allow the installation.",
-  );
-  console.log("");
-
-  // Run `wsl --install --no-distribution` elevated.
-  // --no-distribution: only enables the WSL feature, does not pull a distro yet.
-  // We wait for it to finish (-Wait) so we can check the result.
-  const elevateCmd = `powershell -Command "Start-Process -FilePath 'wsl.exe' -ArgumentList '--install', '--no-distribution' -Verb RunAs -Wait"`;
-  const result = shell.exec(elevateCmd, { silent: false });
-
-  if (result.code !== 0) {
-    // User likely denied UAC or the command failed
-    log.error("❌ WSL installation was cancelled or failed.");
-    log.warn(
-      "👉 To install manually, open PowerShell as Administrator and run:",
-    );
-    console.log(chalk.bold.yellow("    wsl --install"));
-    return false;
-  }
-
-  // Verify wsl is now available
-  const check = shell.exec("wsl --status", { silent: true });
-  if (check.code !== 0) {
-    // WSL was just installed — a reboot is almost certainly required
-    log.warn(
-      "⚠️  WSL feature has been installed, but a system restart is required to complete setup.",
-    );
-    log.warn(
-      "👉 Please RESTART your computer, then run `uso install` again to set up the toolchain.",
-    );
-    return false; // Signal caller that we need a restart before proceeding
-  }
-
-  log.success("✅ WSL feature installed successfully.");
-  return true;
-};
-
-const installWsl = async () => {
-  log.header("🐧 Configuring Stealth WSL Environment...");
-
-  // 1. Check if WSL is enabled
-  if (!shell.which("wsl")) {
-    log.error("❌ WSL is not enabled on this Windows machine.");
-    log.warn(
-      "👉 Please enable 'Windows Subsystem for Linux' in 'Turn Windows features on or off'.",
-    );
-    log.warn("👉 Or run this in PowerShell as Admin: wsl --install");
-    return false;
-  }
-
-  // 2. Install Ubuntu silently (Branded as Uso Engine)
-  // We use 'wsl -d Ubuntu -e true' to check if it's installed and runnable.
-  // 'wsl -l -v' output is notoriously unreliable due to charset encoding (UTF-16) on Windows.
-  const checkDistro = shell.exec(`wsl -d ${WSL_DISTRO} -e true`, {
-    silent: true,
-  });
-
   // If exit code is 0, it's installed and working.
   if (checkDistro.code !== 0) {
     log.info(