Add ask command, update README, default to gpt-oss

README.md

···
-# Local AI Coding Environment
-
-A fully offline, privacy-first AI coding setup for macOS Apple Silicon. Uses **llama.cpp** to run **Qwen 2.5 Coder** models locally, with **Aider** and **OpenCode** as terminal-based coding agents — no API keys, no cloud, no costs.
-
-## Hardware Requirements
-
-- **Mac with Apple Silicon** (M1/M2/M3/M4)
-- **32GB RAM** recommended (the 32B model uses ~20GB)
-- ~25GB free disk space for models
-
-## What Gets Installed
-
-| Component | Purpose |
-|---|---|
-| **llama.cpp** | Local model inference with Metal GPU acceleration |
-| **Qwen 2.5 Coder 32B** (Q4_K_M) | Main chat/coding model (~20GB) |
-| **Qwen 2.5 Coder 1.5B** (Q4_K_M) | Fast autocomplete model (~1.2GB) |
-| **Aider** | Terminal coding agent (Claude Code alternative) |
-| **jq** | JSON processing for the pipe command |
+# localcode
 
-Both models are served via llama.cpp's built-in OpenAI-compatible API, making them work with any tool that supports the OpenAI API format.
+Fully offline AI coding environment for macOS Apple Silicon. Uses **Ollama** to serve local models with **10 terminal coding agents** — no API keys, no cloud, no costs.
 
-## Installation
+## Quick Start
 
 ```bash
-chmod +x setup.sh
-./setup.sh
+npm run build
+npm run dev -- setup     # installs Ollama, pulls models, sets up configs
+localcode                # launch with defaults
 ```
 
-The script is idempotent — safe to run multiple times. The first run downloads ~21GB of model weights from HuggingFace.
-
-After installation, restart your shell or run:
+## Usage
 
 ```bash
-source ~/.zshrc
-```
-
-## Commands
-
-### `llama-start`
-
-Starts both llama.cpp servers in the foreground. Press `Ctrl+C` to stop both.
-
-- Chat model (32B): `http://127.0.0.1:8080`
-- Autocomplete model (1.5B): `http://127.0.0.1:8081`
-
-### `llama-stop`
-
-Kills all running llama-server processes.
-
-### `ai-code [directory]`
-
-The main coding agent. Auto-starts the chat server if it's not running. Initializes a git repo if one doesn't exist, then launches Aider with full file-editing capabilities.
+localcode                          # launch with last-used TUI + model
+localcode goose                    # launch with Goose
+localcode claude                   # launch with Claude Code
+localcode gpt-oss                  # launch with GPT-OSS model
+localcode goose gpt-oss            # launch with both overrides
 
-```bash
-cd ~/projects/my-app
-ai-code .
+localcode models                   # list available models
+localcode tuis                     # list available TUIs
+localcode status                   # show config + Ollama health
 
-# or from anywhere
-ai-code ~/projects/my-app
+localcode start                    # start Ollama + pull models
+localcode stop                     # stop Ollama
+localcode bench                    # benchmark the active chat model
+localcode pipe "add type hints"    # pipe stdin through the model
 ```
 
-Inside Aider you can ask it to edit files, run commands, and refactor code across your project. Changes are auto-committed to git so you can always roll back.
+TUI and model names are auto-detected — just type the id directly. Last-used choices are saved for next time.
 
-### `ai-ask "question"`
+## TUIs
 
-Quick Q&A mode — no file editing, just chat. Useful for coding questions without modifying your project.
+TUIs with `ollama launch` support are installed and configured automatically by Ollama.
 
-```bash
-ai-ask "how do I handle errors in rust"
-```
+| TUI | Launch | Method |
+|-----|--------|--------|
+| Claude Code | `localcode claude` | ollama launch |
+| Codex CLI | `localcode codex` | ollama launch |
+| OpenCode | `localcode opencode` | ollama launch |
+| Pi | `localcode pi` | ollama launch |
+| Cline | `localcode cline` | ollama launch |
+| Droid | `localcode droid` | ollama launch |
+| OpenClaw | `localcode openclaw` | ollama launch |
+| Aider | `localcode aider` | direct (env vars) |
+| Goose | `localcode goose` | direct (env vars) |
+| gptme | `localcode gptme` | direct (env vars) |
 
-### `ai-pipe "prompt"`
+## Models
 
