gsd-pi 2.33.0-dev.bafba33 → 2.33.1-dev.235d83a

package/dist/resources/extensions/voice/index.ts

@@ -1,272 +0,0 @@
-import type { ExtensionAPI, ExtensionContext } from "@gsd/pi-coding-agent";
-import { shortcutDesc } from "../shared/mod.js";
-import type { AssistantMessage } from "@gsd/pi-ai";
-import { isKeyRelease, Key, matchesKey, truncateToWidth, visibleWidth } from "@gsd/pi-tui";
-import { spawn, execSync, type ChildProcess } from "node:child_process";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as readline from "node:readline";
-
-const __extensionDir = import.meta.dirname!;
-const SWIFT_SRC = path.join(__extensionDir, "speech-recognizer.swift");
-const RECOGNIZER_BIN = path.join(__extensionDir, "speech-recognizer");
-const PYTHON_SCRIPT = path.join(__extensionDir, "speech-recognizer.py");
-
-const IS_DARWIN = process.platform === "darwin";
-const IS_LINUX = process.platform === "linux";
-const VOICE_VENV_PYTHON = path.join(
-	process.env.HOME || process.env.USERPROFILE || "/tmp",
-	".gsd",
-	"voice-venv",
-	"bin",
-	"python3",
-);
-
-/** Return the python3 binary path — prefer venv if it exists, else system. */
-function linuxPython(): string {
-	if (fs.existsSync(VOICE_VENV_PYTHON)) return VOICE_VENV_PYTHON;
-	return "python3";
-}
-
-function ensureBinary(): boolean {
-	if (fs.existsSync(RECOGNIZER_BIN)) return true;
-	try {
-		execSync(`swiftc "${SWIFT_SRC}" -o "${RECOGNIZER_BIN}" -framework Speech -framework AVFoundation`, {
-			timeout: 60000,
-		});
-		return true;
-	} catch {
-		return false;
-	}
-}
-
-let linuxReady = false;
-
-function ensureLinuxReady(ctx: ExtensionContext): boolean {
-	if (linuxReady) return true;
-
-	// Check GROQ_API_KEY is available
-	if (!process.env.GROQ_API_KEY) {
-		ctx.ui.notify("Voice: GROQ_API_KEY not set — run 'gsd config' to configure", "error");
-		return false;
-	}
-
-	// Check python3 exists
-	try {
-		execSync("which python3", { stdio: "pipe" });
-	} catch {
-		ctx.ui.notify("Voice: python3 not found — install with: sudo apt install python3", "error");
-		return false;
-	}
-
-	// Check that sounddevice is importable
-	const py = linuxPython();
-	try {
-		execSync(`${py} -c "import sounddevice"`, {
-			stdio: "pipe",
-			timeout: 10000,
-		});
-	} catch (err: unknown) {
-		const stderr = (err as { stderr?: Buffer })?.stderr?.toString() ?? "";
-		if (stderr.includes("sounddevice") || stderr.includes("PortAudio") || stderr.includes("portaudio")) {
-			ctx.ui.notify("Voice: install libportaudio2 with: sudo apt install libportaudio2", "error");
-		} else if (stderr.includes("No module") || stderr.includes("ModuleNotFoundError")) {
-			// Deps missing — the Python script handles auto-install on first run,
-			// so we let it through. The script's own ensure_deps() will pip install.
-			ctx.ui.notify("Voice: installing dependencies on first run — this may take a moment", "info");
-			linuxReady = true;
-			return true;
-		} else {
-			ctx.ui.notify(`Voice: dependency check failed — ${stderr.split("\n")[0] || "unknown error"}`, "error");
-			return false;
-		}
-		return false;
-	}
-
-	linuxReady = true;
-	return true;
-}
-
-export default function (pi: ExtensionAPI) {
-	if (!IS_DARWIN && !IS_LINUX) return;
-
-	let active = false;
-	let recognizerProcess: ChildProcess | null = null;
-	let flashOn = true;
-	let flashTimer: ReturnType<typeof setInterval> | null = null;
-	let footerTui: { requestRender: () => void } | null = null;
-
-	function setVoiceFooter(ctx: ExtensionContext, on: boolean) {
-		if (!on) {
-			stopFlash();
-			ctx.ui.setFooter(undefined);
-			return;
-		}
-
-		flashOn = true;
-		flashTimer = setInterval(() => {
-			flashOn = !flashOn;
-			footerTui?.requestRender();
-		}, 500);
-
-		ctx.ui.setFooter((tui, theme, footerData) => {
-			footerTui = tui;
-			const branchUnsub = footerData.onBranchChange(() => tui.requestRender());
-
-			return {
-				dispose: branchUnsub,
-				invalidate() {},
-				render(width: number): string[] {
-					// Row 1: pwd (branch) ... ● transcribing
-					let pwd = process.cwd();
-					const home = process.env.HOME || process.env.USERPROFILE;
-					if (home && pwd.startsWith(home)) pwd = `~${pwd.slice(home.length)}`;
-					const branch = footerData.getGitBranch();
-					if (branch) pwd = `${pwd} (${branch})`;
-
-					const dot = flashOn ? theme.fg("error", "●") : theme.fg("dim", "●");
-					const voiceTag = `${dot} ${theme.fg("error", "transcribing")}`;
-					const voiceTagWidth = visibleWidth(voiceTag);
-
-					const maxPwdWidth = width - voiceTagWidth - 2;
-					const pwdStr = truncateToWidth(theme.fg("dim", pwd), maxPwdWidth, theme.fg("dim", "..."));
-					const pad1 = " ".repeat(Math.max(1, width - visibleWidth(pwdStr) - voiceTagWidth));
-					const row1 = truncateToWidth(pwdStr + pad1 + voiceTag, width);
-
-					// Row 2: stats ... model
-					let totalInput = 0, totalOutput = 0, totalCost = 0;
-					for (const entry of ctx.sessionManager.getEntries()) {
-						if (entry.type === "message" && entry.message.role === "assistant") {
-							const m = entry.message as AssistantMessage;
-							totalInput += m.usage.input;
-							totalOutput += m.usage.output;
-							totalCost += m.usage.cost.total;
-						}
-					}
-
-					const fmt = (n: number) => n < 1000 ? `${n}` : n < 10000 ? `${(n / 1000).toFixed(1)}k` : `${Math.round(n / 1000)}k`;
-					const parts: string[] = [];
-					if (totalInput) parts.push(`↑${fmt(totalInput)}`);
-					if (totalOutput) parts.push(`↓${fmt(totalOutput)}`);
-					if (totalCost) parts.push(`$${totalCost.toFixed(3)}`);
-
-					const usage = ctx.getContextUsage();
-					const ctxPct = usage?.percent !== null && usage?.percent !== undefined ? `${usage.percent.toFixed(1)}%` : "?";
-					const ctxWin = usage?.contextWindow ?? ctx.model?.contextWindow ?? 0;
-					parts.push(`${ctxPct}/${fmt(ctxWin)}`);
-
-					const statsLeft = theme.fg("dim", parts.join(" "));
-					const modelRight = theme.fg("dim", ctx.model?.id || "no-model");
-					const statsLeftW = visibleWidth(statsLeft);
-					const modelRightW = visibleWidth(modelRight);
-					const pad2 = " ".repeat(Math.max(2, width - statsLeftW - modelRightW));
-					const row2 = truncateToWidth(statsLeft + pad2 + modelRight, width);
-
-					return [row1, row2];
-				},
-			};
-		});
-	}
-
-	function stopFlash() {
-		if (flashTimer) { clearInterval(flashTimer); flashTimer = null; }
-		footerTui = null;
-	}
-
-	async function toggleVoice(ctx: ExtensionContext) {
-		if (active) {
-			killRecognizer();
-			active = false;
-			setVoiceFooter(ctx, false);
-			return;
-		}
-
-		if (IS_DARWIN) {
-			if (!ensureBinary()) {
-				ctx.ui.notify("Voice: failed to compile speech recognizer (need Xcode CLI tools)", "error");
-				return;
-			}
-		} else if (IS_LINUX) {
-			if (!ensureLinuxReady(ctx)) {
-				return;
-			}
-		}
-
-		active = true;
-		setVoiceFooter(ctx, true);
-		await runVoiceSession(ctx);
-	}
-
-	pi.registerCommand("voice", {
-		description: "Toggle voice mode",
-		handler: async (_args, ctx) => toggleVoice(ctx),
-	});
-
-	pi.registerShortcut("ctrl+alt+v", {
-		description: shortcutDesc("Toggle voice mode", "/voice"),
-		handler: async (ctx) => toggleVoice(ctx),
-	});
-
-	function killRecognizer() {
-		if (recognizerProcess) { recognizerProcess.kill("SIGTERM"); recognizerProcess = null; }
-	}
-
-	function startRecognizer(
-		onPartial: (text: string) => void,
-		onFinal: (text: string) => void,
-		onError: (msg: string) => void,
-		onReady: () => void,
-	) {
-		if (IS_LINUX) {
-			recognizerProcess = spawn(linuxPython(), [PYTHON_SCRIPT], {
-				stdio: ["pipe", "pipe", "pipe"],
-			});
-		} else {
-			recognizerProcess = spawn(RECOGNIZER_BIN, [], { stdio: ["pipe", "pipe", "pipe"] });
-		}
-		const rl = readline.createInterface({ input: recognizerProcess.stdout! });
-		rl.on("line", (line: string) => {
-			if (line === "READY") { onReady(); return; }
-			if (line.startsWith("PARTIAL:")) onPartial(line.slice(8));
-			else if (line.startsWith("FINAL:")) onFinal(line.slice(6));
-			else if (line.startsWith("ERROR:")) onError(line.slice(6));
-		});
-		recognizerProcess.on("error", (err) => onError(err.message));
-		recognizerProcess.on("exit", () => { recognizerProcess = null; });
-	}
-
-	async function runVoiceSession(ctx: ExtensionContext): Promise<void> {
-		return new Promise<void>((resolve) => {
-			// The Swift recognizer handles accumulation across pause-induced
-			// transcription resets. Both PARTIAL and FINAL messages contain
-			// the full accumulated text, so we just pass them through.
-			startRecognizer(
-				(text) => {
-					ctx.ui.setEditorText(text);
-				},
-				(text) => {
-					ctx.ui.setEditorText(text);
-				},
-				(msg) => ctx.ui.notify(`Voice: ${msg}`, "error"),
-				() => {},
-			);
-
-			ctx.ui.custom<void>(
-				(_tui, _theme, _kb, done) => ({
-					render(): string[] { return []; },
-					handleInput(data: string) {
-						if (isKeyRelease(data)) return;
-						if (matchesKey(data, Key.escape) || matchesKey(data, Key.enter)) {
-							killRecognizer();
-							active = false;
-							setVoiceFooter(ctx, false);
-							done();
-						}
-					},
-					invalidate() {},
-				}),
-				{ overlay: true, overlayOptions: { anchor: "bottom-center", width: "100%" } },
-			).then(() => resolve());
-		});
-	}
-}

