miii-cli 1.0.1 → 1.1.0

package/README.md

@@ -1,6 +1,6 @@
-# Miii — The High-Performance Local AI Coding Agent
+# Miii — Local-First AI Coding Agent
 
-> **You're paying $200/month for an AI that reads your private code and sends it to a cloud server you don't control. There's a better way.**
+> **The only coding CLI that runs fully local or cloud — any model, zero lock-in, zero monthly bill.**
 
 ![MIII Demo](mii-cli.gif)
 
@@ -13,7 +13,7 @@
 
 **Miii is a fully autonomous coding agent that runs entirely on your machine.** It plans, edits files, runs your tests, searches the web, indexes your codebase semantically, and iterates until the job is done — all without a single byte of your code leaving your network.
 
-Zero subscription. Zero cloud dependency. Zero Python overhead. **176 KB total.** Just raw engineering horsepower in your terminal.
+Zero subscription. Zero cloud dependency. Zero Python overhead. **176 KB total.**
 
 ```bash
 npm install -g miii-cli && miii
@@ -21,29 +21,47 @@ npm install -g miii-cli && miii
 
 ---
 
-## Why Engineers Are Switching
+## Why Miii Exists
 
-Claude Code is impressive. It's also a 50 MB binary that costs $200/month, requires an internet connection, and sends every line of your codebase to a server you don't own.
+Claude Code is impressive. It's also cloud-only, costs $20–200/month, and sends every line of your codebase to a server you don't control.
 
-**Miii does everything Claude Code does. It's 176 KB. It's free. It runs on your laptop.**
+OpenCode and Codex CLI have the same problem — they're all cloud-first, all locked to specific providers, and all charge you indefinitely for the privilege of reading your private code.
 
-GitHub Copilot streams your proprietary code to Microsoft. Aider is a Python monolith that takes longer to boot than to write a function. All of them charge you monthly for the privilege of being the product.
+**Miii flips the model.** Run on Ollama: $0/month, fully offline, code never leaves your machine. Switch to Anthropic or OpenAI when you need cloud power. Change providers live inside the app — no config files, no restarts.
 
-Miii flips the model. Your compute. Your data. Your rules.
+Your compute. Your data. Your rules.
+
+---
+
+## How Miii Compares
+
+| | **Miii** | Claude Code | OpenCode | Codex CLI | Aider |
+|---|:---:|:---:|:---:|:---:|:---:|
+| Monthly cost | **$0** | $20–200 | API cost | API cost | $0 |
+| Bundle size | **176 KB** | ~50 MB | ~30 MB | ~20 MB | ~200 MB |
+| Local / offline (Ollama) | **✅** | ❌ | partial | ❌ | ⚠️ |
+| Air-gapped | **✅** | ❌ | ❌ | ❌ | ❌ |
+| Switch provider live | **✅** | ❌ | ❌ | ❌ | ❌ |
+| File checkpoints (undo) | **✅** | ❌ | ❌ | ❌ | ❌ |
+| Permission gates | **✅** | ✅ | partial | ✅ | ❌ |
+| MCP client | **✅** | ✅ | ✅ | ❌ | ❌ |
+| Semantic codebase index | **✅** | ❌ | ❌ | ❌ | ❌ |
+| Skill/extension system | **✅** | plugins | ❌ | ❌ | ❌ |
+| Startup time | **<100ms** | ~2s | ~1s | ~1s | ~4s |
+| License | **MIT** | Proprietary | MIT | MIT | Apache 2.0 |
 
 ---
 
 ## What Miii Actually Does
 
-This isn't a fancy autocomplete. Miii is a **full autonomous agent loop:**
+This isn't autocomplete. Miii is a **full autonomous agent loop:**
 
 1. You describe a goal
 2. Miii reads your codebase, plans the changes, edits the files
-3. It runs your test suite automatically after every change
-4. If tests fail, it reads the error, fixes the code, re-runs
-5. It repeats until the work is done
-
-No babysitting. No copy-pasting error messages. No broken half-edits.
+3. It asks your permission before touching anything (edit, delete, run commands)
+4. It runs your test suite automatically after every change
+5. If tests fail, it reads the error, fixes the code, re-runs
+6. It repeats until the work is done — and checkpoints every file so you can abort safely
 
 ---
 
@@ -54,61 +72,63 @@ No babysitting. No copy-pasting error messages. No broken half-edits.
 
   ● Researching: refactor auth module to use JWT
   ● Reading src/auth/session.ts
+    Read 42 lines
   ● Reading src/middleware/auth.ts
-  ● Reading src/routes/login.ts
+    Read 28 lines
 
-  Planning: 3 file(s) to change
+  ─ plan (2 actions)
+    ◦ edit_file src/auth/session.ts
+    ◦ edit_file src/middleware/auth.ts
 
-  ● Editing src/auth/session.ts
-  ● Editing src/middleware/auth.ts
-  ● Editing src/routes/login.ts
-  ● Running tests
+  ⚠ edit_file  src/auth/session.ts   y approve  n deny
+  > y
 
-  ─ refactor done — 3 file(s) processed
-```
+  ● edit_file src/auth/session.ts
+    Wrote 12 lines
+  ● edit_file src/middleware/auth.ts
+    Wrote 8 lines
+  ● run_tests
+    ✅ Tests passed
 
