gsd-pi 2.58.0 → 2.59.0-dev.3de3832

package/src/resources/extensions/ollama/ollama-commands.ts

@@ -0,0 +1,248 @@
+// GSD2 — Ollama slash commands
+
+/**
+ * Registers /ollama slash commands for managing local Ollama models.
+ *
+ * Commands:
+ *   /ollama          — Show status (running?, version, loaded models)
+ *   /ollama list     — List all available local models with sizes
+ *   /ollama pull     — Pull a model with progress
+ *   /ollama remove   — Delete a local model
+ *   /ollama ps       — Show running models and resource usage
+ */
+
+import type { ExtensionAPI } from "@gsd/pi-coding-agent";
+import { Text } from "@gsd/pi-tui";
+import * as client from "./ollama-client.js";
+import { discoverModels, formatModelForDisplay } from "./ollama-discovery.js";
+import { formatModelSize } from "./model-capabilities.js";
+
+export function registerOllamaCommands(pi: ExtensionAPI): void {
+	pi.registerCommand("ollama", {
+		description: "Manage local Ollama models — list | pull | remove | ps",
+		async handler(args, ctx) {
+			const parts = (args ?? "").trim().split(/\s+/);
+			const subcommand = parts[0] || "status";
+			const modelArg = parts.slice(1).join(" ");
+
+			switch (subcommand) {
+				case "status":
+					return await handleStatus(ctx);
+				case "list":
+				case "ls":
+					return await handleList(ctx);
+				case "pull":
+					return await handlePull(modelArg, ctx);
+				case "remove":
+				case "rm":
+				case "delete":
+					return await handleRemove(modelArg, ctx);
+				case "ps":
+					return await handlePs(ctx);
+				default:
+					ctx.ui.notify(
+						`Unknown subcommand: ${subcommand}. Use: status, list, pull, remove, ps`,
+						"warning",
+					);
+			}
+		},
+	});
+}
+
+async function handleStatus(ctx: any): Promise<void> {
+	const running = await client.isRunning();
+	if (!running) {
+		ctx.ui.notify(
+			"Ollama is not running. Install from https://ollama.com and run 'ollama serve'",
+			"warning",
+		);
+		return;
+	}
+
+	const version = await client.getVersion();
+	const lines: string[] = [];
+	lines.push(`Ollama${version ? ` v${version}` : ""} — running (${client.getOllamaHost()})`);
+
+	// Show loaded models
+	try {
+		const ps = await client.getRunningModels();
+		if (ps.models && ps.models.length > 0) {
+			lines.push("");
+			lines.push("Loaded:");
+			for (const m of ps.models) {
+				const vram = m.size_vram > 0 ? formatModelSize(m.size_vram) + " VRAM" : "CPU";
+				const expiresAt = new Date(m.expires_at);
+				const idleMs = expiresAt.getTime() - Date.now();
+				const idleMin = Math.max(0, Math.floor(idleMs / 60000));
+				lines.push(`  ${m.name}  ${vram}  expires in ${idleMin}m`);
+			}
+		}
+	} catch {
+		// ps endpoint may not be available on older versions
+	}
+
+	// Show available models
+	try {
+		const models = await discoverModels();
+		if (models.length > 0) {
+			lines.push("");
+			lines.push("Available:");
+			for (const m of models) {
+				lines.push(`  ${formatModelForDisplay(m)}`);
+			}
+		} else {
+			lines.push("");
+			lines.push("No models pulled. Use /ollama pull <model> to get started.");
+		}
+	} catch (err) {
+		lines.push("");
+		lines.push(`Error listing models: ${err instanceof Error ? err.message : String(err)}`);
+	}
+
+	await ctx.ui.custom(
+		(tui: any, theme: any, _kb: any, done: (r: undefined) => void) => {
+			const text = new Text(lines.map((l) => theme.fg("fg", l)).join("\n"), 0, 0);
+			setTimeout(() => done(undefined), 0);
+			return text;
+		},
+	);
+}
+
+async function handleList(ctx: any): Promise<void> {
+	const running = await client.isRunning();
+	if (!running) {
+		ctx.ui.notify("Ollama is not running", "warning");
+		return;
+	}
+
+	const models = await discoverModels();
+	if (models.length === 0) {
+		ctx.ui.notify("No models available. Use /ollama pull <model> to download one.", "info");
+		return;
+	}
+
+	const lines = ["Local Ollama models:", ""];
+	for (const m of models) {
+		lines.push(`  ${formatModelForDisplay(m)}`);
+	}
+
+	await ctx.ui.custom(
+		(tui: any, theme: any, _kb: any, done: (r: undefined) => void) => {
+			const text = new Text(lines.map((l) => theme.fg("fg", l)).join("\n"), 0, 0);
+			setTimeout(() => done(undefined), 0);
+			return text;
+		},
+	);
+}
+
+async function handlePull(modelName: string, ctx: any): Promise<void> {
+	if (!modelName) {
+		ctx.ui.notify("Usage: /ollama pull <model> (e.g. /ollama pull llama3.1:8b)", "warning");
+		return;
+	}
+
+	const running = await client.isRunning();
+	if (!running) {
+		ctx.ui.notify("Ollama is not running", "warning");
+		return;
+	}
+
+	ctx.ui.setWidget("ollama-pull", [`Pulling ${modelName}...`]);
+
+	try {
+		let lastPercent = -1;
+		await client.pullModel(modelName, (progress) => {
+			if (progress.total && progress.completed) {
+				const percent = Math.floor((progress.completed / progress.total) * 100);
+				if (percent !== lastPercent) {
+					lastPercent = percent;
+					const completed = formatModelSize(progress.completed);
+					const total = formatModelSize(progress.total);
+					ctx.ui.setWidget("ollama-pull", [
+						`Pulling ${modelName}... ${percent}% (${completed} / ${total})`,
+					]);
+				}
+			} else if (progress.status) {
+				ctx.ui.setWidget("ollama-pull", [`${modelName}: ${progress.status}`]);
+			}
+		});
+
+		ctx.ui.setWidget("ollama-pull", undefined);
+		ctx.ui.notify(`${modelName} pulled successfully`, "success");
+	} catch (err) {
+		ctx.ui.setWidget("ollama-pull", undefined);
+		ctx.ui.notify(
+			`Failed to pull ${modelName}: ${err instanceof Error ? err.message : String(err)}`,
+			"error",
+		);
+	}
+}
+
+async function handleRemove(modelName: string, ctx: any): Promise<void> {
+	if (!modelName) {
+		ctx.ui.notify("Usage: /ollama remove <model>", "warning");
+		return;
+	}
+
+	const running = await client.isRunning();
+	if (!running) {
+		ctx.ui.notify("Ollama is not running", "warning");
+		return;
+	}
+
+	const confirmed = await ctx.ui.confirm(
+		"Delete model",
+		`Are you sure you want to delete ${modelName}?`,
+	);
+
+	if (!confirmed) return;
+
+	try {
+		await client.deleteModel(modelName);
+		ctx.ui.notify(`${modelName} deleted`, "success");
+	} catch (err) {
+		ctx.ui.notify(
+			`Failed to delete ${modelName}: ${err instanceof Error ? err.message : String(err)}`,
+			"error",
+		);
+	}
+}
+
+async function handlePs(ctx: any): Promise<void> {
+	const running = await client.isRunning();
+	if (!running) {
+		ctx.ui.notify("Ollama is not running", "warning");
+		return;
+	}
+
+	try {
+		const ps = await client.getRunningModels();
+		if (!ps.models || ps.models.length === 0) {
+			ctx.ui.notify("No models currently loaded in memory", "info");
+			return;
+		}
+
+		const lines = ["Running models:", ""];
+		for (const m of ps.models) {
+			const vram = m.size_vram > 0 ? formatModelSize(m.size_vram) + " VRAM" : "CPU only";
+			const totalSize = formatModelSize(m.size);
+			const expiresAt = new Date(m.expires_at);
+			const idleMs = expiresAt.getTime() - Date.now();
+			const idleMin = Math.max(0, Math.floor(idleMs / 60000));
+			lines.push(`  ${m.name}  ${totalSize}  ${vram}  expires in ${idleMin}m`);
+		}
+
+		await ctx.ui.custom(
+			(tui: any, theme: any, _kb: any, done: (r: undefined) => void) => {
+				const text = new Text(lines.map((l) => theme.fg("fg", l)).join("\n"), 0, 0);
+				setTimeout(() => done(undefined), 0);
+				return text;
+			},
+		);
+	} catch (err) {
+		ctx.ui.notify(
+			`Failed to get running models: ${err instanceof Error ? err.message : String(err)}`,
+			"error",
+		);
+	}
+}

