@cbuk100011/claude-mode 1.2.0 → 1.3.0

package/README.md

@@ -1,5 +1,7 @@
 # Claude Mode
 
+![npm version](https://img.shields.io/npm/v/%40cbuk100011%2Fclaude-mode)
+
 A Node.js CLI launcher for Claude Code that supports multiple AI providers and models.
 
 ## Features
@@ -17,12 +19,19 @@ A Node.js CLI launcher for Claude Code that supports multiple AI providers and m
 
 ## Installation
 
+### npm Package (Recommended)
+
+```bash
+# Install globally
+npm install -g @cbuk100011/claude-mode
+```
+
 ### From Source
 
 ```bash
 # Clone the repository
-git clone <repo-url>
-cd claude-mode
+git clone https://github.com/Cam10001110101/claude-mode-cli.git
+cd claude-mode-cli
 
 # Install dependencies
 npm install
@@ -30,16 +39,10 @@ npm install
 # Build
 npm run build
 
-# Link globally (optional)
+# Link globally
 npm link
 ```
 
-### Global Installation (after npm publish)
-
-```bash
-npm install -g claude-mode
-```
-
 ## Usage
 
 ### Interactive Menu
@@ -293,7 +296,7 @@ npm run typecheck
 ## Project Structure
 
 ```
-claude-mode/
+claude-mode-cli/
 ├── src/
 │   ├── index.ts      # Main CLI entry point
 │   ├── providers.ts  # Provider and model configurations

package/dist/index.js

@@ -2,12 +2,12 @@
 
 // src/index.ts
 import { Command } from "commander";
-import chalk2 from "chalk";
-import { select, input } from "@inquirer/prompts";
+import chalk3 from "chalk";
+import { select as select2, input as input2, confirm as confirm2 } from "@inquirer/prompts";
 import { spawn, execSync } from "child_process";
 import { config } from "dotenv";
 import { fileURLToPath } from "url";
-import path2 from "path";
+import path3 from "path";
 
 // src/config.ts
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
@@ -37,6 +37,7 @@ var DEFAULT_CONFIG = {
   healthCheckTimeout: 2e3,
   cacheTTL: 3e4,
   customProviders: [],
+  configuredProviders: [],
   skipHealthCheck: false,
   offlineMode: false,
   headlessAllowedTools: "Read,Edit,Write,Bash,Glob,Grep"
@@ -210,6 +211,33 @@ function claudeNotFoundError() {
     hint: "Install Claude Code CLI: npm install -g @anthropic-ai/claude-code\nOr check that it is in your PATH."
   };
 }
+function setupConfigWriteError(message, hint) {
+  return {
+    code: "SETUP_CONFIG_WRITE_FAILED" /* SETUP_CONFIG_WRITE_FAILED */,
+    message: `Failed to write config: ${message}`,
+    hint: hint || "Check file permissions and try again, or use a different config location."
+  };
+}
+function setupEnvWriteError(message, hint) {
+  return {
+    code: "SETUP_ENV_WRITE_FAILED" /* SETUP_ENV_WRITE_FAILED */,
+    message: `Failed to write .env file: ${message}`,
+    hint: hint || "Check file permissions or specify a different location."
+  };
+}
+function setupCancelledError() {
+  return {
+    code: "SETUP_CANCELLED" /* SETUP_CANCELLED */,
+    message: "Setup cancelled"
+  };
+}
+function setupIncompleteError(message) {
+  return {
+    code: "SETUP_INCOMPLETE" /* SETUP_INCOMPLETE */,
+    message,
+    hint: "Run claude-mode setup to complete configuration."
+  };
+}
 
 // src/providers.ts
 var builtInProviders = {
@@ -508,12 +536,57 @@ async function checkAllProvidersHealth() {
   return results;
 }
 
-// src/index.ts
-config();
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = path2.dirname(__filename);
-config({ path: path2.join(__dirname, "..", ".env") });
-var program = new Command();
+// src/setup.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import path2 from "path";
+import chalk2 from "chalk";
+import {
+  confirm,
+  select,
+  checkbox,
+  input,
+  password
+} from "@inquirer/prompts";
+function getConfigDir2() {
+  return path2.join(homedir2(), ".claude-mode");
+}
+function getConfigPath() {
+  return path2.join(getConfigDir2(), "claude-mode.json");
+}
+function getEnvPath(envPath) {
+  return envPath || path2.join(process.cwd(), ".env");
+}
+function detectSetupStatus() {
+  const configPath = getConfigPath();
+  const envPath = getEnvPath();
+  if (!existsSync2(configPath)) {
+    return "first-time";
+  }
+  try {
+    const config2 = loadConfig();
+    const hasDefaults = !!(config2.defaultProvider && config2.defaultModel);
+    const hasProviders = !!config2.configuredProviders && config2.configuredProviders.length > 0;
+    if (!hasDefaults || !hasProviders) {
+      return "incomplete";
+    }
+    if (config2.configuredProviders) {
+      for (const providerKey of config2.configuredProviders) {
+        const provider = getProvider(providerKey);
+        if (provider) {
+          const hasKey = !!provider.getAuthToken();
+          const needsKey = providerKey === "openrouter" || providerKey === "ollama-cloud";
+          if (needsKey && !hasKey) {
+            return "incomplete";
+          }
+        }
+      }
+    }
+    return "complete";
+  } catch {
+    return "first-time";
+  }
+}
 function printHeader(text) {
   console.log("");
   console.log(chalk2.bold.blue("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"));
@@ -521,13 +594,539 @@ function printHeader(text) {
   console.log(chalk2.bold.blue("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"));
   console.log("");
 }
+function printSection(title) {
+  console.log("");
+  console.log(chalk2.bold.cyan("\u2501\u2501\u2501 " + title + " \u2501\u2501\u2501"));
+  console.log("");
+}
+function printProviderInfo() {
+  console.log(chalk2.bold("Available Providers:"));
+  console.log("");
+  console.log("  " + chalk2.green("OpenRouter") + " - Access to Claude, GPT-5, DeepSeek, and more");
+  console.log("    " + chalk2.gray("Requires: API key"));
+  console.log("");
+  console.log("  " + chalk2.green("Ollama Local") + " - Run models locally on your machine");
+  console.log("    " + chalk2.gray("Requires: Local Ollama instance"));
+  console.log("");
+  console.log("  " + chalk2.green("Ollama Cloud") + " - Managed Ollama service");
+  console.log("    " + chalk2.gray("Requires: API key"));
+  console.log("");
+  console.log("  " + chalk2.green("Ollama Custom") + " - Connect to remote Ollama instance");
+  console.log("    " + chalk2.gray("Requires: Custom URL"));
+  console.log("");
+}
+async function displayWelcome(isFirstTime) {
+  console.clear();
+  if (isFirstTime) {
+    printHeader("Welcome to Claude Mode Setup");
+    console.log(chalk2.bold.cyan("Claude Mode") + " is a CLI launcher for Claude Code");
+    console.log("that supports multiple AI providers.");
+    console.log("");
+    console.log("This wizard will help you configure your providers");
+    console.log("and set up your default settings.");
+    console.log("");
+  } else {
+    printHeader("Claude Mode Configuration");
+    console.log("Update your configuration or add new providers.");
+    console.log("");
+  }
+  printProviderInfo();
+  const ready = await confirm({
+    message: "Ready to configure?",
+    default: true
+  });
+  if (!ready) {
+    throw setupCancelledError();
+  }
+}
+async function displayUpdatePrompt() {
+  console.clear();
+  printHeader("Configuration Found");
+  console.log("A configuration file already exists.");
+  console.log("");
+  console.log("You can:");
+  console.log("  " + chalk2.cyan("\u2022") + " Re-run full setup to reconfigure all providers");
+  console.log("  " + chalk2.cyan("\u2022") + " Configure a single provider");
+  console.log("  " + chalk2.cyan("\u2022") + " Skip and use existing configuration");
+  console.log("");
+  const action = await select({
+    message: "What would you like to do?",
+    choices: [
+      { name: "Re-run full setup", value: "full" },
+      { name: "Configure specific provider", value: "single" },
+      { name: "Skip (use existing config)", value: "skip" }
+    ]
+  });
+  return action !== "skip";
+}
+async function selectProviders(forceProvider) {
+  if (forceProvider) {
+    const provider = getProvider(forceProvider);
+    if (!provider) {
+      console.error(chalk2.red(`Unknown provider: ${forceProvider}`));
+      throw setupIncompleteError(`Provider "${forceProvider}" not found`);
+    }
+    return [forceProvider];
+  }
+  const allProviders = getProviders();
+  const choices = Object.entries(allProviders).map(([key, provider]) => ({
+    name: provider.name,
+    value: key,
+    description: provider.getDescription()
+  }));
+  const selected = await checkbox({
+    message: "Select providers to configure:",
+    choices,
+    validate: (value) => value.length > 0 ? true : "Select at least one provider"
+  });
+  return selected;
+}
+async function configureProvider(providerKey, skipValidation) {
+  const provider = getProvider(providerKey);
+  if (!provider) {
+    throw setupIncompleteError(`Provider "${providerKey}" not found`);
+  }
+  printSection(`Configuring ${provider.name}`);
+  const config2 = {
+    key: providerKey,
+    name: provider.name,
+    validated: false
+  };
+  if (providerKey === "openrouter" || providerKey === "ollama-cloud") {
+    const existingKey = provider.getAuthToken();
+    const keyMsg = existingKey ? `Enter API key (current: ${existingKey.substring(0, 8)}...)` : "Enter API key:";
+    config2.apiKey = await password({
+      message: keyMsg,
+      validate: (value) => {
+        if (existingKey && !value) return true;
+        return value.length > 0 ? true : "API key is required";
+      }
+    });
+    if (config2.apiKey) {
+      if (providerKey === "openrouter") {
+        process.env.ANTHROPIC_AUTH_TOKEN = config2.apiKey;
+      } else if (providerKey === "ollama-cloud") {
+        process.env.OLLAMA_API_KEY = config2.apiKey;
+      }
+    }
+  }
+  if (providerKey === "ollama-custom") {
+    const existingUrl = provider.getBaseUrl();
+    const defaultUrl = existingUrl || "http://192.168.86.101:11434";
+    config2.customUrl = await input({
+      message: "Enter Ollama URL:",
+      default: defaultUrl,
+      validate: (value) => {
+        try {
+          new URL(value);
+          return true;
+        } catch {
+          return "Please enter a valid URL";
+        }
+      }
+    });
+    if (config2.customUrl) {
+      process.env.OLLAMA_BASE_URL_CUSTOM = config2.customUrl;
+    }
+  }
+  if (!skipValidation) {
+    config2.validated = await validateProvider(providerKey);
+  } else {
+    config2.validated = true;
+  }
+  return config2;
+}
+async function validateProvider(providerKey) {
+  console.log(chalk2.gray("Validating provider connection..."));
+  const result = await checkProviderHealth(providerKey);
+  if (result.healthy) {
+    const latency = result.latencyMs ? ` (${result.latencyMs}ms)` : "";
+    console.log(chalk2.green(`\u2713 ${providerKey} is reachable${latency}`));
+    return true;
+  } else {
+    console.log(chalk2.yellow(`\u26A0 ${providerKey} validation failed`));
+    if (result.error) {
+      console.log(chalk2.gray(`  ${result.error.message}`));
+    }
+    const retry = await confirm({
+      message: "Continue anyway?",
+      default: false
+    });
+    return retry;
+  }
+}
+async function selectDefaults(configuredProviders, currentDefaults) {
+  printSection("Set Defaults");
+  let defaultProvider;
+  let defaultModel;
+  if (currentDefaults && configuredProviders.includes(currentDefaults.provider)) {
+    const useCurrent = await confirm({
+      message: `Keep default provider as ${currentDefaults.provider}?`,
+      default: true
+    });
+    if (useCurrent) {
+      defaultProvider = currentDefaults.provider;
+    } else {
+      defaultProvider = await select({
+        message: "Select default provider:",
+        choices: configuredProviders.map((key) => ({
+          name: getProvider(key)?.name || key,
+          value: key
+        }))
+      });
+    }
+  } else {
+    defaultProvider = await select({
+      message: "Select default provider:",
+      choices: configuredProviders.map((key) => ({
+        name: getProvider(key)?.name || key,
+        value: key
+      }))
+    });
+  }
+  const models3 = await getModels(defaultProvider);
+  console.log("");
+  console.log(chalk2.gray("Available models for " + getProvider(defaultProvider)?.name + ":"));
+  if (models3.length === 0) {
+    console.log("  " + chalk2.gray("(no models found - will use manual input)"));
+    console.log("");
+    const modelInput = await input({
+      message: "Enter default model ID:",
+      validate: (value) => value.length > 0 ? true : "Model ID cannot be empty"
+    });
+    defaultModel = modelInput;
+  } else {
+    for (const model of models3) {
+      console.log(`  ${chalk2.green(model.shortcut.padEnd(20))} ${chalk2.gray(model.id)}`);
+    }
+    console.log("");
+    defaultModel = await select({
+      message: "Select default model:",
+      choices: models3.map((model) => ({
+        name: `${model.name} (${model.shortcut})`,
+        value: model.id
+      }))
+    });
+  }
+  return { provider: defaultProvider, model: defaultModel };
+}
+function formatProviderConfig(config2) {
+  const lines = [];
+  lines.push(chalk2.cyan(`  ${config2.name} (${config2.key})`));
+  if (config2.apiKey) {
+    const masked = config2.apiKey.substring(0, 8) + "..." + config2.apiKey.slice(-4);
+    lines.push(`    API Key: ${chalk2.gray(masked)}`);
+  }
+  if (config2.customUrl) {
+    lines.push(`    URL: ${chalk2.gray(config2.customUrl)}`);
+  }
+  if (config2.validated) {
+    lines.push(`    Status: ${chalk2.green("\u2713 Validated")}`);
+  } else {
+    lines.push(`    Status: ${chalk2.yellow("\u26A0 Not validated")}`);
+  }
+  return lines.join("\n");
+}
+async function reviewAndConfirm(providerConfigs, defaults, currentConfig) {
+  printSection("Review Configuration");
+  console.log(chalk2.bold("Configured Providers:"));
+  console.log("");
+  for (const config2 of providerConfigs) {
+    console.log(formatProviderConfig(config2));
+  }
+  console.log("");
+  console.log(chalk2.bold("Defaults:"));
+  console.log(`  ${chalk2.cyan("Provider:")} ${defaults.provider}`);
+  console.log(`  ${chalk2.cyan("Model:")} ${defaults.model}`);
+  console.log("");
+  console.log(chalk2.bold("Files to be created/updated:"));
+  console.log(`  ${chalk2.cyan("Config:")} ${getConfigPath()}`);
+  console.log(`  ${chalk2.cyan("Env:")} ${getEnvPath()}`);
+  console.log("");
+  const confirmed = await confirm({
+    message: "Save this configuration?",
+    default: true
+  });
+  return confirmed;
+}
+function buildEnvVars(providerConfigs) {
+  const envVars = {};
+  for (const config2 of providerConfigs) {
+    switch (config2.key) {
+      case "openrouter":
+        if (config2.apiKey) {
+          envVars.ANTHROPIC_BASE_URL = "https://openrouter.ai/api";
+          envVars.ANTHROPIC_AUTH_TOKEN = config2.apiKey;
+          envVars.OPEN_ROUTER_API_KEY = config2.apiKey;
+        }
+        break;
+      case "ollama-cloud":
+        if (config2.apiKey) {
+          envVars.OLLAMA_HOST = "https://ollama.com";
+          envVars.OLLAMA_API_KEY = config2.apiKey;
+        }
+        break;
+      case "ollama-local":
+        envVars.OLLAMA_BASE_URL_LOCAL = "http://localhost:11434";
+        break;
+      case "ollama-custom":
+        if (config2.customUrl) {
+          envVars.OLLAMA_BASE_URL_CUSTOM = config2.customUrl;
+        }
+        break;
+    }
+  }
+  return envVars;
+}
+function formatEnvFile(envVars) {
+  const lines = [];
+  lines.push("# claude-mode configuration");
+  lines.push("# Generated by: claude-mode setup");
+  lines.push(`# Date: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  lines.push("");
+  if (envVars.ANTHROPIC_BASE_URL || envVars.ANTHROPIC_AUTH_TOKEN) {
+    lines.push("# OpenRouter");
+    if (envVars.ANTHROPIC_BASE_URL) {
+      lines.push(`ANTHROPIC_BASE_URL=${envVars.ANTHROPIC_BASE_URL}`);
+    }
+    if (envVars.ANTHROPIC_AUTH_TOKEN) {
+      lines.push(`ANTHROPIC_AUTH_TOKEN=${envVars.ANTHROPIC_AUTH_TOKEN}`);
+    }
+    if (envVars.OPEN_ROUTER_API_KEY) {
+      lines.push(`OPEN_ROUTER_API_KEY=${envVars.OPEN_ROUTER_API_KEY}`);
+    }
+    lines.push("");
+  }
+  if (envVars.OLLAMA_HOST || envVars.OLLAMA_API_KEY) {
+    lines.push("# Ollama Cloud");
+    if (envVars.OLLAMA_HOST) {
+      lines.push(`OLLAMA_HOST=${envVars.OLLAMA_HOST}`);
+    }
+    if (envVars.OLLAMA_API_KEY) {
+      lines.push(`OLLAMA_API_KEY=${envVars.OLLAMA_API_KEY}`);
+    }
+    lines.push("");
+  }
+  if (envVars.OLLAMA_BASE_URL_LOCAL) {
+    lines.push("# Ollama Local");
+    lines.push(`OLLAMA_BASE_URL_LOCAL=${envVars.OLLAMA_BASE_URL_LOCAL}`);
+    lines.push("");
+  }
+  if (envVars.OLLAMA_BASE_URL_CUSTOM) {
+    lines.push("# Ollama Custom");
+    lines.push(`OLLAMA_BASE_URL_CUSTOM=${envVars.OLLAMA_BASE_URL_CUSTOM}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function mergeEnvFile(envVars, envPath) {
+  const targetPath = getEnvPath(envPath);
+  const existingVars = loadEnvFile(targetPath);
+  const merged = { ...existingVars, ...envVars };
+  const lines = [];
+  lines.push("# claude-mode configuration");
+  lines.push("# Generated by: claude-mode setup");
+  lines.push(`# Date: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  lines.push("");
+  for (const [key, value] of Object.entries(merged)) {
+    if (!key.startsWith("_claude_mode_")) {
+      lines.push(`${key}=${value}`);
+    }
+  }
+  try {
+    writeFileSync2(targetPath, lines.join("\n") + "\n", "utf-8");
+  } catch (error) {
+    const classified = classifyError(error);
+    throw setupEnvWriteError(classified.message, classified.hint);
+  }
+}
+function saveEnvFile(envVars, envPath) {
+  const targetPath = getEnvPath(envPath);
+  try {
+    const content = formatEnvFile(envVars);
+    writeFileSync2(targetPath, content + "\n", "utf-8");
+  } catch (error) {
+    const classified = classifyError(error);
+    throw setupEnvWriteError(classified.message, classified.hint);
+  }
+}
+function loadEnvFile(envPath) {
+  const targetPath = getEnvPath(envPath);
+  if (!existsSync2(targetPath)) {
+    return {};
+  }
+  try {
+    const content = readFileSync2(targetPath, "utf-8");
+    const vars = {};
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed === "" || trimmed.startsWith("#")) {
+        continue;
+      }
+      const eqIndex = trimmed.indexOf("=");
+      if (eqIndex > 0) {
+        const key = trimmed.substring(0, eqIndex).trim();
+        let value = trimmed.substring(eqIndex + 1).trim();
+        if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+          value = value.slice(1, -1);
+        }
+        vars[key] = value;
+      }
+    }
+    return vars;
+  } catch {
+    return {};
+  }
+}
+function saveConfiguration(providerConfigs, defaults, currentConfig) {
+  const envVars = buildEnvVars(providerConfigs);
+  let config2 = currentConfig || loadConfig();
+  config2.defaultProvider = defaults.provider;
+  config2.defaultModel = defaults.model;
+  config2.configuredProviders = providerConfigs.map((c) => c.key);
+  try {
+    const configDir = getConfigDir2();
+    if (!existsSync2(configDir)) {
+      mkdirSync2(configDir, { recursive: true });
+    }
+    const configPath = getConfigPath();
+    writeFileSync2(configPath, JSON.stringify(config2, null, 2), "utf-8");
+  } catch (error) {
+    const classified = classifyError(error);
+    throw setupConfigWriteError(classified.message, classified.hint);
+  }
+  if (existsSync2(getEnvPath())) {
+    mergeEnvFile(envVars);
+  } else {
+    saveEnvFile(envVars);
+  }
+}
+function displaySuccess(providerConfigs, defaults) {
+  console.clear();
+  printHeader("Setup Complete!");
+  console.log(chalk2.green("\u2713") + " Configuration saved successfully!");
+  console.log("");
+  console.log(chalk2.bold("Configured Providers:"));
+  for (const config2 of providerConfigs) {
+    const status = config2.validated ? chalk2.green("\u2713") : chalk2.yellow("\u26A0");
+    console.log(`  ${status} ${config2.name}`);
+  }
+  console.log("");
+  console.log(chalk2.bold("Default Configuration:"));
+  console.log(`  Provider: ${chalk2.cyan(defaults.provider)}`);
+  console.log(`  Model: ${chalk2.cyan(defaults.model)}`);
+  console.log("");
+  console.log(chalk2.bold("Next Steps:"));
+  console.log("  Run " + chalk2.cyan("claude-mode") + " to start using Claude Code");
+  console.log("  Run " + chalk2.cyan("claude-mode --list") + " to see all available models");
+  console.log("  Run " + chalk2.cyan('claude-mode -p "your prompt"') + " for headless mode");
+  console.log("");
+  console.log(chalk2.gray("Configuration files:"));
+  console.log(chalk2.gray(`  Config: ${getConfigPath()}`));
+  console.log(chalk2.gray(`  Env: ${getEnvPath()}`));
+  console.log("");
+}
+async function runSetup(options = {}) {
+  try {
+    const { force = false, provider: forceProvider, skipValidation = false } = options;
+    const status = detectSetupStatus();
+    const isFirstTime = status === "first-time";
+    if (!force && !isFirstTime) {
+      const shouldContinue = await displayUpdatePrompt();
+      if (!shouldContinue) {
+        return;
+      }
+    }
+    await displayWelcome(isFirstTime);
+    const providerKeys = await selectProviders(forceProvider);
+    const providerConfigs = [];
+    const currentConfig = loadConfig();
+    for (const providerKey of providerKeys) {
+      try {
+        const config2 = await configureProvider(providerKey, skipValidation);
+        providerConfigs.push(config2);
+      } catch (error) {
+        console.log("");
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.log(chalk2.yellow(`Failed to configure ${providerKey}: ${errorMessage}`));
+        const shouldContinue = await confirm({
+          message: "Continue with remaining providers?",
+          default: true
+        });
+        if (!shouldContinue) {
+          throw setupCancelledError();
+        }
+      }
+    }
+    if (providerConfigs.length === 0) {
+      throw setupIncompleteError("No providers were configured");
+    }
+    let currentDefaults;
+    if (currentConfig.defaultProvider && currentConfig.defaultModel) {
+      currentDefaults = {
+        provider: currentConfig.defaultProvider,
+        model: currentConfig.defaultModel
+      };
+    }
+    const configuredProviderKeys = providerConfigs.map((c) => c.key);
+    const defaults = await selectDefaults(configuredProviderKeys, currentDefaults);
+    const confirmed = await reviewAndConfirm(providerConfigs, defaults, currentConfig);
+    if (!confirmed) {
+      throw setupCancelledError();
+    }
+    console.log("");
+    console.log(chalk2.gray("Saving configuration..."));
+    saveConfiguration(providerConfigs, defaults, currentConfig);
+    displaySuccess(providerConfigs, defaults);
+  } catch (error) {
+    const classified = classifyError(error);
+    if (classified.message === "Setup cancelled") {
+      console.log("");
+      console.log(chalk2.yellow("Setup cancelled."));
+      console.log("Run " + chalk2.cyan("claude-mode setup") + " to try again.");
+      console.log("");
+      return;
+    }
+    console.log("");
+    console.log(chalk2.red("Setup failed:"));
+    printError(classified);
+    console.log("");
+    console.log(chalk2.gray("You can run " + chalk2.cyan("claude-mode setup") + " to try again."));
+    console.log("");
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+config();
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path3.dirname(__filename);
+config({ path: path3.join(__dirname, "..", ".env") });
+var program = new Command();
+function printHeader2(text) {
+  console.log("");
+  console.log(chalk3.bold.blue("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"));
+  console.log(chalk3.bold.blue("\u2551") + "  " + chalk3.cyan(text));
+  console.log(chalk3.bold.blue("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"));
+  console.log("");
+}
 function printConfig(provider, modelId, mode) {
-  console.log(chalk2.cyan("Provider:") + " " + provider.name);
-  console.log(chalk2.cyan("Model:") + " " + modelId);
-  console.log(chalk2.cyan("Base URL:") + " " + provider.getBaseUrl());
-  console.log(chalk2.cyan("Mode:") + " " + mode);
+  console.log(chalk3.cyan("Provider:") + " " + provider.name);
+  console.log(chalk3.cyan("Model:") + " " + modelId);
+  console.log(chalk3.cyan("Base URL:") + " " + provider.getBaseUrl());
+  console.log(chalk3.cyan("Mode:") + " " + mode);
   console.log("");
 }
+function shouldTriggerSetup() {
+  const status = detectSetupStatus();
+  if (status === "first-time") {
+    return true;
+  }
+  if (status === "incomplete") {
+    return true;
+  }
+  return false;
+}
 function isClaudeInstalled() {
   try {
     execSync("which claude", { stdio: "ignore" });
@@ -602,16 +1201,16 @@ function formatHealthStatus(result) {
   const name = provider?.name || result.provider;
   if (result.healthy) {
     const latency = result.latencyMs ? ` (${result.latencyMs}ms)` : "";
-    return `${chalk2.green("\u2713")} ${name}${chalk2.gray(latency)}`;
+    return `${chalk3.green("\u2713")} ${name}${chalk3.gray(latency)}`;
   } else {
     const error = result.error?.message || "unavailable";
-    return `${chalk2.red("\u2717")} ${name} ${chalk2.gray(`- ${error}`)}`;
+    return `${chalk3.red("\u2717")} ${name} ${chalk3.gray(`- ${error}`)}`;
   }
 }
 async function displayHealthCheck() {
   const skipHealthCheck = getConfig("skipHealthCheck");
   if (skipHealthCheck) return;
-  console.log(chalk2.gray("Checking provider availability..."));
+  console.log(chalk3.gray("Checking provider availability..."));
   const results = await checkAllProvidersHealth();
   console.log("");
   for (const result of results) {
@@ -621,10 +1220,10 @@ async function displayHealthCheck() {
 }
 async function interactiveMode(skipPermissions) {
   console.clear();
-  printHeader("Claude Mode");
+  printHeader2("Claude Mode");
   await displayHealthCheck();
   const allProviders = getProviders();
-  const providerKey = await select({
+  const providerKey = await select2({
     message: "Select Provider:",
     choices: getProviderKeys().map((key) => ({
       name: allProviders[key].name,
@@ -633,20 +1232,20 @@ async function interactiveMode(skipPermissions) {
     }))
   });
   const provider = getProvider(providerKey);
-  console.log(chalk2.yellow("\u2192 Selected:") + " " + provider.name);
+  console.log(chalk3.yellow("\u2192 Selected:") + " " + provider.name);
   const providerModels = await getModels(providerKey);
   if (providerModels.length === 0) {
-    console.log(chalk2.yellow("No models available for this provider."));
-    console.log(chalk2.gray("You can enter a model ID manually."));
-    const modelId2 = await input({
+    console.log(chalk3.yellow("No models available for this provider."));
+    console.log(chalk3.gray("You can enter a model ID manually."));
+    const modelId2 = await input2({
       message: "Enter model ID:",
       validate: (value) => value.length > 0 ? true : "Model ID cannot be empty"
     });
-    console.log(chalk2.yellow("\u2192 Model:") + " " + modelId2);
+    console.log(chalk3.yellow("\u2192 Model:") + " " + modelId2);
     await continueInteractiveMode(provider, modelId2, skipPermissions);
     return;
   }
-  const modelId = await select({
+  const modelId = await select2({
     message: "Select Model:",
     choices: providerModels.map((model) => ({
       name: model.name,
@@ -655,11 +1254,11 @@ async function interactiveMode(skipPermissions) {
     }))
   });
   const selectedModel = providerModels.find((m) => m.id === modelId);
-  console.log(chalk2.yellow("\u2192 Selected:") + " " + selectedModel?.name + ` (${modelId})`);
+  console.log(chalk3.yellow("\u2192 Selected:") + " " + selectedModel?.name + ` (${modelId})`);
   await continueInteractiveMode(provider, modelId, skipPermissions);
 }
 async function continueInteractiveMode(provider, modelId, skipPermissions) {
-  const mode = await select({
+  const mode = await select2({
     message: "Select Mode:",
     choices: [
       { name: "Terminal (interactive)", value: "terminal" },
@@ -668,13 +1267,13 @@ async function continueInteractiveMode(provider, modelId, skipPermissions) {
   });
   let prompt;
   if (mode === "headless") {
-    prompt = await input({
+    prompt = await input2({
       message: "Enter your prompt:",
       validate: (value) => value.length > 0 ? true : "Prompt cannot be empty"
     });
   }
   if (!skipPermissions) {
-    skipPermissions = await select({
+    skipPermissions = await select2({
       message: "Skip permission prompts when executing commands?",
       choices: [
         { name: "No (ask for permission)", value: false },
@@ -683,19 +1282,19 @@ async function continueInteractiveMode(provider, modelId, skipPermissions) {
     });
   }
   console.log(
-    chalk2.yellow("\u2192 Skip permissions:") + " " + (skipPermissions ? chalk2.red("Yes (\u26A0\uFE0F auto-approve)") : chalk2.green("No (ask)"))
+    chalk3.yellow("\u2192 Skip permissions:") + " " + (skipPermissions ? chalk3.red("Yes (\u26A0\uFE0F auto-approve)") : chalk3.green("No (ask)"))
   );
   const isHeadless = mode === "headless";
   if (isHeadless) {
-    printHeader("Executing Claude Code (Headless)");
+    printHeader2("Executing Claude Code (Headless)");
   } else {
-    printHeader("Launching Claude Code (Interactive)");
+    printHeader2("Launching Claude Code (Interactive)");
   }
   printConfig(provider, modelId, isHeadless ? "Headless" : "Interactive");
   try {
     await runClaude(provider, modelId, isHeadless, skipPermissions, prompt);
   } catch (error) {
-    console.error(chalk2.red("Error:"), error);
+    console.error(chalk3.red("Error:"), error);
     process.exit(1);
   }
 }
@@ -703,8 +1302,8 @@ async function quickMode(providerArg, modelArg, skipPermissions, modeArg, prompt
   const providerKey = resolveProvider(providerArg);
   const provider = getProvider(providerKey);
   if (!provider) {
-    console.error(chalk2.red(`Unknown provider: ${providerArg}`));
-    console.log(chalk2.gray("Available providers: " + getProviderKeys().join(", ")));
+    console.error(chalk3.red(`Unknown provider: ${providerArg}`));
+    console.log(chalk3.gray("Available providers: " + getProviderKeys().join(", ")));
     process.exit(1);
   }
   const modelId = await resolveModel(providerKey, modelArg);
@@ -729,7 +1328,7 @@ async function quickMode(providerArg, modelArg, skipPermissions, modeArg, prompt
     }
   }
   if (isHeadless && !prompt) {
-    prompt = await input({
+    prompt = await input2({
       message: "Enter your prompt:",
       validate: (value) => value.length > 0 ? true : "Prompt cannot be empty"
     });
@@ -738,23 +1337,23 @@ async function quickMode(providerArg, modelArg, skipPermissions, modeArg, prompt
   try {
     await runClaude(provider, modelId, isHeadless, skipPermissions, prompt);
   } catch (error) {
-    console.error(chalk2.red("Error:"), error);
+    console.error(chalk3.red("Error:"), error);
     process.exit(1);
   }
 }
 async function listModels() {
-  console.log(chalk2.bold("\nAvailable Models by Provider:\n"));
+  console.log(chalk3.bold("\nAvailable Models by Provider:\n"));
   const allProviders = getProviders();
   for (const providerKey of getProviderKeys()) {
     const provider = allProviders[providerKey];
     const providerModels = await getModels(providerKey);
-    console.log(chalk2.cyan(`${provider.name}:`));
-    console.log(chalk2.gray(`  ${provider.getDescription()}`));
+    console.log(chalk3.cyan(`${provider.name}:`));
+    console.log(chalk3.gray(`  ${provider.getDescription()}`));
     if (providerModels.length === 0) {
-      console.log(`  ${chalk2.gray("(no models found)")}`);
+      console.log(`  ${chalk3.gray("(no models found)")}`);
     } else {
       for (const model of providerModels) {
-        console.log(`  ${chalk2.green(model.shortcut.padEnd(14))} \u2192 ${model.id}`);
+        console.log(`  ${chalk3.green(model.shortcut.padEnd(14))} \u2192 ${model.id}`);
       }
     }
     console.log("");
@@ -762,14 +1361,14 @@ async function listModels() {
 }
 function showConfig() {
   const config2 = loadConfig();
-  console.log(chalk2.bold("\nCurrent Configuration:\n"));
+  console.log(chalk3.bold("\nCurrent Configuration:\n"));
   console.log(JSON.stringify(config2, null, 2));
   console.log("");
 }
 function initConfigCommand() {
   const configPath = initConfig();
-  console.log(chalk2.green(`Config file created at: ${configPath}`));
-  console.log(chalk2.gray("Edit this file to customize your settings."));
+  console.log(chalk3.green(`Config file created at: ${configPath}`));
+  console.log(chalk3.gray("Edit this file to customize your settings."));
 }
 function generateBashCompletion() {
   const providerKeys = getProviderKeys();
@@ -897,13 +1496,13 @@ function printCompletion(shell) {
       console.log(generateFishCompletion());
       break;
     default:
-      console.error(chalk2.red(`Unknown shell: ${shell}`));
-      console.log(chalk2.gray("Supported shells: bash, zsh, fish"));
+      console.error(chalk3.red(`Unknown shell: ${shell}`));
+      console.log(chalk3.gray("Supported shells: bash, zsh, fish"));
       process.exit(1);
   }
 }
 async function healthCommand() {
-  console.log(chalk2.bold("\nProvider Health Check:\n"));
+  console.log(chalk3.bold("\nProvider Health Check:\n"));
   const results = await checkAllProvidersHealth();
   for (const result of results) {
     console.log("  " + formatHealthStatus(result));
@@ -912,40 +1511,40 @@ async function healthCommand() {
   const healthy = results.filter((r) => r.healthy).length;
   const total = results.length;
   if (healthy === total) {
-    console.log(chalk2.green(`All ${total} providers are healthy.`));
+    console.log(chalk3.green(`All ${total} providers are healthy.`));
   } else {
-    console.log(chalk2.yellow(`${healthy}/${total} providers are healthy.`));
+    console.log(chalk3.yellow(`${healthy}/${total} providers are healthy.`));
   }
 }
 program.name("claude-mode").description(
   `
-${chalk2.bold("Claude Mode")} - Launch Claude Code with different providers
+${chalk3.bold("Claude Mode")} - Launch Claude Code with different providers
 
-${chalk2.bold("Providers:")}
+${chalk3.bold("Providers:")}
   openrouter        OpenRouter API
   ollama-cloud      Ollama Cloud (OLLAMA_HOST)
   ollama-local      Ollama Local (OLLAMA_BASE_URL_LOCAL)
   ollama-custom     Ollama Custom (OLLAMA_BASE_URL_CUSTOM)
 
-${chalk2.bold("Model shortcuts:")}
+${chalk3.bold("Model shortcuts:")}
   OpenRouter (Premium): gpt52, gpt52-pro, gpt52-codex, opus, grok
   OpenRouter (Value): deepseek, zai-glm47-flash, seed16, sonnet, haiku
   OpenRouter (Existing): gpt120, glm47, gemini-pro, gemini-flash
   Ollama: Models discovered dynamically via API
 
-${chalk2.bold("Mode shortcuts:")}
+${chalk3.bold("Mode shortcuts:")}
   terminal, t, interactive, i  - Interactive terminal mode
   headless, h, prompt, p       - Headless mode with prompt
 
-${chalk2.bold("Options:")}
+${chalk3.bold("Options:")}
   -p, --prompt <prompt>               Headless mode (uses defaults if provider/model not set)
   -d, --dangerously-skip-permissions  Skip permission prompts (\u26A0\uFE0F use with caution)
 
-${chalk2.bold("Default Provider/Model:")}
+${chalk3.bold("Default Provider/Model:")}
   Set in ~/.claude-mode/claude-mode.json:
     { "defaultProvider": "openrouter", "defaultModel": "sonnet" }
 
-${chalk2.bold("Examples:")}
+${chalk3.bold("Examples:")}
   claude-mode                                    Interactive menu
   claude-mode -p "perform a code review"         Headless with default provider/model
   claude-mode openrouter sonnet                  Interactive with Claude Sonnet
@@ -978,7 +1577,24 @@ program.command("config").description("Manage configuration").argument("[action]
 program.command("completion").description("Generate shell completion scripts").argument("<shell>", "Shell type: bash, zsh, fish").action((shell) => {
   printCompletion(shell);
 });
+program.command("setup").description("Interactive setup wizard for first-time configuration").option("-f, --force", "Re-run setup even if config exists").option("-p, --provider <provider>", "Configure only this provider").option("--skip-validation", "Skip API key validation").action(async (options) => {
+  await runSetup({
+    force: options.force,
+    provider: options.provider,
+    skipValidation: options.skipValidation
+  });
+});
 program.option("-d, --dangerously-skip-permissions", "Skip permission prompts when executing commands").option("-l, --list", "List all available providers and models").option("-p, --prompt <prompt>", "Run in headless mode with the given prompt (uses defaults if provider/model not specified)").argument("[provider]", "Provider (openrouter, ollama-cloud, ollama-local, ollama-custom)").argument("[model]", "Model ID or shortcut").argument("[mode]", "Mode (terminal/t, headless/h) or prompt for headless").argument("[promptArg]", "Prompt for headless mode").action(async (provider, model, mode, promptArg, options) => {
+  if (shouldTriggerSetup()) {
+    const shouldSetup = await confirm2({
+      message: "No configuration found. Would you like to run setup?",
+      default: true
+    });
+    if (shouldSetup) {
+      await runSetup({ force: false });
+      return;
+    }
+  }
   if (options.list) {
     await listModels();
     return;
@@ -990,14 +1606,14 @@ program.option("-d, --dangerously-skip-permissions", "Skip permission prompts wh
     const effectiveProvider = provider || defaultProvider;
     const effectiveModel = model || defaultModel;
     if (!effectiveProvider || !effectiveModel) {
-      console.error(chalk2.red("Error: Provider and model are required"));
+      console.error(chalk3.red("Error: Provider and model are required"));
       if (!effectiveProvider && !effectiveModel) {
-        console.log(chalk2.gray("Set defaults in config: claude-mode config init"));
-        console.log(chalk2.gray("Then edit ~/.claude-mode/claude-mode.json to set defaultProvider and defaultModel"));
+        console.log(chalk3.gray("Set defaults in config: claude-mode config init"));
+        console.log(chalk3.gray("Then edit ~/.claude-mode/claude-mode.json to set defaultProvider and defaultModel"));
       } else if (!effectiveProvider) {
-        console.log(chalk2.gray("Missing: provider (set defaultProvider in config or pass as argument)"));
+        console.log(chalk3.gray("Missing: provider (set defaultProvider in config or pass as argument)"));
       } else {
-        console.log(chalk2.gray("Missing: model (set defaultModel in config or pass as argument)"));
+        console.log(chalk3.gray("Missing: model (set defaultModel in config or pass as argument)"));
       }
       process.exit(1);
     }
@@ -1011,10 +1627,10 @@ program.option("-d, --dangerously-skip-permissions", "Skip permission prompts wh
     if (defaultModel) {
       await quickMode(provider, defaultModel, skipPermissions, mode, promptArg);
     } else {
-      console.error(chalk2.red("Error: Model is required when provider is specified"));
-      console.log(chalk2.gray("Usage: claude-mode <provider> <model> [mode] [prompt]"));
-      console.log(chalk2.gray("Or set defaultModel in ~/.claude-mode/claude-mode.json"));
-      console.log(chalk2.gray("Run claude-mode --list to see available models"));
+      console.error(chalk3.red("Error: Model is required when provider is specified"));
+      console.log(chalk3.gray("Usage: claude-mode <provider> <model> [mode] [prompt]"));
+      console.log(chalk3.gray("Or set defaultModel in ~/.claude-mode/claude-mode.json"));
+      console.log(chalk3.gray("Run claude-mode --list to see available models"));
       process.exit(1);
     }
   } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cbuk100011/claude-mode",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "CLI launcher for Claude Code with multiple AI providers",
   "type": "module",
   "main": "./dist/index.js",