-No prompts asking which files to change. No copy-pasting error messages. Just: describe the goal, watch it work.
+  ─ refactor done — 2 file(s) processed
+```
 
 ---
 
 ## Killer Features
 
-**🔍 Semantic Codebase Indexing** *(new in v0.3.2)*
+**🔒 Privacy-First, Local by Default**
+Run on Ollama and your code never leaves your machine. No account. No API key. No monthly bill. Switch to Anthropic or OpenAI when you need it — one command, live, mid-session.
+
+**🔄 Live Provider Switching**
+Type `/config` to open an interactive picker. Arrow-navigate between Ollama, Anthropic, and OpenAI-compatible endpoints. Change model, API key, base URL, or Tavily key without restarting. Config saves automatically.
+
+**🛡 Permission Gates + File Checkpoints**
+Miii asks before every edit, delete, or shell command — just like Claude Code. Every file is checkpointed before it's touched. Hit Esc to abort and all changes roll back automatically.
+
+**🔍 Semantic Codebase Indexing**
 Build a vector index of your entire codebase using local embeddings. Ask "where is the auth logic?" and Miii finds it by meaning, not keyword. No data leaves your machine.
 
 **🧠 Deep Think Engine**
-Before answering complex questions, Miii runs a constrained research phase — reading files, checking git history, searching the web — then synthesizes a grounded answer. Not a hallucination. A conclusion.
+Before answering complex questions, Miii runs a constrained research phase — reading files, checking git history, searching the web — then synthesizes a grounded answer.
 
 **🌐 Real-Time Web Access**
-Tavily-powered web search and page extraction, built in. Ask about breaking changes in a library you just upgraded. Get an answer that's actually current.
+Tavily-powered web search, built in. Ask about breaking changes in a library you just upgraded. Get an answer that's actually current.
 
 **🛠 Surgical File Editing**
-`patch_file` replaces exact strings in your files. No full rewrites. No formatting destruction. No token waste. Exactly the change, nothing more.
+`patch_file` replaces exact strings in your files. No full rewrites. No formatting destruction. Exactly the change, nothing more.
 
-**🔄 Self-Healing Test Loop**
-Miii runs `npm test` after every file change. If something breaks, it reads the failure trace and fixes it autonomously — up to 3 retries before surfacing the issue to you.
+**🔁 Self-Healing Test Loop**
+Runs `npm test` after every file change. If something breaks, reads the failure trace and fixes it autonomously — up to 3 retries before surfacing the issue.
 
 **📂 Persistent Sessions**
-Pick up exactly where you left off. Named sessions mean your context, your history, and your goal survive terminal restarts.
+Pick up exactly where you left off. Named sessions mean your context, history, and goal survive terminal restarts.
 
 **📦 Skill System**
 Extend Miii with plain Markdown files or npm packages. Ship reusable agent behaviors as versioned packages your whole team can pull.
 
----
-
-## The Numbers That Matter
-
-| | **Miii** | Claude Code | Aider |
-|---|:---:|:---:|:---:|
-| Monthly cost | **$0** | $20–200 | $0 |
-| Bundle size | **176 KB** | ~50 MB | ~200 MB |
-| Your code stays local | **✅** | ❌ | ⚠️ |
-| Startup time | **<100ms** | ~2s | ~4s |
-| Semantic codebase index | **✅** | ❌ | ❌ |
-| Deep research mode | **✅** | ❌ | ❌ |
-| Auto test loop | **✅** | ⚠️ | ⚠️ |
-| Works air-gapped | **✅** | ❌ | ❌ |
-| License | **MIT** | Proprietary | Apache 2.0 |
+**🔌 MCP Client**
+Connect any MCP-compatible tool server. Miii discovers tools automatically and makes them available to the agent.
 
 ---
 
@@ -126,7 +146,7 @@ cd your-project
 miii
 ```
 
