workermill 0.3.3 → 0.4.0

package/dist/index.js

@@ -24,101 +24,312 @@ import readline from "readline";
 import { execSync } from "child_process";
 import chalk from "chalk";
 var PROVIDERS = [
-  { name: "ollama", display: "Ollama (local, no API key needed)", needsKey: false, defaultModel: "qwen3-coder:30b" },
-  { name: "anthropic", display: "Anthropic (Claude)", needsKey: true, defaultModel: "claude-sonnet-4-6", envVar: "ANTHROPIC_API_KEY" },
-  { name: "openai", display: "OpenAI (GPT)", needsKey: true, defaultModel: "gpt-5.4", envVar: "OPENAI_API_KEY" },
-  { name: "google", display: "Google (Gemini)", needsKey: true, defaultModel: "gemini-3.1-pro", envVar: "GOOGLE_GENERATIVE_AI_API_KEY" }
+  {
+    name: "ollama",
+    display: "Ollama (local, no API key)",
+    needsKey: false,
+    models: [
+      { id: "qwen3-coder:30b", label: "Qwen 3 Coder 30B (recommended)" },
+      { id: "qwen2.5-coder:32b", label: "Qwen 2.5 Coder 32B" }
+    ]
+  },
+  {
+    name: "anthropic",
+    display: "Anthropic (Claude)",
+    needsKey: true,
+    envVar: "ANTHROPIC_API_KEY",
+    models: [
+      { id: "claude-sonnet-4-6", label: "Claude Sonnet 4.6 (recommended)" },
+      { id: "claude-opus-4-6", label: "Claude Opus 4.6 (most powerful)" }
+    ]
+  },
+  {
+    name: "openai",
+    display: "OpenAI",
+    needsKey: true,
+    envVar: "OPENAI_API_KEY",
+    models: [
+      { id: "gpt-5.2-codex", label: "GPT-5.2 Codex (built for code)" },
+      { id: "gpt-5", label: "GPT-5 (general flagship)" }
+    ]
+  },
+  {
+    name: "google",
+    display: "Google (Gemini)",
+    needsKey: true,
+    envVar: "GOOGLE_GENERATIVE_AI_API_KEY",
+    models: [
+      { id: "gemini-2.5-pro", label: "Gemini 2.5 Pro (most powerful)" },
+      { id: "gemini-2.5-flash", label: "Gemini 2.5 Flash (fast, good value)" }
+    ]
+  }
 ];
 function ask(rl, question) {
   return new Promise((resolve) => rl.question(question, resolve));
 }
