@dcl-regenesislabs/opendcl 0.1.0-22234509684.commit-63dfd19

package/extensions/dcl-header.ts

@@ -0,0 +1,162 @@
+/**
+ * Custom header extension for OpenDCL.
+ * Shows a block-character "Decentraland" ASCII art header with version
+ * and working directory. Falls back to a compact text header on narrow terminals.
+ * Also auto-sets quietStartup in user settings to suppress raw file path listing.
+ */
+
+import type { ExtensionFactory } from "@mariozechner/pi-coding-agent";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/** Block-character "Decentraland" art — Small Mono 12 figlet style, 7 lines. */
+const HEADER_ART: string[] = [
+  "▗▄▄                                     ▗▄▖               ▗▖",
+  "▐▛▀█                      ▐▌            ▝▜▌               ▐▌",
+  "▐▌ ▐▌ ▟█▙  ▟██▖ ▟█▙ ▐▙██▖▐███  █▟█▌ ▟██▖ ▐▌   ▟██▖▐▙██▖ ▟█▟▌",
+  "▐▌ ▐▌▐▙▄▟▌▐▛  ▘▐▙▄▟▌▐▛ ▐▌ ▐▌   █▘   ▘▄▟▌ ▐▌   ▘▄▟▌▐▛ ▐▌▐▛ ▜▌",
+  "▐▌ ▐▌▐▛▀▀▘▐▌   ▐▛▀▀▘▐▌ ▐▌ ▐▌   █   ▗█▀▜▌ ▐▌  ▗█▀▜▌▐▌ ▐▌▐▌ ▐▌",
+  "▐▙▄█ ▝█▄▄▌▝█▄▄▌▝█▄▄▌▐▌ ▐▌ ▐▙▄  █   ▐▙▄█▌ ▐▙▄ ▐▙▄█▌▐▌ ▐▌▝█▄█▌",
+  "▝▀▀   ▝▀▀  ▝▀▀  ▝▀▀ ▝▘ ▝▘  ▀▀  ▀    ▀▀▝▘  ▀▀  ▀▀▝▘▝▘ ▝▘ ▝▀▝▘",
+];
+
+/** Minimum terminal width to show the full block-character art. */
+const MIN_ART_WIDTH = 65;
+
+export function getVersion(): string {
+  try {
+    const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
+    return pkg.version || "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+
+/**
+ * Reads skill directories and extracts the `name` field
+ * from each SKILL.md YAML frontmatter.
+ */
+export function getSkillNames(skillsDir: string): string[] {
+  try {
+    const entries = readdirSync(skillsDir, { withFileTypes: true });
+    const names: string[] = [];
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const skillPath = join(skillsDir, entry.name, "SKILL.md");
+      try {
+        const content = readFileSync(skillPath, "utf-8");
+        const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+        if (match) {
+          const nameMatch = match[1].match(/^name:\s*(.+)$/m);
+          if (nameMatch) {
+            names.push(nameMatch[1].trim());
+            continue;
+          }
+        }
+        // Fallback to directory name if frontmatter parsing fails
+        names.push(entry.name);
+      } catch {
+        // Skip skills that can't be read
+      }
+    }
+
+    return names.sort();
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Ensures quietStartup is set in the user's settings file.
+ * Creates the settings file if it doesn't exist.
+ * If quietStartup is already set (to any value), leaves it alone.
+ */
+export function ensureQuietStartup(settingsPath: string): void {
+  try {
+    const dir = dirname(settingsPath);
+    mkdirSync(dir, { recursive: true });
+
+    if (existsSync(settingsPath)) {
+      const raw = readFileSync(settingsPath, "utf-8");
+      const settings = JSON.parse(raw);
+      if (!("quietStartup" in settings)) {
+        settings.quietStartup = true;
+        writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+      }
+    } else {
+      writeFileSync(settingsPath, JSON.stringify({ quietStartup: true }, null, 2) + "\n", "utf-8");
+    }
+  } catch {
+    // Settings write failure should not break startup
+  }
+}
+
+/** Shorten an absolute path by replacing the user's home directory with `~`. */
+export function shortenPath(path: string): string {
+  const home = homedir();
+  if (path === home) return "~";
+  if (path.startsWith(home + "/")) return "~" + path.slice(home.length);
+  return path;
+}
+
+const extension: ExtensionFactory = (pi) => {
+  pi.on("session_start", async (_event, ctx) => {
+    // Auto-set quietStartup in user settings
+    const settingsPath = join(homedir(), ".opendcl", "agent", "settings.json");
+    ensureQuietStartup(settingsPath);
+
+    if (!ctx.hasUI) return;
+
+    const version = getVersion();
+    const cwd = ctx.cwd;
+
+    ctx.ui.setHeader((_tui, theme) => ({
+      render(width: number): string[] {
+        if (width >= MIN_ART_WIDTH) {
+          const lines: string[] = [];
+
+          // Block-character art in accent color
+          for (const line of HEADER_ART) {
+            lines.push(theme.fg("accent", line));
+          }
+
+          // "by RegenesisLabs" right-aligned under the art
+          const tag = "by RegenesisLabs";
+          const artWidth = HEADER_ART[2].length; // widest line
+          const pad = Math.max(0, artWidth - tag.length);
+          lines.push(" ".repeat(pad) + theme.fg("dim", tag));
+
+          // Blank line
+          lines.push("");
+
+          // Version line
+          lines.push(
+            theme.bold(theme.fg("accent", "OpenDCL")) +
+              theme.fg("dim", ` v${version} — AI assistant for Decentraland SDK7`),
+          );
+
+          // Working directory
+          lines.push(theme.fg("dim", shortenPath(cwd)));
+
+          return lines;
+        }
+
+        // Narrow terminal fallback — compact 2-line header
+        return [
+          theme.bold(theme.fg("accent", "OpenDCL")) +
+            theme.fg("dim", ` v${version} — AI assistant for Decentraland SDK7`),
+          theme.fg("dim", shortenPath(cwd)),
+        ];
+      },
+      invalidate() {},
+    }));
+  });
+};
+
+export default extension;

package/extensions/dcl-init.ts

@@ -0,0 +1,62 @@
+/**
+ * DCL Init Extension
+ *
+ * Registers the `init` tool (LLM-callable) and `/init` command that scaffolds
+ * a new Decentraland scene project using `npx @dcl/sdk-commands init`.
+ */
+
+import type { ExtensionFactory } from "@mariozechner/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import { join } from "node:path";
+import { fileExists } from "./scene-utils.js";
+
+async function initScene(
+  cwd: string,
+  pi: { exec(cmd: string, args: string[], opts?: unknown): Promise<{ code: number; stdout: string; stderr: string }> }
+): Promise<{ message: string; isError?: boolean }> {
+  if (await fileExists(join(cwd, "scene.json"))) {
+    return { message: "A scene.json already exists in this directory. Aborting to prevent overwriting.", isError: true };
+  }
+
+  try {
+    const result = await pi.exec("npx", ["@dcl/sdk-commands", "init", "--skip-install"], {
+      cwd,
+      timeout: 60000,
+    });
+
+    if (result.code === 0) {
+      return { message: "Scene initialized! Run 'npm install' to install dependencies, then use the preview tool to start." };
+    } else {
+      return { message: `Init failed (exit code ${result.code}): ${result.stderr || result.stdout}`, isError: true };
+    }
+  } catch (err) {
+    return { message: `Failed to initialize scene: ${err instanceof Error ? err.message : String(err)}`, isError: true };
+  }
+}
+
+const extension: ExtensionFactory = (pi) => {
+  pi.registerTool({
+    name: "init",
+    label: "Init Scene",
+    description:
+      "Initialize a new Decentraland SDK7 scene. Scaffolds scene.json, package.json, tsconfig.json, and src/index.ts. Use when user wants to create or start a new scene.",
+    parameters: Type.Object({}),
+    async execute(_id, _params, _signal, _onUpdate, ctx) {
+      const result = await initScene(ctx.cwd, pi);
+      if (!result.isError) await ctx.reload();
+      return { content: [{ type: "text" as const, text: result.message }], details: undefined };
+    },
+  });
+
+  pi.registerCommand("init", {
+    description: "Initialize a new Decentraland scene project in the current directory",
+    handler: async (_args, ctx) => {
+      ctx.ui.notify("Initializing new Decentraland scene...", "info");
+      const result = await initScene(ctx.cwd, pi);
+      ctx.ui.notify(result.message, result.isError ? "error" : "info");
+      if (!result.isError) await ctx.reload();
+    },
+  });
+};
+
+export default extension;

package/extensions/dcl-preview.ts

@@ -0,0 +1,144 @@
+/**
+ * DCL Preview Extension
+ *
+ * Registers the `preview` tool (LLM-callable) and `/preview` command that starts
+ * the Decentraland development server using `npx @dcl/sdk-commands start --bevy-web`.
+ * Registers with the shared process registry so it can be managed via /tasks.
+ */
+
+import type { ExtensionFactory } from "@mariozechner/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import { join } from "node:path";
+import { spawn, type ChildProcess } from "node:child_process";
+import { processes } from "./process-registry.js";
+import { fileExists, findSceneRoot } from "./scene-utils.js";
+import { updateStatus } from "./dcl-tasks.js";
+
+export function selectPreviewUrl(
+  output: string,
+  bevyUrlAlreadyFound: boolean
+): { url: string; shouldNotify: boolean } | null {
+  const urls = [...output.matchAll(/https?:\/\/[^\s]+/g)].map((m) => m[0]);
+  if (urls.length === 0) return null;
+
+  const bevyUrl = urls.find((u) => u.includes("decentraland.zone/bevy-web"));
+  if (bevyUrl) return { url: bevyUrl, shouldNotify: true };
+
+  if (!bevyUrlAlreadyFound) return { url: urls[0], shouldNotify: false };
+
+  return null;
+}
+
+interface PreviewContext {
+  ui: {
+    notify(message: string, type?: string): void;
+    setStatus(key: string, text: string | undefined): void;
+  };
+}
+
+const extension: ExtensionFactory = (pi) => {
+  let previewProcess: ChildProcess | null = null;
+
+  function cleanupPreview(): void {
+    if (previewProcess && !previewProcess.killed) {
+      previewProcess.kill();
+    }
+    previewProcess = null;
+    processes.delete("preview");
+  }
+
+  async function startPreviewServer(
+    cwd: string,
+    ctx: PreviewContext
+  ): Promise<{ message: string; isError?: boolean }> {
+    const sceneRoot = await findSceneRoot(cwd);
+
+    if (!sceneRoot) {
+      return { message: "No scene.json found. Create a scene first with /init.", isError: true };
+    }
+
+    if (!(await fileExists(join(sceneRoot, "node_modules")))) {
+      return { message: "node_modules not found. Run 'npm install' first.", isError: true };
+    }
+
+    cleanupPreview();
+
+    try {
+      previewProcess = spawn("npx", ["@dcl/sdk-commands", "start", "--bevy-web"], {
+        cwd: sceneRoot,
+        stdio: "pipe",
+        shell: true,
+      });
+
+      processes.set("preview", {
+        name: "Preview server",
+        kill: cleanupPreview,
+      });
+      updateStatus(ctx);
+
+      let bevyUrlFound = false;
+
+      function handleOutput(data: Buffer): void {
+        const output = data.toString().trim();
+        if (output.includes("EADDRINUSE") || output.includes("address already in use")) {
+          ctx.ui.notify("Port already in use. Try /tasks to stop existing servers.", "error");
+          return;
+        }
+        const result = selectPreviewUrl(output, bevyUrlFound);
+        if (result) {
+          if (result.shouldNotify) bevyUrlFound = true;
+          processes.set("preview", {
+            name: "Preview server",
+            info: result.url,
+            kill: cleanupPreview,
+          });
+          if (result.shouldNotify) {
+            ctx.ui.notify(`Preview server running at ${result.url}`, "info");
+          }
+          updateStatus(ctx);
+        }
+      }
+
+      previewProcess.stdout?.on("data", handleOutput);
+      previewProcess.stderr?.on("data", handleOutput);
+
+      previewProcess.on("error", (err) => {
+        ctx.ui.notify(`Failed to start preview: ${err.message}`, "error");
+      });
+
+      previewProcess.on("exit", (code) => {
+        if (code !== 0 && code !== null) {
+          ctx.ui.notify(`Preview server exited with code ${code}`, "warning");
+        }
+        cleanupPreview();
+        updateStatus(ctx);
+      });
+
+      return { message: `Preview server starting in ${sceneRoot}` };
+    } catch (err) {
+      return { message: `Failed to start preview: ${err instanceof Error ? err.message : String(err)}`, isError: true };
+    }
+  }
+
+  pi.registerTool({
+    name: "preview",
+    label: "Preview",
+    description:
+      "Start the Decentraland preview server. Use when the user wants to preview, run, test, or see their scene.",
+    parameters: Type.Object({}),
+    async execute(_id, _params, _signal, _onUpdate, ctx) {
+      const result = await startPreviewServer(ctx.cwd, ctx);
+      return { content: [{ type: "text" as const, text: result.message }], details: undefined };
+    },
+  });
+
+  pi.registerCommand("preview", {
+    description: "Start the Decentraland preview server",
+    handler: async (_args, ctx) => {
+      const result = await startPreviewServer(ctx.cwd, ctx);
+      ctx.ui.notify(result.message, result.isError ? "error" : "info");
+    },
+  });
+};
+
+export default extension;

package/extensions/dcl-setup-ollama.ts

@@ -0,0 +1,312 @@
+/**
+ * DCL Setup Ollama Extension
+ *
+ * Registers the /setup-ollama command that walks users through
+ * model selection and configuration for a free local LLM setup.
+ * On session start, nudges users who have no provider configured.
+ */
+
+import type { ExtensionFactory } from "@mariozechner/pi-coding-agent";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+import { spawn } from "node:child_process";
+
+interface OllamaProvider {
+  baseUrl?: string;
+  api?: string;
+  apiKey?: string;
+  models?: { id: string }[];
+}
+
+const API_KEY_ENV_VARS = [
+  "ANTHROPIC_API_KEY",
+  "OPENAI_API_KEY",
+  "GOOGLE_API_KEY",
+  "OPENROUTER_API_KEY",
+];
+
+export const OLLAMA_MODELS = [
+  { id: "qwen2.5-coder:32b", label: "qwen2.5-coder:32b (Recommended — best coding benchmarks, ~18GB)" },
+  { id: "qwen3-coder:30b", label: "qwen3-coder:30b (Latest Alibaba coder, 256K context, ~19GB)" },
+  { id: "devstral:24b", label: "devstral:24b (Mistral coding agent model, ~14GB)" },
+  { id: "glm-4.7-flash", label: "glm-4.7-flash (Reasoning + code generation, ~25GB)" },
+];
+
+async function readJsonFile<T>(path: string, fallback: T): Promise<T> {
+  try {
+    const content = await readFile(path, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return fallback;
+  }
+}
+
+async function writeJsonFile(path: string, data: unknown): Promise<void> {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+
+export async function writeModelsConfig(modelsPath: string, modelId: string): Promise<void> {
+  const config = await readJsonFile<{ providers?: Record<string, unknown> }>(modelsPath, {});
+  config.providers ??= {};
+
+  const ollama = config.providers.ollama as OllamaProvider | undefined;
+  if (ollama) {
+    ollama.models ??= [];
+    if (!ollama.models.some((m) => m.id === modelId)) {
+      ollama.models.push({ id: modelId });
+    }
+  } else {
+    config.providers.ollama = {
+      baseUrl: "http://localhost:11434/v1",
+      api: "openai-completions",
+      apiKey: "ollama",
+      models: [{ id: modelId }],
+    };
+  }
+
+  await writeJsonFile(modelsPath, config);
+}
+
+export async function setDefaultModel(settingsPath: string, provider: string, modelId: string): Promise<void> {
+  const settings = await readJsonFile<Record<string, unknown>>(settingsPath, {});
+
+  settings.defaultProvider = provider;
+  settings.defaultModel = modelId;
+
+  await writeJsonFile(settingsPath, settings);
+}
+
+export async function isProviderConfigured(): Promise<boolean> {
+  if (API_KEY_ENV_VARS.some((v) => process.env[v])) {
+    return true;
+  }
+
+  const configDir = join(homedir(), ".opendcl", "agent");
+
+  const modelsConfig = await readJsonFile<{ providers?: Record<string, unknown> }>(join(configDir, "models.json"), {});
+  if (modelsConfig.providers != null && Object.keys(modelsConfig.providers).length > 0) {
+    return true;
+  }
+
+  const authConfig = await readJsonFile<Record<string, unknown>>(join(configDir, "auth.json"), {});
+  return Object.keys(authConfig).length > 0;
+}
+
+export function parseOllamaList(output: string): string[] {
+  const lines = output.split(/\r?\n/).filter((l) => l.trim());
+  // Skip header line (starts with "NAME")
+  const dataLines = lines.filter((l) => !l.startsWith("NAME"));
+  return dataLines
+    .map((l) => l.split(/\s+/)[0])
+    .filter(Boolean)
+    .map((name) => name.replace(/:latest$/, ""));
+}
+
+export async function removeOllamaModel(
+  modelsPath: string,
+  settingsPath: string,
+  modelId: string,
+): Promise<void> {
+  const config = await readJsonFile<{ providers?: Record<string, unknown> }>(modelsPath, {});
+  const ollama = config.providers?.ollama as OllamaProvider | undefined;
+  if (ollama?.models) {
+    ollama.models = ollama.models.filter((m) => m.id !== modelId);
+    if (ollama.models.length === 0) {
+      delete config.providers!.ollama;
+    }
+    await writeJsonFile(modelsPath, config);
+  }
+
+  const settings = await readJsonFile<Record<string, unknown>>(settingsPath, {});
+  if (settings.defaultProvider === "ollama" && settings.defaultModel === modelId) {
+    delete settings.defaultProvider;
+    delete settings.defaultModel;
+    await writeJsonFile(settingsPath, settings);
+  }
+}
+
+/**
+ * Run ollama commands through the user's login shell so the full PATH is used.
+ * (pi.exec without shell won't find binaries added by installers to profile files.)
+ */
+function ollamaExec(pi: Parameters<ExtensionFactory>[0], args: string, timeout = 10000) {
+  const shell = process.env.SHELL || "/bin/sh";
+  return pi.exec(shell, ["-lc", `ollama ${args}`], { timeout }).catch(() => null);
+}
+
+function stripAnsi(text: string): string {
+  return text.replace(/\x1b\[[\x30-\x3f]*[\x20-\x2f]*[\x40-\x7e]/g, "");
+}
+
+/**
+ * Extract a clean, human-readable progress line from raw ollama pull output.
+ * Ollama outputs ANSI-heavy terminal UI — this strips escape codes and
+ * picks the most informative line (percentage progress > phase labels).
+ */
+export function extractPullProgress(raw: string): string | null {
+  const clean = stripAnsi(raw);
+  const lines = clean.split(/\r\n|\r|\n/).map((l) => l.trim()).filter(Boolean);
+  // Prefer the line with download percentage (e.g. "pulling abc123:  45%  8 GB/18 GB  12 MB/s")
+  const progress = lines.findLast((l) => /\d+%/.test(l));
+  if (progress) return progress;
+  // Fall back to phase lines like "pulling manifest", "verifying sha256 digest"
+  const phase = lines.findLast((l) => /^(pulling|verifying|writing|success)/.test(l));
+  return phase ?? null;
+}
+
+/**
+ * Pull a model with streaming progress via spawn.
+ * Throttles notifications to avoid UI spam (one update every 2 seconds max).
+ */
+export function ollamaPull(
+  modelId: string,
+  onProgress: (line: string) => void,
+): Promise<{ success: boolean; error?: string }> {
+  return new Promise((resolve) => {
+    const shell = process.env.SHELL || "/bin/sh";
+    const child = spawn(shell, ["-lc", `ollama pull ${modelId}`], {
+      stdio: "pipe",
+    });
+
+    let lastNotify = 0;
+    let lastLine = "";
+    let errorOutput = "";
+
+    function handleData(data: Buffer): void {
+      const text = data.toString();
+      errorOutput += text;
+      const line = extractPullProgress(text);
+      if (!line) return;
+      lastLine = line;
+      const now = Date.now();
+      if (now - lastNotify >= 2000) {
+        lastNotify = now;
+        onProgress(line);
+      }
+    }
+
+    child.stdout?.on("data", handleData);
+    child.stderr?.on("data", handleData);
+
+    child.on("error", (err) => {
+      resolve({ success: false, error: err.message });
+    });
+
+    child.on("exit", (code) => {
+      if (lastLine) onProgress(lastLine);
+      if (code === 0) {
+        resolve({ success: true });
+      } else {
+        resolve({ success: false, error: stripAnsi(errorOutput).slice(-500) });
+      }
+    });
+  });
+}
+
+const extension: ExtensionFactory = (pi) => {
+  pi.on("session_start", async (_event, ctx) => {
+    if (!(await isProviderConfigured())) {
+      ctx.ui.notify(
+        "Get started by running /setup (cloud providers) or /setup-ollama (free local models)",
+        "warning",
+      );
+      return;
+    }
+
+    const configDir = join(homedir(), ".opendcl", "agent");
+    const settingsPath = join(configDir, "settings.json");
+    const settings = await readJsonFile<Record<string, unknown>>(settingsPath, {});
+    if (settings.defaultProvider !== "ollama") return;
+
+    const defaultModel = settings.defaultModel as string | undefined;
+    if (!defaultModel) return;
+
+    const listResult = await ollamaExec(pi, "list");
+    if (!listResult || listResult.code !== 0) return;
+
+    const installed = parseOllamaList(listResult.stdout || "");
+    if (installed.includes(defaultModel)) return;
+
+    const modelsPath = join(configDir, "models.json");
+    await removeOllamaModel(modelsPath, settingsPath, defaultModel);
+    ctx.ui.notify(
+      `Model '${defaultModel}' is no longer installed in Ollama. Run /setup-ollama to configure a new model.`,
+      "warning",
+    );
+  });
+
+  pi.registerCommand("setup-ollama", {
+    description: "Configure Ollama as your free local LLM provider",
+    handler: async (_args, ctx) => {
+      const configDir = join(homedir(), ".opendcl", "agent");
+
+      const versionResult = await ollamaExec(pi, "--version");
+      if (!versionResult || versionResult.code !== 0) {
+        ctx.ui.notify("Ollama is not installed. Download it from https://ollama.com then run /setup-ollama again.", "warning");
+        return;
+      }
+
+      const listResult = await ollamaExec(pi, "list");
+      if (!listResult || listResult.code !== 0) {
+        ctx.ui.notify("Ollama is installed but not running. Start it with 'ollama serve', then run /setup-ollama again.", "warning");
+        return;
+      }
+
+      const installed = parseOllamaList(listResult.stdout || "");
+      const theme = ctx.ui.theme;
+      const sorted = [...OLLAMA_MODELS].sort((a, b) => {
+        const aInstalled = installed.includes(a.id) ? 0 : 1;
+        const bInstalled = installed.includes(b.id) ? 0 : 1;
+        return aInstalled - bInstalled;
+      });
+      const labels = sorted.map((m) =>
+        installed.includes(m.id)
+          ? `${m.label} ${theme.fg("success", "● ready")}`
+          : `${m.label} ${theme.fg("dim", "○ needs download")}`,
+      );
+
+      const selected = await ctx.ui.select("Which model do you want to use?", labels);
+      if (!selected) {
+        ctx.ui.notify("Setup cancelled.", "info");
+        return;
+      }
+
+      const model = sorted.find((m) => selected.startsWith(m.label));
+      if (!model) {
+        ctx.ui.notify("Invalid selection.", "error");
+        return;
+      }
+
+      const alreadyInstalled = installed.includes(model.id);
+      if (!alreadyInstalled) {
+        ctx.ui.setStatus("pull", `Pulling ${model.id}...`);
+        const pullResult = await ollamaPull(model.id, (line) => {
+          ctx.ui.setStatus("pull", line);
+        });
+        ctx.ui.setStatus("pull", undefined);
+        if (!pullResult.success) {
+          ctx.ui.notify(`Failed to pull model: ${pullResult.error || "unknown error"}`, "error");
+          return;
+        }
+      }
+      ctx.ui.notify("Model ready.", "info");
+
+      const modelsPath = join(configDir, "models.json");
+      await writeModelsConfig(modelsPath, model.id);
+
+      const settingsPath = join(configDir, "settings.json");
+      await setDefaultModel(settingsPath, "ollama", model.id);
+
+      ctx.ui.notify(
+        `Ollama configured: ${model.id}. Reloading...`,
+        "info",
+      );
+      await ctx.reload();
+      return;
+    },
+  });
+};
+
+export default extension;