-That's it. No API keys. No account. No sign-up form.
+No API keys. No account. No sign-up form. First run walks you through setup interactively.
 
 ---
 
@@ -134,6 +154,7 @@ That's it. No API keys. No account. No sign-up form.
 
 | Command | What it does |
 |---|---|
+| `/config` | Open interactive picker — change provider, model, API key, base URL, Tavily key live |
 | `/think <question>` | Deep research: reads files + web, then answers |
 | `/refactor <goal>` | Autonomous multi-file refactor with test validation |
 | `/index build` | Build semantic vector index of your codebase |
@@ -149,7 +170,7 @@ That's it. No API keys. No account. No sign-up form.
 
 ## Semantic Codebase Indexing
 
-For large codebases, Miii can build and query a local vector index — no third-party APIs, no embeddings sent anywhere.
+For large codebases, Miii builds and queries a local vector index — no third-party APIs, no embeddings sent anywhere.
 
 ```bash
 # Pull an embedding model (one time)
@@ -158,17 +179,16 @@ ollama pull nomic-embed-text
 # Index your project
 /index build
 
-# The agent now calls search_codebase automatically
-# when it needs to find code by concept
+# The agent calls search_codebase automatically when it needs to find code by concept
 ```
 
-The agent calls `search_codebase` on its own when needed. You don't have to think about it.
-
 ---
 
 ## Configuration
 
-Drop a `.miii.json` in your project root or `~/.config/miii/config.json` globally:
+**Interactive (recommended):** type `/config` inside Miii to open the picker.
+
+**File-based:** drop a `.miii.json` in your project root or `~/.config/miii/config.json` globally:
 
 ```json
 {
@@ -176,11 +196,12 @@ Drop a `.miii.json` in your project root or `~/.config/miii/config.json` globall
   "provider": "ollama",
   "baseUrl": "http://localhost:11434",
   "gitContext": true,
-  "tavilyApiKey": "tvly-...",
   "embedModel": "nomic-embed-text"
 }
 ```
 
+Providers: `ollama` (local, free) · `anthropic` (Claude API) · `openai-compat` (OpenAI or any compatible endpoint)
+
 ---
 
 ## Build from Source
@@ -192,13 +213,20 @@ cd miii-cli && npm install && npm run build && npm link
 
 ---
 
+## Who Should Use Miii
+
+- **Privacy-conscious developers** — won't send proprietary code to Anthropic or OpenAI
+- **Cost-sensitive teams** — API bills compound; Ollama is $0
+- **Air-gapped environments** — regulated industries, defense, offline infra
+- **Model experimenters** — want to try llama3, mistral, qwen, Claude side-by-side without switching tools
+
+---
+
 ## The Bottom Line
 
 The AI coding tools you're paying for right now will raise their prices, change their terms, and keep reading your code. **Miii won't.** It's MIT licensed, runs locally, and gets better every time Ollama ships a new model.
 