-async function runSetup() {
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  console.log();
-  console.log(chalk.bold("  WorkerMill CLI") + chalk.dim(" \u2014 AI coding agent"));
-  console.log();
-  console.log(chalk.dim("  No provider configured. Let's set one up."));
-  console.log();
-  console.log("  Provider:");
-  PROVIDERS.forEach((p, i) => {
+async function pickProvider(rl, label, providers) {
+  console.log(`  ${chalk.bold(label)}:`);
+  providers.forEach((p, i) => {
     console.log(`    ${chalk.cyan(`${i + 1}`)}. ${p.display}`);
   });
   console.log();
-  const choiceStr = await ask(rl, chalk.dim("  Choose (1-4): "));
+  const choiceStr = await ask(rl, chalk.dim(`  Choose (1-${providers.length}): `));
   const choice = parseInt(choiceStr.trim(), 10) - 1;
-  const selected = PROVIDERS[choice] || PROVIDERS[0];
+  const selected = providers[choice] || providers[0];
+  console.log(chalk.dim(`  \u2192 ${selected.display}`));
+  return selected;
+}
+async function pickModel(rl, provider) {
   console.log();
-  console.log(chalk.dim(`  Selected: ${selected.display}`));
-  const providerConfig = { model: selected.defaultModel };
-  if (selected.needsKey) {
-    const envValue = selected.envVar ? process.env[selected.envVar] : void 0;
-    if (envValue) {
-      console.log(chalk.green(`  \u2713 Found ${selected.envVar} in environment`));
-      providerConfig.apiKey = `{env:${selected.envVar}}`;
-    } else {
-      const key = await ask(rl, chalk.dim(`  API key: `));
-      providerConfig.apiKey = key.trim();
+  provider.models.forEach((m, i) => {
+    console.log(`    ${chalk.cyan(`${i + 1}`)}. ${m.label}`);
+  });
+  console.log(`    ${chalk.cyan(`${provider.models.length + 1}`)}. Custom model`);
+  console.log();
+  const choiceStr = await ask(rl, chalk.dim(`  Choose (1-${provider.models.length + 1}): `));
+  const choice = parseInt(choiceStr.trim(), 10) - 1;
+  if (choice >= 0 && choice < provider.models.length) {
+    const model2 = provider.models[choice].id;
+    console.log(chalk.dim(`  \u2192 ${model2}`));
+    return model2;
+  }
+  const custom = await ask(rl, chalk.dim("  Model name: "));
+  const model = custom.trim() || provider.models[0].id;
+  console.log(chalk.dim(`  \u2192 ${model}`));
+  return model;
+}
+function maskKey(key) {
+  if (key.length <= 12) return "\u2022".repeat(key.length);
+  return key.slice(0, 6) + "\u2022".repeat(Math.min(key.length - 10, 30)) + key.slice(-4);
+}
+async function getApiKey(rl, provider, existingKeys) {
+  if (!provider.needsKey) return void 0;
+  if (existingKeys.has(provider.name)) {
+    console.log(chalk.green(`  \u2713 Reusing ${provider.display} API key from earlier`));
+    return existingKeys.get(provider.name);
+  }
+  const envValue = provider.envVar ? process.env[provider.envVar] : void 0;
+  if (envValue) {
+    console.log(chalk.green(`  \u2713 Found ${provider.envVar} in environment`));
+    const key2 = `{env:${provider.envVar}}`;
+    existingKeys.set(provider.name, key2);
+    return key2;
+  }
+  const key = await readKeyMasked(rl, chalk.dim(`  ${provider.display} API key: `));
+  const trimmed = key.trim();
+  existingKeys.set(provider.name, trimmed);
+  return trimmed;
+}
+function readKeyMasked(rl, prompt) {
+  return new Promise((resolve) => {
+    let buffer = "";
+    let revealed = false;
+    process.stdout.write(prompt);
+    const wasRaw = process.stdin.isRaw;
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
     }
+    process.stdin.resume();
+    const redraw = () => {
+      process.stdout.write(`\r\x1B[K${prompt}`);
+      if (revealed) {
+        process.stdout.write(buffer);
+      } else {
+        process.stdout.write(maskKey(buffer));
+      }
+    };
+    const onData = (data) => {
+      const str = data.toString();
+      for (const ch of str) {
+        const code = ch.charCodeAt(0);
+        if (code === 13 || code === 10) {
+          process.stdin.removeListener("data", onData);
+          if (process.stdin.isTTY) {
+            process.stdin.setRawMode(wasRaw ?? false);
+          }
+          process.stdout.write(`\r\x1B[K${prompt}`);
+          if (buffer.length > 0) {
+            process.stdout.write(chalk.green(maskKey(buffer)));
+          }
+          process.stdout.write("\n");
+          resolve(buffer);
+          return;
+        }
+        if (code === 9) {
+          revealed = !revealed;
+          redraw();
+          continue;
+        }
+        if (code === 3) {
+          process.stdin.removeListener("data", onData);
+          if (process.stdin.isTTY) {
+            process.stdin.setRawMode(wasRaw ?? false);
+          }
+          process.stdout.write("\n");
+          resolve("");
+          return;
+        }
+        if (code === 127 || code === 8) {
+          if (buffer.length > 0) {
+            buffer = buffer.slice(0, -1);
+            redraw();
+          }
+          continue;
+        }
+        if (code === 21) {
+          buffer = "";
+          redraw();
+          continue;
+        }
+        if (code >= 32) {
+          buffer += ch;
+          redraw();
+        }
+      }
+    };
+    process.stdin.on("data", onData);
+  });
+}
+async function configureOllama(providerConfig) {
+  const hostsToTry = ["http://localhost:11434"];
+  try {
+    const gateway = execSync("ip route show default 2>/dev/null | awk '{print $3}'", { encoding: "utf-8" }).trim();
+    if (gateway) hostsToTry.push(`http://${gateway}:11434`);
+  } catch {
   }
-  if (selected.name === "ollama") {
-    const hostsToTry = ["http://localhost:11434"];
+  if (process.env.OLLAMA_HOST) {
+    const envHost = process.env.OLLAMA_HOST.startsWith("http") ? process.env.OLLAMA_HOST : `http://${process.env.OLLAMA_HOST}`;
+    hostsToTry.unshift(envHost);
+  }
+  providerConfig.contextLength = 65536;
+  for (const host of hostsToTry) {
     try {
-      const gateway = execSync("ip route show default 2>/dev/null | awk '{print $3}'", { encoding: "utf-8" }).trim();
-      if (gateway) {
-        hostsToTry.push(`http://${gateway}:11434`);
-      }
-    } catch {
-    }
-    if (process.env.OLLAMA_HOST) {
-      const envHost = process.env.OLLAMA_HOST.startsWith("http") ? process.env.OLLAMA_HOST : `http://${process.env.OLLAMA_HOST}`;
-      hostsToTry.unshift(envHost);
-    }
-    let connectedHost = null;
-    let models = [];
-    for (const host of hostsToTry) {
-      try {
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), 3e3);
-        const response = await globalThis.fetch(`${host}/api/tags`, { signal: controller.signal });
-        clearTimeout(timeout);
-        if (response.ok) {
-          const data = await response.json();
-          connectedHost = host;
-          models = data.models || [];
-          break;
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 3e3);
+      const response = await globalThis.fetch(`${host}/api/tags`, { signal: controller.signal });
+      clearTimeout(timeout);
+      if (response.ok) {
+        const data = await response.json();
+        providerConfig.host = host;
+        console.log(chalk.green(`  \u2713 Connected to Ollama at ${host}`));
+        const models = data.models || [];
+        if (models.length > 0) {
+          console.log(chalk.dim(`  Available: ${models.map((m) => m.name).join(", ")}`));
         }
-      } catch {
-        continue;
+        return;
       }
+    } catch {
+      continue;
     }
-    providerConfig.contextLength = 65536;
-    if (connectedHost) {
-      providerConfig.host = connectedHost;
-      console.log(chalk.green(`  \u2713 Connected to Ollama at ${connectedHost}`));
-      console.log(chalk.dim(`  Context window: ${providerConfig.contextLength.toLocaleString()} tokens`));
-      if (models.length > 0) {
-        console.log(chalk.dim(`  Available models: ${models.map((m) => m.name).join(", ")}`));
-      }
-    } else {
-      providerConfig.host = "http://localhost:11434";
-      console.log(chalk.yellow("  \u26A0 Could not connect to Ollama. Make sure it's running."));
-      console.log(chalk.dim("    Tried: " + hostsToTry.join(", ")));
+  }
+  providerConfig.host = "http://localhost:11434";
+  console.log(chalk.yellow("  \u26A0 Could not connect to Ollama. Make sure it's running."));
+}
+async function runSetup() {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const apiKeys = /* @__PURE__ */ new Map();
+  console.log();
+  console.log(chalk.bold("  WorkerMill CLI") + chalk.dim(" \u2014 AI coding agent"));
+  console.log();
+  console.log(chalk.dim("  WorkerMill uses three roles. Each can use a different provider."));
+  console.log(chalk.dim("  Workers build code, the planner designs the plan, the reviewer checks quality."));
+  console.log();
+  console.log(chalk.hex("#D77757").bold("  \u2460 Workers") + chalk.dim(" \u2014 expert personas that write code"));
+  console.log();
+  const workerProvider = await pickProvider(rl, "Provider for workers", PROVIDERS);
+  const workerModel = await pickModel(rl, workerProvider);
+  const workerKey = await getApiKey(rl, workerProvider, apiKeys);
+  const workerConfig = { model: workerModel };
+  if (workerKey) workerConfig.apiKey = workerKey;
+  if (workerProvider.name === "ollama") await configureOllama(workerConfig);
+  console.log();
+  console.log(chalk.hex("#D77757").bold("  \u2461 Planner") + chalk.dim(" \u2014 plans stories and validates the approach"));
+  console.log();
+  const sameForPlanner = await ask(rl, chalk.dim(`  Same as workers (${workerProvider.display} / ${workerModel})? [Y/n] `));
+  let plannerProviderName;
+  let plannerModel;
+  if (sameForPlanner.trim().toLowerCase() === "n") {
+    const plannerProvider = await pickProvider(rl, "Provider for planner", PROVIDERS);
+    plannerModel = await pickModel(rl, plannerProvider);
+    const plannerKey = await getApiKey(rl, plannerProvider, apiKeys);
+    plannerProviderName = plannerProvider.name;
+    if (plannerKey && plannerProvider.name !== workerProvider.name) {
     }
+  } else {
+    plannerProviderName = workerProvider.name;
+    plannerModel = workerModel;
+    console.log(chalk.dim(`  \u2192 ${workerProvider.display} / ${workerModel}`));
   }
   console.log();
-  const modelOverride = await ask(rl, chalk.dim(`  Model (press Enter for ${selected.defaultModel}): `));
-  if (modelOverride.trim()) {
-    providerConfig.model = modelOverride.trim();
+  console.log(chalk.hex("#D77757").bold("  \u2462 Reviewer") + chalk.dim(" \u2014 tech lead that reviews code quality"));
+  console.log();
+  const sameForReviewer = await ask(rl, chalk.dim(`  Same as workers (${workerProvider.display} / ${workerModel})? [Y/n] `));
+  let reviewerProviderName;
+  let reviewerModel;
+  if (sameForReviewer.trim().toLowerCase() === "n") {
+    const reviewerProvider = await pickProvider(rl, "Provider for reviewer", PROVIDERS);
+    reviewerModel = await pickModel(rl, reviewerProvider);
+    const reviewerKey = await getApiKey(rl, reviewerProvider, apiKeys);
+    reviewerProviderName = reviewerProvider.name;
+    if (reviewerKey && reviewerProvider.name !== workerProvider.name) {
+    }
+  } else {
+    reviewerProviderName = workerProvider.name;
+    reviewerModel = workerModel;
+    console.log(chalk.dim(`  \u2192 ${workerProvider.display} / ${workerModel}`));
   }
   rl.close();
+  const providers = {
+    [workerProvider.name]: workerConfig
+  };
+  if (plannerProviderName !== workerProvider.name && !providers[plannerProviderName]) {
+    const pProvider = PROVIDERS.find((p) => p.name === plannerProviderName);
+    const cfg = { model: plannerModel };
+    const key = apiKeys.get(plannerProviderName);
+    if (key) cfg.apiKey = key;
+    if (pProvider.name === "ollama") await configureOllama(cfg);
+    providers[plannerProviderName] = cfg;
+  }
+  if (reviewerProviderName !== workerProvider.name && !providers[reviewerProviderName]) {
+    const rProvider = PROVIDERS.find((p) => p.name === reviewerProviderName);
+    const cfg = { model: reviewerModel };
+    const key = apiKeys.get(reviewerProviderName);
+    if (key) cfg.apiKey = key;
+    if (rProvider.name === "ollama") await configureOllama(cfg);
+    providers[reviewerProviderName] = cfg;
+  }
+  const routing = {};
+  if (plannerProviderName !== workerProvider.name) {
+    routing.planner = plannerProviderName;
+    routing.critic = plannerProviderName;
+  }
+  if (reviewerProviderName !== workerProvider.name) {
+    routing.tech_lead = reviewerProviderName;
+  }
+  if (plannerProviderName === workerProvider.name && plannerModel !== workerModel) {
+    const altKey = `${plannerProviderName}_planner`;
+    providers[altKey] = { ...providers[plannerProviderName], model: plannerModel };
+    routing.planner = altKey;
+    routing.critic = altKey;
+  }
+  if (reviewerProviderName === workerProvider.name && reviewerModel !== workerModel) {
+    const altKey = `${reviewerProviderName}_reviewer`;
+    providers[altKey] = { ...providers[reviewerProviderName], model: reviewerModel };
+    routing.tech_lead = altKey;
+  }
   const config = {
-    providers: { [selected.name]: providerConfig },
-    default: selected.name
+    providers,
+    default: workerProvider.name,
+    ...Object.keys(routing).length > 0 ? { routing } : {}
   };
   saveConfig(config);
   console.log();
   console.log(chalk.green("  \u2713 Config saved to ~/.workermill/cli.json"));
   console.log();
+  console.log(chalk.dim("  Workers:  ") + `${workerProvider.name}/${workerModel}`);
+  console.log(chalk.dim("  Planner:  ") + `${plannerProviderName}/${plannerModel}`);
+  console.log(chalk.dim("  Reviewer: ") + `${reviewerProviderName}/${reviewerModel}`);
+  console.log();
   return config;
 }
 
@@ -1997,7 +2208,7 @@ function printWelcome(provider, model, workingDir) {
   console.log(dim("  Type ") + white("/help") + dim(" for all commands."));
   console.log();
 }
-var VERSION = "0.3.3";
+var VERSION = "0.4.0";
 function addSharedOptions(cmd) {
   return cmd.option("--provider <provider>", "Override default provider").option("--model <model>", "Override model").option("--trust", "Skip all tool permission prompts").option("--full-disk", "Allow tools to access files outside working directory");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "workermill",
-  "version": "0.3.3",
+  "version": "0.4.0",
   "description": "AI coding agent with multi-expert orchestration. Works with any LLM provider.",
   "type": "module",
   "bin": {