-Pipe code through the model via stdin. Useful for one-shot transforms in scripts.
+| Model | ID | Size | Tool Calling | Notes |
+|-------|----|------|-------------|-------|
+| Qwen3 Coder 30B-A3B | `qwen3-coder` | 19 GB | Yes | Best coding benchmarks (SWE-bench 69.6) |
+| GLM-4.7 Flash 30B-A3B | `glm-flash` | 19 GB | Yes | Strong coding, 198K context |
+| GPT-OSS 20B | `gpt-oss` | 14 GB | Yes | Lightest with tool support, good for 32GB machines |
+| Qwen 2.5 Coder 32B | `qwen-32b-chat` | 20 GB | No | Dense model, no structured tool calls |
+| Qwen 2.5 Coder 14B | `qwen-14b-chat` | 9 GB | No | Smallest chat model |
+| Qwen 2.5 Coder 7B | `qwen-7b-chat` | 5 GB | No | Lightest chat model |
+| Qwen 2.5 Coder 1.5B | `qwen-1.5b-autocomplete` | 1 GB | No | Autocomplete only |
 
-```bash
-cat main.py | ai-pipe "add type hints"
-git diff | ai-pipe "write a commit message"
-cat api.go | ai-pipe "find bugs"
-```
+Models without tool calling will output raw tool-call text in agents that rely on structured tool use (Goose, Pi, etc.). Use gpt-oss, qwen3-coder, or glm-flash for those agents.
 
-## Using OpenCode Instead of Aider
+## Hardware Requirements
 
-[OpenCode](https://opencode.ai) is another terminal coding agent with a polished TUI. It connects to the same llama.cpp backend.
-
-### Install OpenCode
-
-```bash
-brew install anomalyco/tap/opencode
-```
+- **Mac with Apple Silicon** (M1/M2/M3/M4)
+- **32 GB RAM** recommended
+- Disk space depends on models pulled
 
-### Configure
+## Configuration
 
-Create `~/.config/opencode/opencode.json`:
-
-```json
-{
-  "$schema": "https://opencode.ai/config.json",
-  "model": "llama-cpp/qwen2.5-coder-32b",
-  "provider": {
-    "llama-cpp": {
-      "npm": "@ai-sdk/openai-compatible",
-      "name": "llama.cpp (local)",
-      "options": {
-        "baseURL": "http://127.0.0.1:8080/v1",
-        "apiKey": "not-needed"
-      },
-      "models": {
-        "qwen2.5-coder-32b": {
-          "name": "Qwen 2.5 Coder 32B",
-          "tools": true
-        }
-      }
-    }
-  }
-}
-```
-
-### Run
-
-```bash
-llama-start        # start the server (or ai-code auto-starts it)
-opencode           # launch OpenCode in your project directory
-```
-
-Use `/models` inside OpenCode to select the Qwen model, and `Tab` to switch between Plan and Build modes.
-
-## Configuration Files
-
-| File | Purpose |
-|---|---|
-| `~/.aider/aider.conf.yml` | Aider settings (model, git, UI) |
-| `~/.aider/.env` | API base URL and key for Aider |
-| `~/.config/opencode/opencode.json` | OpenCode provider config |
-| `~/.local/share/llama-models/` | Downloaded GGUF model files |
-| `~/.local/bin/` | Launcher scripts |
-
-## llama.cpp Server Flags
-
-The chat server launches with these defaults:
-
-| Flag | Value | Purpose |
-|---|---|---|
-| `--ctx-size` | 16384 | Context window (increase to 32768 if tools misbehave) |
-| `--n-gpu-layers` | 99 | Offload all layers to Metal GPU |
-| `--flash-attn` | — | Enable flash attention for speed |
-| `--mlock` | — | Lock model in RAM to prevent swapping |
-| `--threads` | auto | Uses performance core count |
-
-## Troubleshooting
-
-**Model loading is slow on first run**: The first inference after starting the server takes 10–30 seconds while the model loads into memory. Subsequent requests are fast.
-
-**Running out of RAM / swapping**: The 32B Q4 model needs ~20GB. Close memory-heavy apps. You can also try the smaller `qwen2.5-coder-14b-instruct-q4_k_m.gguf` instead.
-
-**OpenCode tools not working**: Increase `--ctx-size` to 32768 in the `llama-chat-server` script. Tool-calling needs more context to work reliably.
-
-**Slow generation speed**: Expect ~15–25 tokens/sec on the 32B model with M4. This is normal for a model this size running locally. The 1.5B autocomplete model runs much faster.
-
-**Server won't start**: Check if another process is using port 8080 or 8081 with `lsof -i :8080`. Use `llama-stop` to kill stale processes.
-
-## Performance Expectations
-
-| Model | Speed | Use Case |
-|---|---|---|
-| Qwen 2.5 Coder 32B | ~15–25 tok/s | Chat, code generation, refactoring |
-| Qwen 2.5 Coder 1.5B | ~100+ tok/s | Autocomplete, quick suggestions |
-
-Both models run entirely on-device using Metal acceleration. No network connection required after initial setup.
+All stored in `~/.config/localcode/config.json` — just the active model, autocomplete model, and TUI ids. Ollama manages model storage.
 
 ## Uninstall
 
 ```bash
-# Remove models (~21GB)
-rm -rf ~/.local/share/llama-models
-
-# Remove launcher scripts
-rm ~/.local/bin/{ai-code,ai-ask,ai-pipe,llama-start,llama-stop,llama-chat-server,llama-complete-server}
-
-# Remove configs
-rm -rf ~/.aider
-rm -f ~/.config/opencode/opencode.json
-
-# Remove Ollama auto-start (if set)
-launchctl unload ~/Library/LaunchAgents/com.ollama.serve.plist
-rm ~/Library/LaunchAgents/com.ollama.serve.plist
-
-# Uninstall packages
-pipx uninstall aider-chat
-brew uninstall llama.cpp jq
+brew uninstall ollama          # remove Ollama + all pulled models
+rm ~/.local/bin/localcode      # remove CLI wrapper
+rm -rf ~/.config/localcode     # remove config
 ```

src/commands/ask.ts

···
+import { OLLAMA_URL } from "../config.js";
+import { getActiveChatModel } from "../runtime-config.js";
+import { err } from "../log.js";
+import { ensureOllama } from "./server.js";
+
+export async function runAsk(question: string): Promise<void> {
+  await ensureOllama();
+  const model = getActiveChatModel();
+
+  const body = JSON.stringify({
+    model: model.ollamaTag,
+    messages: [
+      {
+        role: "system",
+        content:
+          "You are an expert programmer. Give concise, practical answers. Include code examples when helpful.",
+      },
+      { role: "user", content: question },
+    ],
+    stream: true,
+  });
+
+  let res: Response;
+  try {
+    res = await fetch(`${OLLAMA_URL}/v1/chat/completions`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body,
+    });
+  } catch {
+    err("Ollama not running. Start it with: localcode start");
+  }
+
+  if (!res!.ok) {
+    err(`Server returned ${res!.status}`);
+  }
+
+  // Stream the response
+  const reader = res!.body?.getReader();
+  if (!reader) {
+    err("No response body");
+  }
+
+  const decoder = new TextDecoder();
+  let buffer = "";
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop()!;
+
+    for (const line of lines) {
+      if (!line.startsWith("data: ")) continue;
+      const data = line.slice(6);
+      if (data === "[DONE]") continue;
+      try {
+        const json = JSON.parse(data) as {
+          choices?: { delta?: { content?: string } }[];
+        };
+        const content = json.choices?.[0]?.delta?.content;
+        if (content) process.stdout.write(content);
+      } catch {
+        // skip malformed chunks
+      }
+    }
+  }
+  process.stdout.write("\n");
+}