-One engineer built a 176 KB tool that replaces a $200/month cloud product. That shouldn't be a surprise — it should be the baseline.
-
-If this saves you time or money, **star the repo**. It's the only metric that tells other engineers this is worth their attention.
+If this saves you time or money, **star the repo** — it's the only metric that tells other engineers this is worth their attention.
 
 **[⭐ Star on GitHub](https://github.com/maruakshay/miii-cli)**
 

package/dist/config.js

@@ -1,4 +1,4 @@
-import { readFileSync, existsSync } from 'fs';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
 const defaults = {
@@ -9,6 +9,23 @@ const defaults = {
 const ALLOWED_KEYS = new Set(['model', 'provider', 'baseUrl', 'systemPrompt', 'apiKey', 'gitContext', 'tavilyApiKey', 'embedModel']);
 const PROJECT_CONFIG = join(process.cwd(), '.miii.json');
 const GLOBAL_CONFIG = join(homedir(), '.config', 'miii', 'config.json');
+export function saveConfig(config) {
+    mkdirSync(join(homedir(), '.config', 'miii'), { recursive: true });
+    const existing = existsSync(GLOBAL_CONFIG)
+        ? (() => { try {
+            return JSON.parse(readFileSync(GLOBAL_CONFIG, 'utf-8'));
+        }
+        catch {
+            return {};
+        } })()
+        : {};
+    const merged = { ...existing };
+    for (const key of ALLOWED_KEYS) {
+        if (key in config)
+            merged[key] = config[key];
+    }
+    writeFileSync(GLOBAL_CONFIG, JSON.stringify(merged, null, 2), { mode: 0o600 });
+}
 export function loadConfig() {
     const candidates = [PROJECT_CONFIG, GLOBAL_CONFIG];
     for (const p of candidates) {

package/dist/init.js

@@ -11,6 +11,8 @@ import { SkillLoader } from './skills/loader.js';
 import { InputBar } from './tui/InputBar.js';
 import { welcome } from './tui/printer.js';
 import { ensureOllama } from './llm/ollama.js';
+import { loadMCPTools } from './mcp/client.js';
+import { needsSetup, runSetup } from './setup.js';
 const require = createRequire(import.meta.url);
 const UPDATE_CACHE = join(homedir(), '.config', 'miii', 'update-check.json');
 const CHECK_INTERVAL_MS = 6 * 60 * 60 * 1000; // 6h
@@ -71,6 +73,8 @@ export async function lazyInit() {
         boolean: ['update'],
         alias: { m: 'model', u: 'url', p: 'provider', s: 'session' },
     });
+    if (needsSetup())
+        await runSetup();
     const config = loadConfig();
     if (argv.model)
         config.model = argv.model;
@@ -90,9 +94,21 @@ export async function lazyInit() {
         skills.loadAll(),
         checkLatestVersion(currentVersion, !!argv.update),
     ]);
+    // Load MCP servers if configured
+    let mcpTools = [];
+    let mcpClients = [];
+    if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
+        const result = await loadMCPTools(config.mcpServers);
+        mcpTools = result.tools;
+        mcpClients = result.clients;
+        if (mcpTools.length)
+            process.stderr.write(`MCP: loaded ${mcpTools.length} tool(s) from ${mcpClients.length} server(s)\n`);
+    }
     // Print welcome banner to scrollback BEFORE Ink starts
     welcome(config.provider, config.model, process.cwd(), currentVersion, updateAvailable, linked);
     const sessionName = argv.session || `s-${Date.now()}`;
-    const { waitUntilExit } = render(React.createElement(InputBar, { config, skills, cwd: process.cwd(), session: sessionName, version: currentVersion }), { exitOnCtrlC: false });
+    const { waitUntilExit } = render(React.createElement(InputBar, { config, skills, cwd: process.cwd(), session: sessionName, version: currentVersion, mcpTools }), { exitOnCtrlC: false });
     await waitUntilExit();
+    for (const c of mcpClients)
+        c.close();
 }

package/dist/llm/stream.js

@@ -1,4 +1,6 @@
 export async function chat(cfg) {
+    if (cfg.provider === 'anthropic')
+        return chatAnthropic(cfg);
     if (cfg.provider === 'openai-compat')
         return chatOpenAI(cfg);
     return chatOllama(cfg);
@@ -115,6 +117,45 @@ async function chatOpenAI(cfg) {
             onError(toError(err));
     }
 }
+async function chatAnthropic(cfg) {
+    const { model, messages, baseUrl, apiKey, signal, onDone, onError, onUsage } = cfg;
+    const url = baseUrl && baseUrl !== 'http://localhost:11434'
+        ? `${baseUrl}/v1/messages`
+        : 'https://api.anthropic.com/v1/messages';
+    const systemParts = messages.filter(m => m.role === 'system').map(m => m.content);
+    const filtered = messages.filter(m => m.role !== 'system');
+    try {
+        const body = {
+            model,
+            max_tokens: 8192,
+            messages: filtered,
+        };
+        if (systemParts.length)
+            body.system = systemParts.join('\n\n');
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                'x-api-key': apiKey ?? '',
+                'anthropic-version': '2023-06-01',
+            },
+            body: JSON.stringify(body),
+            signal,
+        });
+        if (!res.ok) {
+            onError(new Error(`Anthropic ${res.status}: ${await res.text()}`));
+            return;
+        }
+        const obj = await res.json();
+        const text = (obj.content ?? []).filter(c => c.type === 'text').map(c => c.text).join('');
+        onUsage?.(obj.usage?.input_tokens ?? 0, obj.usage?.output_tokens ?? 0);
+        await onDone(text);
+    }
+    catch (err) {
+        if (err?.name !== 'AbortError')
+            onError(toError(err));
+    }
+}
 function toError(e) {
     return e instanceof Error ? e : new Error(String(e));
 }