package/dist/resources/skills/create-gsd-extension/templates/extension-skeleton.ts

@@ -1,51 +0,0 @@
-/**
- * {{EXTENSION_NAME}} — {{DESCRIPTION}}
- *
- * Capabilities:
- * {{CAPABILITIES_LIST}}
- */
-
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { Type } from "@sinclair/typebox";
-import { StringEnum } from "@mariozechner/pi-ai";
-
-export default function (pi: ExtensionAPI) {
-  // === Events ===
-
-  pi.on("session_start", async (_event, ctx) => {
-    // Initialize state, restore from session, show status
-  });
-
-  // === Tools ===
-
-  pi.registerTool({
-    name: "{{tool_name}}",
-    label: "{{Tool Label}}",
-    description: "{{Tool description for LLM}}",
-    parameters: Type.Object({
-      action: StringEnum(["list", "add"] as const),
-      text: Type.Optional(Type.String({ description: "Item text" })),
-    }),
-    async execute(toolCallId, params, signal, onUpdate, ctx) {
-      if (signal?.aborted) {
-        return { content: [{ type: "text", text: "Cancelled" }] };
-      }
-
-      // Do work here
-
-      return {
-        content: [{ type: "text", text: "Result for LLM" }],
-        details: {},
-      };
-    },
-  });
-
-  // === Commands ===
-
-  pi.registerCommand("{{command_name}}", {
-    description: "{{Command description}}",
-    handler: async (args, ctx) => {
-      ctx.ui.notify(`Running ${args}`, "info");
-    },
-  });
-}