package/src/resources/extensions/ollama/ollama-discovery.ts

@@ -0,0 +1,106 @@
+// GSD2 — Ollama model discovery and capability detection
+
+/**
+ * Discovers locally available Ollama models and enriches them with
+ * capability metadata (context window, vision, reasoning) from the
+ * known model table and /api/show responses.
+ *
+ * Returns models in the format expected by pi.registerProvider().
+ */
+
+import { listModels, getOllamaHost } from "./ollama-client.js";
+import {
+	estimateContextFromParams,
+	formatModelSize,
+	getModelCapabilities,
+	humanizeModelName,
+} from "./model-capabilities.js";
+import type { OllamaModelInfo } from "./types.js";
+
+export interface DiscoveredOllamaModel {
+	id: string;
+	name: string;
+	reasoning: boolean;
+	input: ("text" | "image")[];
+	cost: { input: number; output: number; cacheRead: number; cacheWrite: number };
+	contextWindow: number;
+	maxTokens: number;
+	/** Raw size in bytes for display purposes */
+	sizeBytes: number;
+	/** Parameter size string from Ollama (e.g. "7B") */
+	parameterSize: string;
+}
+
+const ZERO_COST = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+
+function enrichModel(info: OllamaModelInfo): DiscoveredOllamaModel {
+	const caps = getModelCapabilities(info.name);
+	const parameterSize = info.details?.parameter_size ?? "";
+
+	// Determine context window: known table > estimate from param size > default
+	const contextWindow =
+		caps.contextWindow ??
+		(parameterSize ? estimateContextFromParams(parameterSize) : 8192);
+
+	// Determine max tokens: known table > fraction of context > default
+	const maxTokens =
+		caps.maxTokens ?? Math.min(Math.floor(contextWindow / 4), 16384);
+
+	// Detect vision from families or known table
+	const hasVision =
+		caps.input?.includes("image") ??
+		(info.details?.families?.some((f) => f === "clip" || f === "mllama") ?? false);
+
+	// Detect reasoning from known table
+	const reasoning = caps.reasoning ?? false;
+
+	return {
+		id: info.name,
+		name: humanizeModelName(info.name),
+		reasoning,
+		input: hasVision ? ["text", "image"] : ["text"],
+		cost: ZERO_COST,
+		contextWindow,
+		maxTokens,
+		sizeBytes: info.size,
+		parameterSize,
+	};
+}
+
+/**
+ * Discover all locally available Ollama models with enriched capabilities.
+ */
+export async function discoverModels(): Promise<DiscoveredOllamaModel[]> {
+	const tags = await listModels();
+	if (!tags.models || tags.models.length === 0) return [];
+
+	return tags.models.map(enrichModel);
+}
+
+/**
+ * Format a discovered model for display in model list.
+ */
+export function formatModelForDisplay(model: DiscoveredOllamaModel): string {
+	const parts = [model.id];
+
+	if (model.sizeBytes > 0) {
+		parts.push(`(${formatModelSize(model.sizeBytes)})`);
+	}
+
+	const flags: string[] = [];
+	if (model.reasoning) flags.push("reasoning");
+	if (model.input.includes("image")) flags.push("vision");
+
+	if (flags.length > 0) {
+		parts.push(`[${flags.join(", ")}]`);
+	}
+
+	return parts.join(" ");
+}
+
+/**
+ * Build the OpenAI-compat base URL for Ollama.
+ */
+export function getOllamaOpenAIBaseUrl(): string {
+	return `${getOllamaHost()}/v1`;
+}