package/dist/mcp/client.js

@@ -0,0 +1,110 @@
+import { spawn } from 'child_process';
+import { createInterface } from 'readline';
+function schemaToParams(def) {
+    const props = def.inputSchema?.properties ?? {};
+    const required = new Set(def.inputSchema?.required ?? []);
+    const entries = Object.entries(props).map(([k, v]) => {
+        const t = v?.type ?? 'any';
+        return `"${k}": "${t}${required.has(k) ? '' : ' (optional)'}"`;
+    });
+    return '{' + entries.join(', ') + '}';
+}
+export class MCPClient {
+    proc = null;
+    pending = new Map();
+    nextId = 1;
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+    async connect(cfg) {
+        this.proc = spawn(cfg.command, cfg.args ?? [], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: { ...process.env, ...cfg.env },
+        });
+        this.proc.stderr?.on('data', () => { });
+        const rl = createInterface({ input: this.proc.stdout });
+        rl.on('line', (line) => {
+            if (!line.trim())
+                return;
+            try {
+                const msg = JSON.parse(line);
+                if (msg.id !== undefined) {
+                    const p = this.pending.get(msg.id);
+                    if (p) {
+                        this.pending.delete(msg.id);
+                        if (msg.error)
+                            p.reject(new Error(msg.error.message));
+                        else
+                            p.resolve(msg.result);
+                    }
+                }
+            }
+            catch { }
+        });
+        this.proc.on('error', (err) => {
+            for (const p of this.pending.values())
+                p.reject(err);
+            this.pending.clear();
+        });
+        await this.send('initialize', {
+            protocolVersion: '2024-11-05',
+            capabilities: { tools: {} },
+            clientInfo: { name: 'miii', version: '1.0.0' },
+        });
+        this.proc.stdin.write(JSON.stringify({ jsonrpc: '2.0', method: 'notifications/initialized' }) + '\n');
+    }
+    async listTools() {
+        const result = await this.send('tools/list');
+        return result?.tools ?? [];
+    }
+    async callTool(name, args) {
+        const result = await this.send('tools/call', { name, arguments: args });
+        return (result?.content ?? [])
+            .filter(c => c.type === 'text')
+            .map(c => c.text ?? '')
+            .join('\n');
+    }
+    send(method, params) {
+        return new Promise((resolve, reject) => {
+            const id = this.nextId++;
+            this.pending.set(id, { resolve, reject });
+            this.proc.stdin.write(JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n');
+            setTimeout(() => {
+                if (this.pending.has(id)) {
+                    this.pending.delete(id);
+                    reject(new Error(`MCP timeout: ${method}`));
+                }
+            }, 10_000);
+        });
+    }
+    close() {
+        this.proc?.kill();
+    }
+}
+export async function loadMCPTools(servers) {
+    const clients = [];
+    const tools = [];
+    for (const [serverName, cfg] of Object.entries(servers)) {
+        const client = new MCPClient(serverName);
+        try {
+            await client.connect(cfg);
+            const defs = await client.listTools();
+            clients.push(client);
+            for (const def of defs) {
+                const toolName = `mcp_${serverName}_${def.name}`.replace(/[^a-zA-Z0-9_]/g, '_');
+                tools.push({
+                    name: toolName,
+                    description: `[MCP:${serverName}] ${def.description ?? def.name}`,
+                    params: schemaToParams(def),
+                    execute: async (args) => client.callTool(def.name, args),
+                });
+            }
+        }
+        catch (err) {
+            process.stderr.write(`MCP server "${serverName}" failed to connect: ${err}\n`);
+            client.close();
+        }
+    }
+    return { tools, clients };
+}

