@matyah00/openpi 0.1.2

package/extensions/state-tools.ts

@@ -0,0 +1,276 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { Type } from "typebox";
+
+type GoalAction = "list" | "set" | "complete" | "block";
+
+type Milestone = {
+  id: string;
+  title?: string;
+  files?: string[];
+  dependsOn?: string[];
+  status?: string;
+};
+
+function memoryDir(cwd: string): string {
+  return path.join(cwd, ".pi", "memory");
+}
+
+function goalsPath(cwd: string): string {
+  return path.join(memoryDir(cwd), "goals.md");
+}
+
+function checkpointsDir(cwd: string): string {
+  return path.join(memoryDir(cwd), "checkpoints");
+}
+
+function ensureMemory(cwd: string) {
+  fs.mkdirSync(memoryDir(cwd), { recursive: true });
+  fs.mkdirSync(checkpointsDir(cwd), { recursive: true });
+  const file = goalsPath(cwd);
+  if (!fs.existsSync(file)) {
+    fs.writeFileSync(file, [
+      "# Pi Goals",
+      "",
+      "## Current Threads",
+      "",
+      "## In Progress",
+      "",
+      "## Next Actions",
+      "",
+      "## Done",
+      "",
+      "## Blocked",
+      "",
+    ].join("\n"), "utf-8");
+  }
+}
+
+function readText(filePath: string): string {
+  try {
+    return fs.readFileSync(filePath, "utf-8");
+  } catch {
+    return "";
+  }
+}
+
+function writeGoals(cwd: string, content: string) {
+  ensureMemory(cwd);
+  fs.writeFileSync(goalsPath(cwd), content.endsWith("\n") ? content : `${content}\n`, "utf-8");
+}
+
+function appendUnderHeading(content: string, heading: string, line: string): string {
+  const marker = `## ${heading}`;
+  const index = content.indexOf(marker);
+  if (index === -1) return `${content.trimEnd()}\n\n${marker}\n${line}\n`;
+  const after = index + marker.length;
+  return `${content.slice(0, after)}\n${line}${content.slice(after)}`;
+}
+
+function replaceSection(content: string, heading: string, lines: string[]): string {
+  const marker = `## ${heading}`;
+  const start = content.indexOf(marker);
+  const section = `${marker}\n${lines.join("\n")}\n`;
+  if (start === -1) return `${content.trimEnd()}\n\n${section}`;
+  const next = content.indexOf("\n## ", start + marker.length);
+  if (next === -1) return `${content.slice(0, start)}${section}`;
+  return `${content.slice(0, start)}${section}${content.slice(next + 1)}`;
+}
+
+function timestampForFile(date = new Date()): string {
+  return date.toISOString().replace(/[:.]/g, "-").slice(0, 19);
+}
+
+function listLatestCheckpoint(cwd: string): string | null {
+  const dir = checkpointsDir(cwd);
+  if (!fs.existsSync(dir)) return null;
+  const files = fs.readdirSync(dir).filter((name) => name.endsWith(".md")).sort();
+  return files.length ? path.join(dir, files[files.length - 1]) : null;
+}
+
+function normalizeFile(file: string): string {
+  return file.replace(/\\/g, "/").toLowerCase();
+}
+
+function parallelConflicts(milestones: Milestone[]): string[] {
+  const conflicts: string[] = [];
+  for (let i = 0; i < milestones.length; i++) {
+    for (let j = i + 1; j < milestones.length; j++) {
+      const left = milestones[i];
+      const right = milestones[j];
+      const leftFiles = new Set((left.files || []).map(normalizeFile));
+      const rightFiles = new Set((right.files || []).map(normalizeFile));
+      const shared = Array.from(leftFiles).filter((file) => rightFiles.has(file));
+      if (shared.length) conflicts.push(`${left.id} conflicts with ${right.id}: shared files ${shared.join(", ")}`);
+
+      const sensitive = ["package.json", "requirements.txt", "pyproject.toml", "cargo.toml", "go.mod", "schema.prisma"];
+      const leftSensitive = Array.from(leftFiles).filter((file) => sensitive.some((item) => file.endsWith(item)));
+      const rightSensitive = Array.from(rightFiles).filter((file) => sensitive.some((item) => file.endsWith(item)));
+      if (leftSensitive.length && rightSensitive.length) {
+        conflicts.push(`${left.id} conflicts with ${right.id}: both touch dependency/schema files`);
+      }
+
+      if ((left.dependsOn || []).includes(right.id) || (right.dependsOn || []).includes(left.id)) {
+        conflicts.push(`${left.id} conflicts with ${right.id}: dependency relationship`);
+      }
+    }
+    if (["blocked", "done"].includes((milestones[i].status || "").toLowerCase())) {
+      conflicts.push(`${milestones[i].id} is ${milestones[i].status}; do not parallelize`);
+    }
+  }
+  return conflicts;
+}
+
+export default function stateToolsExtension(pi: ExtensionAPI) {
+  pi.registerTool({
+    name: "session_state",
+    label: "Session State",
+    description: "Read Pi-native goals and latest checkpoint from .pi/memory.",
+    promptSnippet: "Use session_state when resuming, checking goals, or deciding whether to snapshot.",
+    parameters: Type.Object({}),
+    async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
+      ensureMemory(ctx.cwd);
+      const latest = listLatestCheckpoint(ctx.cwd);
+      const text = [
+        `goals: ${goalsPath(ctx.cwd)}`,
+        "",
+        readText(goalsPath(ctx.cwd)) || "(no goals)",
+        "",
+        latest ? `latest checkpoint: ${latest}\n\n${readText(latest)}` : "latest checkpoint: none",
+      ].join("\n");
+      return { content: [{ type: "text", text }] };
+    },
+    renderCall(_args, theme) {
+      return new Text(theme.fg("toolTitle", theme.bold("session_state")), 0, 0);
+    },
+  });
+
+  pi.registerTool({
+    name: "goal_state",
+    label: "Goal State",
+    description: "Manage Pi-native goals in .pi/memory/goals.md.",
+    promptSnippet: "Use goal_state to list, set, complete, or block durable session goals.",
+    parameters: Type.Object({
+      action: Type.String({ description: "list, set, complete, or block." }),
+      goal: Type.Optional(Type.String({ description: "Goal text for set/complete/block." })),
+      note: Type.Optional(Type.String({ description: "Optional note or evidence." })),
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      ensureMemory(ctx.cwd);
+      const action = String(params.action || "list") as GoalAction;
+      const goal = String(params.goal || "").trim();
+      const note = String(params.note || "").trim();
+      let content = readText(goalsPath(ctx.cwd));
+      const stamp = new Date().toISOString();
+
+      if (action === "set") {
+        if (!goal) throw new Error("goal_state set requires goal");
+        content = appendUnderHeading(content, "In Progress", `- ${stamp} - ${goal}${note ? ` | ${note}` : ""}`);
+        content = appendUnderHeading(content, "Current Threads", `- ${goal}`);
+        writeGoals(ctx.cwd, content);
+      } else if (action === "complete") {
+        if (!goal) throw new Error("goal_state complete requires goal");
+        content = appendUnderHeading(content, "Done", `- ${stamp} - ${goal}${note ? ` | ${note}` : ""}`);
+        writeGoals(ctx.cwd, content);
+      } else if (action === "block") {
+        if (!goal) throw new Error("goal_state block requires goal");
+        content = appendUnderHeading(content, "Blocked", `- ${stamp} - ${goal}${note ? ` | ${note}` : ""}`);
+        writeGoals(ctx.cwd, content);
+      }
+
+      return { content: [{ type: "text", text: readText(goalsPath(ctx.cwd)) }] };
+    },
+    renderCall(args, theme) {
+      return new Text(`${theme.fg("toolTitle", theme.bold("goal_state "))}${theme.fg("accent", args.action || "list")}`, 0, 0);
+    },
+  });
+
+  pi.registerTool({
+    name: "write_snapshot",
+    label: "Write Snapshot",
+    description: "Write a mid-session checkpoint to .pi/memory/checkpoints and update next actions.",
+    promptSnippet: "Use write_snapshot before context compaction, pausing, or after major decisions.",
+    parameters: Type.Object({
+      label: Type.Optional(Type.String()),
+      currentTask: Type.String(),
+      decisions: Type.Optional(Type.Array(Type.String())),
+      knownContext: Type.Optional(Type.Array(Type.String())),
+      nextActions: Type.Optional(Type.Array(Type.String())),
+      risks: Type.Optional(Type.Array(Type.String())),
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      ensureMemory(ctx.cwd);
+      const stamp = new Date().toISOString();
+      const label = String(params.label || "mid-session").trim();
+      const filePath = path.join(checkpointsDir(ctx.cwd), `${timestampForFile()}-${label.replace(/[^a-zA-Z0-9_-]+/g, "-").slice(0, 40)}.md`);
+      const decisions = (params.decisions || []) as string[];
+      const knownContext = (params.knownContext || []) as string[];
+      const nextActions = (params.nextActions || []) as string[];
+      const risks = (params.risks || []) as string[];
+      const checkpoint = [
+        "---",
+        `date: ${stamp}`,
+        `label: ${label}`,
+        "---",
+        "",
+        "## Current Task",
+        String(params.currentTask),
+        "",
+        "## Decisions",
+        ...(decisions.length ? decisions.map((item) => `- ${item}`) : ["- None recorded"]),
+        "",
+        "## Known Context",
+        ...(knownContext.length ? knownContext.map((item) => `- ${item}`) : ["- None recorded"]),
+        "",
+        "## Next Actions",
+        ...(nextActions.length ? nextActions.map((item, index) => `${index + 1}. ${item}`) : ["1. None recorded"]),
+        "",
+        "## Risks",
+        ...(risks.length ? risks.map((item) => `- ${item}`) : ["- None"]),
+        "",
+      ].join("\n");
+      fs.writeFileSync(filePath, checkpoint, "utf-8");
+
+      let goals = readText(goalsPath(ctx.cwd));
+      goals = appendUnderHeading(goals, "Current Threads", `- [checkpoint] ${stamp} - ${label} -> ${path.relative(ctx.cwd, filePath).replace(/\\/g, "/")}`);
+      if (nextActions.length) goals = replaceSection(goals, "Next Actions", nextActions.map((item, index) => `${index + 1}. ${item}`));
+      writeGoals(ctx.cwd, goals);
+
+      return { content: [{ type: "text", text: `Snapshot written: ${filePath}\n\n${checkpoint}` }] };
+    },
+    renderCall(args, theme) {
+      return new Text(`${theme.fg("toolTitle", theme.bold("write_snapshot "))}${theme.fg("accent", args.label || "mid-session")}`, 0, 0);
+    },
+  });
+
+  pi.registerTool({
+    name: "parallel_safety_check",
+    label: "Parallel Safety Check",
+    description: "Check milestone file ownership, dependency, and status conflicts before parallel agent dispatch.",
+    promptSnippet: "Use parallel_safety_check before running multiple agents in parallel.",
+    parameters: Type.Object({
+      milestones: Type.Array(Type.Object({
+        id: Type.String(),
+        title: Type.Optional(Type.String()),
+        files: Type.Optional(Type.Array(Type.String())),
+        dependsOn: Type.Optional(Type.Array(Type.String())),
+        status: Type.Optional(Type.String()),
+      })),
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+      const milestones = (params.milestones || []) as Milestone[];
+      const conflicts = parallelConflicts(milestones);
+      const verdict = conflicts.length ? "SEQUENTIAL_REQUIRED" : "PARALLEL_SAFE";
+      return {
+        content: [{ type: "text", text: [`parallel_safety_check: ${verdict}`, "", ...(conflicts.length ? conflicts : ["No ownership, dependency, or terminal-status conflicts detected."])].join("\n") }],
+        details: { verdict, conflicts },
+      };
+    },
+    renderCall(args, theme) {
+      const count = Array.isArray(args.milestones) ? args.milestones.length : 0;
+      return new Text(`${theme.fg("toolTitle", theme.bold("parallel_safety_check "))}${theme.fg("accent", `${count} milestones`)}`, 0, 0);
+    },
+  });
+}

package/extensions/system-select.ts

@@ -0,0 +1,120 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+import { bundledAgentsDir, bundledPiPiAgentsDir } from "./lib/packagePaths.ts";
+
+type AgentDef = {
+  name: string;
+  description: string;
+  tools: string[];
+  body: string;
+  source: string;
+};
+
+function parseFrontmatter(raw: string): { fields: Record<string, string>; body: string } {
+  const match = raw.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
+  if (!match) return { fields: {}, body: raw };
+  const fields: Record<string, string> = {};
+  for (const line of match[1].split("\n")) {
+    const idx = line.indexOf(":");
+    if (idx > 0) fields[line.slice(0, idx).trim()] = line.slice(idx + 1).trim();
+  }
+  return { fields, body: match[2] };
+}
+
+function scanAgents(dir: string, source: string): AgentDef[] {
+  if (!existsSync(dir)) return [];
+  const agents: AgentDef[] = [];
+  for (const file of readdirSync(dir)) {
+    if (!file.endsWith(".md")) continue;
+    const raw = readFileSync(join(dir, file), "utf-8");
+    const { fields, body } = parseFrontmatter(raw);
+    agents.push({
+      name: fields.name || basename(file, ".md"),
+      description: fields.description || "",
+      tools: fields.tools ? fields.tools.split(",").map((tool) => tool.trim()).filter(Boolean) : [],
+      body: body.trim(),
+      source,
+    });
+  }
+  return agents;
+}
+
+function displayName(name: string): string {
+  return name.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+
+export default function (pi: ExtensionAPI) {
+  let activeAgent: AgentDef | null = null;
+  let allAgents: AgentDef[] = [];
+  let defaultTools: string[] = [];
+
+  pi.on("session_start", async (_event, ctx) => {
+    activeAgent = null;
+    allAgents = [];
+
+    const dirs: [string, string][] = [
+      [join(ctx.cwd, ".pi", "agents"), ".pi"],
+      [join(ctx.cwd, "agents"), "agents"],
+      [bundledAgentsDir, "openpi"],
+      [bundledPiPiAgentsDir, "openpi/pi-pi"],
+      [join(homedir(), ".pi", "agent", "agents"), "~/.pi"],
+    ];
+
+    const seen = new Set<string>();
+    const sourceCounts: Record<string, number> = {};
+
+    for (const [dir, source] of dirs) {
+      for (const agent of scanAgents(dir, source)) {
+        const key = agent.name.toLowerCase();
+        if (seen.has(key)) continue;
+        seen.add(key);
+        allAgents.push(agent);
+        sourceCounts[source] = (sourceCounts[source] || 0) + 1;
+      }
+    }
+
+    defaultTools = pi.getActiveTools();
+    if (ctx.hasUI) {
+      ctx.ui.setStatus("system-prompt", "System Prompt: Default");
+      const loaded = Object.entries(sourceCounts).map(([src, count]) => `${count} from ${src}`).join(", ");
+      ctx.ui.notify(allAgents.length ? `Loaded ${allAgents.length} Pi agents (${loaded})` : "No Pi agents found", "info");
+    }
+  });
+
+  pi.registerCommand("system", {
+    description: "Select a Pi-native system persona",
+    handler: async (_args, ctx) => {
+      if (allAgents.length === 0) {
+        ctx.ui.notify("No agents found in .pi/agents, agents, or bundled openpi agents", "warning");
+        return;
+      }
+
+      const options = ["Reset to Default", ...allAgents.map((agent) => `${agent.name} - ${agent.description} [${agent.source}]`)];
+      const choice = await ctx.ui.select("Select System Prompt", options);
+      if (choice === undefined) return;
+
+      if (choice === options[0]) {
+        activeAgent = null;
+        pi.setActiveTools(defaultTools);
+        ctx.ui.setStatus("system-prompt", "System Prompt: Default");
+        ctx.ui.notify("System Prompt reset to Default", "success");
+        return;
+      }
+
+      const agent = allAgents[options.indexOf(choice) - 1];
+      activeAgent = agent;
+      pi.setActiveTools(agent.tools.length ? agent.tools : defaultTools);
+      ctx.ui.setStatus("system-prompt", `System Prompt: ${displayName(agent.name)}`);
+      ctx.ui.notify(`System Prompt switched to: ${displayName(agent.name)}`, "success");
+    },
+  });
+
+  pi.on("before_agent_start", async (event) => {
+    if (!activeAgent) return;
+    return {
+      systemPrompt: `${activeAgent.body}\n\n${event.systemPrompt}`,
+    };
+  });
+}

package/extensions/theme-cycler.ts

@@ -0,0 +1,181 @@
+/**
+ * Theme Cycler — Keyboard shortcuts to cycle through available themes
+ *
+ * Shortcuts:
+ *   Ctrl+X          — Cycle theme forward
+ *   Ctrl+Q          — Cycle theme backward
+ *
+ * Commands:
+ *   /theme          — Open select picker to choose a theme
+ *   /theme <name>   — Switch directly by name
+ *
+ * Features:
+ *   - Status line shows current theme name with accent color
+ *   - Color swatch widget flashes briefly after each switch
+ *   - Auto-dismisses swatch after 3 seconds
+ *
+ * Usage: pi -e extensions/theme-cycler.ts -e extensions/minimal.ts
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { truncateToWidth } from "@mariozechner/pi-tui";
+import { applyExtensionDefaults } from "./themeMap.ts";
+
+export default function (pi: ExtensionAPI) {
+	let currentCtx: ExtensionContext | undefined;
+	let swatchTimer: ReturnType<typeof setTimeout> | null = null;
+
+	function updateStatus(ctx: ExtensionContext) {
+		if (!ctx.hasUI) return;
+		const name = ctx.ui.theme.name;
+		ctx.ui.setStatus("theme", `🎨 ${name}`);
+	}
+
+	function showSwatch(ctx: ExtensionContext) {
+		if (!ctx.hasUI) return;
+
+		if (swatchTimer) {
+			clearTimeout(swatchTimer);
+			swatchTimer = null;
+		}
+
+		ctx.ui.setWidget(
+			"theme-swatch",
+			(_tui, theme) => ({
+				invalidate() {},
+				render(width: number): string[] {
+					const block = "\u2588\u2588\u2588";
+					const swatch =
+						theme.fg("success", block) +
+						" " +
+						theme.fg("accent", block) +
+						" " +
+						theme.fg("warning", block) +
+						" " +
+						theme.fg("dim", block) +
+						" " +
+						theme.fg("muted", block);
+					const label = theme.fg("accent", " 🎨 ") + theme.fg("muted", ctx.ui.theme.name) + "  " + swatch;
+					const border = theme.fg("borderMuted", "─".repeat(Math.max(0, width)));
+					return [border, truncateToWidth("  " + label, width), border];
+				},
+			}),
+			{ placement: "belowEditor" },
+		);
+
+		swatchTimer = setTimeout(() => {
+			ctx.ui.setWidget("theme-swatch", undefined);
+			swatchTimer = null;
+		}, 3000);
+	}
+
+	function getThemeList(ctx: ExtensionContext) {
+		return ctx.ui.getAllThemes();
+	}
+
+	function findCurrentIndex(ctx: ExtensionContext): number {
+		const themes = getThemeList(ctx);
+		const current = ctx.ui.theme.name;
+		return themes.findIndex((t) => t.name === current);
+	}
+
+	function cycleTheme(ctx: ExtensionContext, direction: 1 | -1) {
+		if (!ctx.hasUI) return;
+
+		const themes = getThemeList(ctx);
+		if (themes.length === 0) {
+			ctx.ui.notify("No themes available", "warning");
+			return;
+		}
+
+		let index = findCurrentIndex(ctx);
+		if (index === -1) index = 0;
+
+		index = (index + direction + themes.length) % themes.length;
+		const theme = themes[index];
+		const result = ctx.ui.setTheme(theme.name);
+
+		if (result.success) {
+			updateStatus(ctx);
+			showSwatch(ctx);
+			ctx.ui.notify(`${theme.name} (${index + 1}/${themes.length})`, "info");
+		} else {
+			ctx.ui.notify(`Failed to set theme: ${result.error}`, "error");
+		}
+	}
+
+	// --- Shortcuts ---
+
+	pi.registerShortcut("ctrl+x", {
+		description: "Cycle theme forward",
+		handler: async (ctx) => {
+			currentCtx = ctx;
+			cycleTheme(ctx, 1);
+		},
+	});
+
+	pi.registerShortcut("ctrl+q", {
+		description: "Cycle theme backward",
+		handler: async (ctx) => {
+			currentCtx = ctx;
+			cycleTheme(ctx, -1);
+		},
+	});
+
+	// --- Command: /theme ---
+
+	pi.registerCommand("theme", {
+		description: "Select a theme: /theme or /theme <name>",
+		handler: async (args, ctx) => {
+			currentCtx = ctx;
+			if (!ctx.hasUI) return;
+
+			const themes = getThemeList(ctx);
+			const arg = args.trim();
+
+			if (arg) {
+				const result = ctx.ui.setTheme(arg);
+				if (result.success) {
+					updateStatus(ctx);
+					showSwatch(ctx);
+					ctx.ui.notify(`Theme: ${arg}`, "info");
+				} else {
+					ctx.ui.notify(`Theme not found: ${arg}. Use /theme to see available themes.`, "error");
+				}
+				return;
+			}
+
+			const items = themes.map((t) => {
+				const desc = t.path ? t.path : "built-in";
+				const active = t.name === ctx.ui.theme.name ? " (active)" : "";
+				return `${t.name}${active} — ${desc}`;
+			});
+
+			const selected = await ctx.ui.select("Select Theme", items);
+			if (!selected) return;
+
+			const selectedName = selected.split(/\s/)[0];
+			const result = ctx.ui.setTheme(selectedName);
+			if (result.success) {
+				updateStatus(ctx);
+				showSwatch(ctx);
+				ctx.ui.notify(`Theme: ${selectedName}`, "info");
+			}
+		},
+	});
+
+	// --- Session init ---
+
+	pi.on("session_start", async (_event, ctx) => {
+		currentCtx = ctx;
+		applyExtensionDefaults(import.meta.url, ctx);
+		updateStatus(ctx);
+	});
+
+	pi.on("session_shutdown", async () => {
+		if (swatchTimer) {
+			clearTimeout(swatchTimer);
+			swatchTimer = null;
+		}
+	});
+}