package/src/resources/extensions/ollama/ollama-tool.ts

@@ -0,0 +1,218 @@
+// GSD2 — LLM-callable Ollama management tool
+/**
+ * Registers an ollama_manage tool that the LLM can call to interact
+ * with the local Ollama instance — list models, pull new ones, check status.
+ */
+
+import type { ExtensionAPI } from "@gsd/pi-coding-agent";
+import { Text } from "@gsd/pi-tui";
+import { Type } from "@sinclair/typebox";
+import * as client from "./ollama-client.js";
+import { discoverModels, formatModelForDisplay } from "./ollama-discovery.js";
+import { formatModelSize } from "./model-capabilities.js";
+
+interface OllamaToolDetails {
+	action: string;
+	model?: string;
+	modelCount?: number;
+	durationMs: number;
+	error?: string;
+}
+
+export function registerOllamaTool(pi: ExtensionAPI): void {
+	pi.registerTool({
+		name: "ollama_manage",
+		label: "Ollama",
+		description:
+			"Manage local Ollama models. List available models, pull new ones, " +
+			"check Ollama status, or see running models and resource usage. " +
+			"Use this when you need a specific local model that isn't available yet.",
+		promptSnippet: "Manage local Ollama models (list, pull, status, ps)",
+		promptGuidelines: [
+			"Use 'list' to see what models are available locally before trying to use one.",
+			"Use 'pull' to download a model that isn't available yet.",
+			"Use 'status' to check if Ollama is running.",
+			"Use 'ps' to see which models are loaded in memory and VRAM usage.",
+			"Common models: llama3.1:8b, qwen2.5-coder:7b, deepseek-r1:8b, codestral:22b",
+		],
+		parameters: Type.Object({
+			action: Type.Union(
+				[
+					Type.Literal("list"),
+					Type.Literal("pull"),
+					Type.Literal("status"),
+					Type.Literal("ps"),
+				],
+				{ description: "Action to perform" },
+			),
+			model: Type.Optional(
+				Type.String({ description: "Model name (required for pull)" }),
+			),
+		}),
+
+		async execute(_toolCallId, params, signal, onUpdate, _ctx) {
+			const startTime = Date.now();
+			const { action, model } = params;
+
+			try {
+				switch (action) {
+					case "status": {
+						const running = await client.isRunning();
+						if (!running) {
+							return {
+								content: [{ type: "text", text: "Ollama is not running. It needs to be started with 'ollama serve'." }],
+								details: { action, durationMs: Date.now() - startTime } as OllamaToolDetails,
+							};
+						}
+						const version = await client.getVersion();
+						return {
+							content: [{ type: "text", text: `Ollama${version ? ` v${version}` : ""} is running at ${client.getOllamaHost()}` }],
+							details: { action, durationMs: Date.now() - startTime } as OllamaToolDetails,
+						};
+					}
+
+					case "list": {
+						const running = await client.isRunning();
+						if (!running) {
+							return {
+								content: [{ type: "text", text: "Ollama is not running." }],
+								isError: true,
+								details: { action, durationMs: Date.now() - startTime, error: "not_running" } as OllamaToolDetails,
+							};
+						}
+
+						const models = await discoverModels();
+						if (models.length === 0) {
+							return {
+								content: [{ type: "text", text: "No models available. Pull one with action='pull'." }],
+								details: { action, modelCount: 0, durationMs: Date.now() - startTime } as OllamaToolDetails,
+							};
+						}
+
+						const lines = models.map((m) => formatModelForDisplay(m));
+						return {
+							content: [{ type: "text", text: `Available models:\n${lines.join("\n")}` }],
+							details: { action, modelCount: models.length, durationMs: Date.now() - startTime } as OllamaToolDetails,
+						};
+					}
+
+					case "pull": {
+						if (!model) {
+							return {
+								content: [{ type: "text", text: "Error: 'model' parameter is required for pull action." }],
+								isError: true,
+								details: { action, durationMs: Date.now() - startTime, error: "missing_model" } as OllamaToolDetails,
+							};
+						}
+
+						const running = await client.isRunning();
+						if (!running) {
+							return {
+								content: [{ type: "text", text: "Ollama is not running." }],
+								isError: true,
+								details: { action, model, durationMs: Date.now() - startTime, error: "not_running" } as OllamaToolDetails,
+							};
+						}
+
+						let lastStatus = "";
+						await client.pullModel(model, (progress) => {
+							if (progress.total && progress.completed) {
+								const pct = Math.floor((progress.completed / progress.total) * 100);
+								const status = `Pulling ${model}... ${pct}%`;
+								if (status !== lastStatus) {
+									lastStatus = status;
+									onUpdate?.({ content: [{ type: "text", text: status }], details: { action, model, durationMs: Date.now() - startTime } as OllamaToolDetails });
+								}
+							} else if (progress.status && progress.status !== lastStatus) {
+								lastStatus = progress.status;
+								onUpdate?.({ content: [{ type: "text", text: `${model}: ${progress.status}` }], details: { action, model, durationMs: Date.now() - startTime } as OllamaToolDetails });
+							}
+						}, signal);
+
+						return {
+							content: [{ type: "text", text: `Successfully pulled ${model}` }],
+							details: { action, model, durationMs: Date.now() - startTime } as OllamaToolDetails,
+						};
+					}
+
+					case "ps": {
+						const running = await client.isRunning();
+						if (!running) {
+							return {
+								content: [{ type: "text", text: "Ollama is not running." }],
+								isError: true,
+								details: { action, durationMs: Date.now() - startTime, error: "not_running" } as OllamaToolDetails,
+							};
+						}
+
+						const ps = await client.getRunningModels();
+						if (!ps.models || ps.models.length === 0) {
+							return {
+								content: [{ type: "text", text: "No models currently loaded in memory." }],
+								details: { action, modelCount: 0, durationMs: Date.now() - startTime } as OllamaToolDetails,
+							};
+						}
+
+						const lines = ps.models.map((m) => {
+							const vram = m.size_vram > 0 ? `${formatModelSize(m.size_vram)} VRAM` : "CPU";
+							return `${m.name} — ${formatModelSize(m.size)} total, ${vram}`;
+						});
+
+						return {
+							content: [{ type: "text", text: `Loaded models:\n${lines.join("\n")}` }],
+							details: { action, modelCount: ps.models.length, durationMs: Date.now() - startTime } as OllamaToolDetails,
+						};
+					}
+
+					default:
+						return {
+							content: [{ type: "text", text: `Unknown action: ${action}` }],
+							isError: true,
+							details: { action, durationMs: Date.now() - startTime, error: "unknown_action" } as OllamaToolDetails,
+						};
+				}
+			} catch (err) {
+				const msg = err instanceof Error ? err.message : String(err);
+				return {
+					content: [{ type: "text", text: `Ollama error: ${msg}` }],
+					isError: true,
+					details: { action, model, durationMs: Date.now() - startTime, error: msg } as OllamaToolDetails,
+				};
+			}
+		},
+
+		renderCall(args, theme) {
+			let text = theme.fg("toolTitle", theme.bold("ollama "));
+			text += theme.fg("accent", args.action);
+			if (args.model) {
+				text += theme.fg("dim", ` ${args.model}`);
+			}
+			return new Text(text, 0, 0);
+		},
+
+		renderResult(result, { isPartial, expanded }, theme) {
+			const d = result.details as OllamaToolDetails | undefined;
+
+			if (isPartial) return new Text(theme.fg("warning", "Working..."), 0, 0);
+			if ((result as any).isError || d?.error) {
+				return new Text(theme.fg("error", `Error: ${d?.error ?? "unknown"}`), 0, 0);
+			}
+
+			let text = theme.fg("success", d?.action ?? "done");
+			if (d?.modelCount !== undefined) {
+				text += theme.fg("dim", ` (${d.modelCount} models)`);
+			}
+			text += theme.fg("dim", ` ${d?.durationMs ?? 0}ms`);
+
+			if (expanded) {
+				const content = result.content[0];
+				if (content?.type === "text") {
+					const preview = content.text.split("\n").slice(0, 10).join("\n");
+					text += "\n\n" + theme.fg("dim", preview);
+				}
+			}
+
+			return new Text(text, 0, 0);
+		},
+	});
+}