package/dist/resources/skills/create-gsd-extension/templates/stateful-tool-skeleton.ts

@@ -1,143 +0,0 @@
-/**
- * {{EXTENSION_NAME}} — Stateful tool with persistence
- *
- * State is stored in tool result details for proper branching support.
- */
-
-import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
-import { Type } from "@sinclair/typebox";
-import { StringEnum } from "@mariozechner/pi-ai";
-import { Text, truncateToWidth, matchesKey, Key } from "@mariozechner/pi-tui";
-
-interface {{ItemType}} {
-  id: number;
-  // Add fields
-}
-
-interface {{ToolDetails}} {
-  action: string;
-  items: {{ItemType}}[];
-  nextId: number;
-  error?: string;
-}
-
-export default function (pi: ExtensionAPI) {
-  let items: {{ItemType}}[] = [];
-  let nextId = 1;
-
-  // Reconstruct state from session
-  const reconstructState = (ctx: ExtensionContext) => {
-    items = [];
-    nextId = 1;
-    for (const entry of ctx.sessionManager.getBranch()) {
-      if (entry.type === "message" && entry.message.role === "toolResult") {
-        if (entry.message.toolName === "{{tool_name}}") {
-          const details = entry.message.details as {{ToolDetails}} | undefined;
-          if (details) {
-            items = details.items;
-            nextId = details.nextId;
-          }
-        }
-      }
-    }
-  };
-
-  // Reconstruct on ALL session change events
-  pi.on("session_start", async (_event, ctx) => reconstructState(ctx));
-  pi.on("session_switch", async (_event, ctx) => reconstructState(ctx));
-  pi.on("session_fork", async (_event, ctx) => reconstructState(ctx));
-  pi.on("session_tree", async (_event, ctx) => reconstructState(ctx));
-
-  // Register the tool
-  pi.registerTool({
-    name: "{{tool_name}}",
-    label: "{{Tool Label}}",
-    description: "{{Description for LLM}}",
-    parameters: Type.Object({
-      action: StringEnum(["list", "add", "remove"] as const),
-      text: Type.Optional(Type.String({ description: "Item text" })),
-      id: Type.Optional(Type.Number({ description: "Item ID" })),
-    }),
-
-    async execute(toolCallId, params, signal, onUpdate, ctx) {
-      if (signal?.aborted) {
-        return { content: [{ type: "text", text: "Cancelled" }] };
-      }
-
-      switch (params.action) {
-        case "list":
-          return {
-            content: [{ type: "text", text: items.length ? JSON.stringify(items) : "No items" }],
-            details: { action: "list", items: [...items], nextId } as {{ToolDetails}},
-          };
-
-        case "add": {
-          if (!params.text) throw new Error("text required for add");
-          const item: {{ItemType}} = { id: nextId++ /* , ... */ };
-          items.push(item);
-          return {
-            content: [{ type: "text", text: `Added #${item.id}` }],
-            details: { action: "add", items: [...items], nextId } as {{ToolDetails}},
-          };
-        }
-
-        case "remove": {
-          if (params.id === undefined) throw new Error("id required for remove");
-          const idx = items.findIndex(i => i.id === params.id);
-          if (idx === -1) throw new Error(`Item #${params.id} not found`);
-          items.splice(idx, 1);
-          return {
-            content: [{ type: "text", text: `Removed #${params.id}` }],
-            details: { action: "remove", items: [...items], nextId } as {{ToolDetails}},
-          };
-        }
-
-        default:
-          throw new Error(`Unknown action: ${params.action}`);
-      }
-    },
-
-    // Custom rendering
-    renderCall(args, theme) {
-      let text = theme.fg("toolTitle", theme.bold("{{tool_name}} "));
-      text += theme.fg("muted", args.action);
-      return new Text(text, 0, 0);
-    },
-
-    renderResult(result, { expanded }, theme) {
-      const details = result.details as {{ToolDetails}} | undefined;
-      if (!details) return new Text("", 0, 0);
-      if (details.error) return new Text(theme.fg("error", details.error), 0, 0);
-      return new Text(theme.fg("success", `✓ ${details.action} (${details.items.length} items)`), 0, 0);
-    },
-  });
-
-  // User command to view state
-  pi.registerCommand("{{command_name}}", {
-    description: "View {{items}}",
-    handler: async (_args, ctx) => {
-      if (!ctx.hasUI) {
-        ctx.ui.notify("Requires interactive mode", "error");
-        return;
-      }
-      await ctx.ui.custom<void>((_tui, theme, _kb, done) => ({
-        render(width: number): string[] {
-          const lines = [
-            "",
-            truncateToWidth(theme.fg("accent", ` {{Items}} (${items.length}) `), width),
-            "",
-          ];
-          for (const item of items) {
-            lines.push(truncateToWidth(`  #${item.id}`, width));
-          }
-          lines.push("", truncateToWidth(theme.fg("dim", "  Press Escape to close"), width), "");
-          return lines;
-        },
-        handleInput(data: string) {
-          if (matchesKey(data, Key.escape)) done();
-        },
-        invalidate() {},
-      }));
-    },
-  });
-}

package/src/resources/extensions/mcporter/extension-manifest.json

@@ -1,12 +0,0 @@
-{
-  "id": "mcporter",
-  "name": "MCPorter",
-  "version": "1.0.0",
-  "description": "Discover and call tools from MCP servers configured in Claude Desktop, Cursor, and VS Code",
-  "tier": "bundled",
-  "requires": { "platform": ">=2.29.0" },
-  "provides": {
-    "tools": ["mcp_servers", "mcp_discover", "mcp_call"],
-    "hooks": ["session_start"]
-  }
-}