package/dist/setup.js

@@ -0,0 +1,183 @@
+import { createInterface } from 'readline';
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+const GLOBAL_CONFIG = join(homedir(), '.config', 'miii', 'config.json');
+const R = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const CYAN = '\x1b[96m';
+const GREEN = '\x1b[92m';
+const GRAY = '\x1b[90m';
+const YELLOW = '\x1b[93m';
+const PURPLE = '\x1b[95m';
+const WHITE = '\x1b[97m';
+const b = (s) => `${BOLD}${s}${R}`;
+const cy = (s) => `${CYAN}${s}${R}`;
+const gr = (s) => `${GRAY}${s}${R}`;
+const gn = (s) => `${GREEN}${s}${R}`;
+const yw = (s) => `${YELLOW}${s}${R}`;
+const wh = (s) => `${WHITE}${s}${R}`;
+const dim = (s) => `${DIM}${s}${R}`;
+const PROVIDERS = [
+    { key: 'ollama', label: 'Ollama', desc: 'local · free · air-gapped' },
+    { key: 'anthropic', label: 'Anthropic', desc: 'Claude API (cloud)' },
+    { key: 'openai-compat', label: 'OpenAI / Custom', desc: 'OpenAI or compatible endpoint' },
+];
+const MODEL_SUGGESTIONS = {
+    'ollama': ['qwen2.5-coder:7b', 'llama3.2', 'deepseek-r1:7b', 'codellama:13b'],
+    'anthropic': ['claude-sonnet-4-6', 'claude-opus-4-7', 'claude-haiku-4-5-20251001'],
+    'openai-compat': ['gpt-4o', 'gpt-4o-mini', 'o1-mini'],
+};
+const w = process.stdout.write.bind(process.stdout);
+const ln = (s = '') => w(s + '\n');
+function divider() {
+    ln(gr('  ' + '─'.repeat(46)));
+}
+export function needsSetup() {
+    return !existsSync(GLOBAL_CONFIG);
+}
+export async function runSetup() {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (prompt) => new Promise(resolve => rl.question(prompt, ans => resolve(ans.trim())));
+    // ── Header ────────────────────────────────────────────────────────────────
+    ln();
+    ln(`  ${PURPLE}${BOLD}●  ●${R}`);
+    ln(`  ${PURPLE}${BOLD}╲●╱${R}   ${b(wh('Miii'))}  ${gr('first-time setup')}`);
+    ln();
+    // ── Provider ──────────────────────────────────────────────────────────────
+    ln(yw(b('  Provider')));
+    divider();
+    for (let i = 0; i < PROVIDERS.length; i++) {
+        const p = PROVIDERS[i];
+        ln(`  ${cy(b(String(i + 1)))}  ${wh(p.label.padEnd(16))}  ${gr(dim(p.desc))}`);
+    }
+    ln();
+    let providerKey = 'ollama';
+    while (true) {
+        const raw = await ask(`  ${cy('›')} ${gr('[1–3]: ')}`);
+        const choice = raw || '1';
+        const idx = parseInt(choice, 10) - 1;
+        if (idx >= 0 && idx < PROVIDERS.length) {
+            providerKey = PROVIDERS[idx].key;
+            w(`  ${gn('✓')} ${wh(PROVIDERS[idx].label)}\n`);
+            break;
+        }
+        ln(gr('  enter 1, 2, or 3'));
+    }
+    ln();
+    // ── Credentials / URL ─────────────────────────────────────────────────────
+    let apiKey;
+    let baseUrl = 'http://localhost:11434';
+    if (providerKey === 'anthropic') {
+        ln(yw(b('  API Key')));
+        divider();
+        ln(gr('  console.anthropic.com → API Keys'));
+        ln();
+        while (true) {
+            const raw = await ask(`  ${cy('›')} sk-ant-...: `);
+            if (raw.startsWith('sk-ant-') || raw.startsWith('sk-')) {
+                apiKey = raw;
+                ln(`  ${gn('✓')} key saved`);
+                break;
+            }
+            ln(gr('  key should start with sk-ant-'));
+        }
+        baseUrl = 'https://api.anthropic.com';
+        ln();
+    }
+    if (providerKey === 'openai-compat') {
+        ln(yw(b('  Endpoint')));
+        divider();
+        const rawUrl = await ask(`  ${cy('›')} Base URL ${gr('[https://api.openai.com]')}: `);
+        baseUrl = rawUrl || 'https://api.openai.com';
+        ln();
+        const rawKey = await ask(`  ${cy('›')} API key ${gr('(optional)')}: `);
+        if (rawKey) {
+            apiKey = rawKey;
+            ln(`  ${gn('✓')} key saved`);
+        }
+        else {
+            ln(`  ${gr('─')} no key set`);
+        }
+        ln();
+    }
+    if (providerKey === 'ollama') {
+        // Try default URL silently; only ask if unreachable
+        try {
+            await fetch('http://localhost:11434/api/tags', { signal: AbortSignal.timeout(2000) });
+        }
+        catch {
+            ln(yw(b('  Ollama URL')));
+            divider();
+            ln(gr('  Could not reach http://localhost:11434'));
+            ln();
+            const rawUrl = await ask(`  ${cy('›')} URL ${gr('[http://localhost:11434]')}: `);
+            baseUrl = rawUrl || 'http://localhost:11434';
+            ln(`  ${gn('✓')} ${baseUrl}`);
+            ln();
+        }
+    }
+    // ── Model ─────────────────────────────────────────────────────────────────
+    ln(yw(b('  Model')));
+    divider();
+    let suggestions = MODEL_SUGGESTIONS[providerKey] ?? [];
+    if (providerKey === 'ollama') {
+        try {
+            const res = await fetch(`${baseUrl}/api/tags`, { signal: AbortSignal.timeout(4000) });
+            if (res.ok) {
+                const data = await res.json();
+                const pulled = (data.models ?? []).map(m => m.name).filter(Boolean);
+                if (pulled.length)
+                    suggestions = pulled;
+            }
+        }
+        catch { }
+        if (!suggestions.length) {
+            ln(gr('  No models found — enter name manually (e.g. qwen2.5-coder:7b)'));
+            ln();
+            const rawModel = await ask(`  ${cy('›')} model name: `);
+            const model = rawModel || 'qwen2.5-coder:7b';
+            ln(`  ${gn('✓')} ${model}`);
+            ln();
+            rl.close();
+            return saveConfig({ provider: 'ollama', model, baseUrl, apiKey });
+        }
+    }
+    for (let i = 0; i < suggestions.length; i++) {
+        ln(`  ${cy(b(String(i + 1).padStart(2)))}  ${suggestions[i]}`);
+    }
+    ln();
+    const defaultModel = suggestions[0] ?? 'llama3.2';
+    let model = defaultModel;
+    while (true) {
+        const raw = await ask(`  ${cy('›')} ${gr(`[1–${suggestions.length} or name]: `)}`);
+        if (!raw)
+            break;
+        const idx = parseInt(raw, 10) - 1;
+        if (idx >= 0 && idx < suggestions.length) {
+            model = suggestions[idx];
+            break;
+        }
+        if (raw.length > 0) {
+            model = raw;
+            break;
+        }
+    }
+    ln(`  ${gn('✓')} ${model}`);
+    ln();
+    rl.close();
+    return saveConfig({ provider: providerKey, model, baseUrl, apiKey });
+}
+function saveConfig(cfg) {
+    const config = { provider: cfg.provider, model: cfg.model, baseUrl: cfg.baseUrl };
+    if (cfg.apiKey)
+        config.apiKey = cfg.apiKey;
+    mkdirSync(join(homedir(), '.config', 'miii'), { recursive: true });
+    writeFileSync(GLOBAL_CONFIG, JSON.stringify(config, null, 2), { mode: 0o600 });
+    const w = process.stdout.write.bind(process.stdout);
+    const gr = (s) => `\x1b[90m${s}\x1b[0m`;
+    const gn = (s) => `\x1b[92m${s}\x1b[0m`;
+    w(`  ${gn('✓')} config saved  ${gr(GLOBAL_CONFIG)}\n\n`);
+    return config;
+}