src/commands/pipe.ts

···
 import { OLLAMA_URL } from "../config.js";
 import { getActiveChatModel } from "../runtime-config.js";
 import { err } from "../log.js";
+import { ensureOllama } from "./server.js";
 
 export async function runPipe(prompt: string): Promise<void> {
+  await ensureOllama();
   const model = getActiveChatModel();
 
   // Read stdin

src/main.ts

···
 import { showStatus } from "./commands/status.js";
 import { startServers, stopServers } from "./commands/server.js";
 import { runPipe } from "./commands/pipe.js";
+import { runAsk } from "./commands/ask.js";
 import { getTuiById } from "./registry/tuis.js";
 import { getModelById } from "./registry/models.js";
 
···
   localcode bench                           Benchmark the running chat model
   localcode bench history                   Show past benchmark results
 
+${BOLD}Quick:${RESET}
+  localcode ask "question"                  Quick coding Q&A (streamed)
+  localcode pipe "prompt"                   Pipe stdin through the model
+
 ${BOLD}Other:${RESET}
-  localcode pipe "prompt"                   Pipe stdin through the model
   localcode setup                           Full install (Ollama, models, tools)
 `);
 }
···
       } else {
         await runBench(process.argv.slice(3));
       }
+      break;
+    }
+
+    case "ask": {
+      const question = process.argv.slice(3).join(" ");
+      if (!question) {
+        console.error("Usage: localcode ask \"question\"");
+        process.exit(1);
+      }
+      await runAsk(question);
       break;
     }
 

src/runtime-config.ts

···
 const CONFIG_PATH = join(homedir(), ".config", "localcode", "config.json");
 
 const DEFAULTS: RuntimeConfig = {
-  chatModel: "qwen3-coder",
+  chatModel: "gpt-oss",
   autocompleteModel: "qwen-1.5b-autocomplete",
   tui: "aider",
 };