pi-orchestrator-config 4.1.5

package/extensions/coms/themeMap.ts

@@ -0,0 +1,147 @@
+// Forked from https://github.com/disler/pi-vs-claude-code (commit b93c3f1)
+// We own this code — check upstream periodically for relevant changes.
+/**
+ * themeMap.ts — Per-extension default theme assignments
+ *
+ * Themes live in .pi/themes/ and are mapped by extension filename (no extension).
+ * Each extension calls applyExtensionTheme(import.meta.url, ctx) in its session_start
+ * hook to automatically load its designated theme on boot.
+ *
+ * Available themes (.pi/themes/):
+ *   catppuccin-mocha · cyberpunk · dracula · everforest · gruvbox
+ *   midnight-ocean   · nord      · ocean-breeze · rose-pine
+ *   synthwave        · tokyo-night
+ */
+
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { basename } from "path";
+import { fileURLToPath } from "url";
+
+// ── Theme assignments ──────────────────────────────────────────────────────
+//
+// Key   = extension filename without extension (matches extensions/<key>.ts)
+// Value = theme name from .pi/themes/<value>.json
+//
+export const THEME_MAP: Record<string, string> = {
+	"agent-chain":        "midnight-ocean",   // deep sequential pipeline
+	"agent-team":         "dracula",          // rich orchestration palette
+	"coms":               "ocean-breeze",     // peer-to-peer messaging, cross-boundary
+	"coms-net":           "ocean-breeze",     // peer-to-peer messaging, cross-boundary
+	"cross-agent":        "ocean-breeze",     // cross-boundary, connecting
+	"damage-control":     "gruvbox",          // grounded, earthy safety
+	"minimal":            "synthwave",        // synthwave by default now!
+	"pi-pi":              "rose-pine",        // warm creative meta-agent
+	"pure-focus":         "everforest",       // calm, distraction-free
+	"purpose-gate":       "tokyo-night",      // intentional, sharp focus
+	"session-replay":     "catppuccin-mocha", // soft, reflective history
+	"subagent-widget":    "cyberpunk",        // multi-agent futuristic
+	"system-select":      "catppuccin-mocha", // soft selection UI
+	"theme-cycler":       "synthwave",        // neon, it's a theme tool
+	"tilldone":           "everforest",       // task-focused calm
+	"tool-counter":       "synthwave",        // techy metrics
+	"tool-counter-widget":"synthwave",        // same family
+};
+
+// ── Helpers ───────────────────────────────────────────────────────────────
+
+/** Derive the extension name (e.g. "minimal") from its import.meta.url. */
+function extensionName(fileUrl: string): string {
+	const filePath = fileUrl.startsWith("file://") ? fileURLToPath(fileUrl) : fileUrl;
+	return basename(filePath).replace(/\.[^.]+$/, "");
+}
+
+// ── Theme ──────────────────────────────────────────────────────────────────
+
+/**
+ * Apply the mapped theme for an extension on session boot.
+ *
+ * @param fileUrl   Pass `import.meta.url` from the calling extension file.
+ * @param ctx       The ExtensionContext from the session_start handler.
+ * @returns         true if the theme was applied successfully, false otherwise.
+ */
+export function applyExtensionTheme(fileUrl: string, ctx: ExtensionContext): boolean {
+	if (!ctx.hasUI) return false;
+
+	const name = extensionName(fileUrl);
+
+	// If there are multiple extensions stacked in 'ipi', they each fire session_start
+	// and try to apply their own mapped theme. The LAST one to fire wins.
+	// Since system-select is last in the ipi alias array, it was setting 'catppuccin-mocha'.
+
+	// We want to skip theme application for all secondary extensions if they are stacked,
+	// so the primary extension (first in the array) dictates the theme.
+	const primaryExt = primaryExtensionName();
+	if (primaryExt && primaryExt !== name) {
+		return true; // Pretend we succeeded, but don't overwrite the primary theme
+	}
+
+	let themeName = THEME_MAP[name];
+
+	if (!themeName) {
+		themeName = "synthwave";
+	}
+
+	const result = ctx.ui.setTheme(themeName);
+
+	if (!result.success && themeName !== "synthwave") {
+		return ctx.ui.setTheme("synthwave").success;
+	}
+
+	return result.success;
+}
+// ── Title ──────────────────────────────────────────────────────────────────
+
+/**
+ * Read process.argv to find the first -e / --extension flag value.
+ *
+ * When Pi is launched as:
+ *   pi -e extensions/subagent-widget.ts -e extensions/pure-focus.ts
+ *
+ * process.argv contains those paths verbatim. Every stacked extension calls
+ * this and gets the same answer ("subagent-widget"), so all setTitle calls
+ * are idempotent — no shared state or deduplication needed.
+ *
+ * Returns null if no -e flag is present (e.g. plain `pi` with no extensions).
+ */
+function primaryExtensionName(): string | null {
+	const argv = process.argv;
+	for (let i = 0; i < argv.length - 1; i++) {
+		if (argv[i] === "-e" || argv[i] === "--extension") {
+			return basename(argv[i + 1]).replace(/\.[^.]+$/, "");
+		}
+	}
+	return null;
+}
+
+/**
+ * Set the terminal title to "π - <first-extension-name>" on session boot.
+ * Reads the title from process.argv so all stacked extensions agree on the
+ * same value — no coordination or shared state required.
+ *
+ * Deferred 150 ms to fire after Pi's own startup title-set.
+ */
+function applyExtensionTitle(ctx: ExtensionContext): void {
+	if (!ctx.hasUI) return;
+	const name = primaryExtensionName();
+	if (!name) return;
+	setTimeout(() => ctx.ui.setTitle(`π - ${name}`), 150);
+}
+
+// ── Combined default ───────────────────────────────────────────────────────
+
+/**
+ * Apply both the mapped theme AND the terminal title for an extension.
+ * Drop-in replacement for applyExtensionTheme — call this in every session_start.
+ *
+ * Usage:
+ *   import { applyExtensionDefaults } from "./themeMap.js";
+ *
+ *   pi.on("session_start", async (_event, ctx) => {
+ *     applyExtensionDefaults(import.meta.url, ctx);
+ *     // ... rest of handler
+ *   });
+ */
+export function applyExtensionDefaults(fileUrl: string, ctx: ExtensionContext): void {
+	applyExtensionTheme(fileUrl, ctx);
+	applyExtensionTitle(ctx);
+}

package/extensions/image-gen/image-gen.ts

@@ -0,0 +1,332 @@
+/**
+ * image-gen.ts — Image generation tool via Gemini API
+ *
+ * Generates images from structured parameters using Google's Gemini API.
+ * Model via pi-config-settings.json (`image_model`) or PI_IMAGE_MODEL env.
+ * API key via GEMINI_API_KEY or GOOGLE_API_KEY (env only — secrets stay out of settings).
+ */
+
+import { Type } from "typebox";
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { getSetting } from "../orchestrator/project-settings.js";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { execFileSync, spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const ASPECT_RATIOS = ["1:1", "3:4", "4:3", "9:16", "16:9"] as const;
+const IMAGE_TIMEOUT = 3 * 60 * 1000; // 3 minutes
+
+const imageGenSchema = Type.Object({
+    subject: Type.String({ description: "Main subject of the image" }),
+    action: Type.Optional(Type.String({ description: "What the subject is doing" })),
+    scene: Type.Optional(Type.String({ description: "Location or environment" })),
+    composition: Type.Optional(Type.String({ description: "Camera angle and framing" })),
+    lighting: Type.Optional(Type.String({ description: "Lighting setup" })),
+    style: Type.Optional(Type.String({ description: "Artistic style (e.g., photorealistic, watercolor, pixel art)" })),
+    text: Type.Optional(Type.String({ description: "Text to render in the image" })),
+    aspect_ratio: Type.Optional(Type.Enum(
+        Object.fromEntries(ASPECT_RATIOS.map(r => [r, r])) as Record<string, string>,
+        { description: "Aspect ratio: 1:1, 3:4, 4:3, 9:16, 16:9" }
+    )),
+});
+
+interface GeminiPart {
+    text?: string;
+    inlineData?: { mimeType: string; data: string };
+}
+
+interface GeminiCandidate {
+    content?: { parts?: GeminiPart[] };
+}
+
+interface GeminiResponse {
+    candidates?: GeminiCandidate[];
+    promptFeedback?: { blockReason?: string };
+}
+
+function getApiKey(): string | null {
+    return process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY || null;
+}
+
+function getModel(cwd: string): string | null {
+    const model = getSetting(cwd, "image_model");
+    return model || null;
+}
+
+function assemblePrompt(params: {
+    subject: string;
+    action?: string;
+    scene?: string;
+    composition?: string;
+    lighting?: string;
+    style?: string;
+    text?: string;
+}): string {
+    const parts: string[] = [];
+
+    const subjectParts = [params.subject];
+    if (params.action) subjectParts.push(params.action);
+    if (params.scene) subjectParts.push(params.scene);
+    parts.push(subjectParts.join(", "));
+
+    if (params.composition) parts.push(params.composition);
+    if (params.lighting) parts.push(params.lighting);
+    if (params.style) parts.push(params.style);
+
+    let prompt = `${parts.map(p => p.replace(/[.!,;:]+$/, "")).join(". ")}.`;
+
+    if (params.text) {
+        prompt += `\n\nText: ${params.text}`;
+    }
+
+    return prompt;
+}
+
+function getExtensionForMime(mimeType: string): string {
+    const map: Record<string, string> = {
+        "image/png": "png",
+        "image/jpeg": "jpg",
+        "image/gif": "gif",
+        "image/webp": "webp",
+    };
+    return map[mimeType] ?? "png";
+}
+
+// Same logic as getProjectTmpDir in extensions/orchestrator/utils.ts
+function getTempDir(cwd: string): string {
+    const dir = path.join(cwd, ".pi", "tmp");
+    fs.mkdirSync(dir, { recursive: true });
+    return dir;
+}
+
+function getHttpdPath(): string {
+    // Resolve relative to this extension's location → ../../scripts/httpd.py
+    const thisDir = path.dirname(fileURLToPath(import.meta.url));
+    return path.resolve(thisDir, "..", "..", "scripts", "httpd.py");
+}
+
+function serveImage(imagePath: string): { url: string; port: string; dir: string } | null {
+    // Only serve via HTTP in containers (where user can't access local files)
+    // Use filesystem checks matching orchestrator's isRunningInContainer()
+    const inContainer = fs.existsSync("/.dockerenv") ||
+        fs.existsSync("/run/.containerenv") ||
+        (() => { try { return fs.readFileSync("/proc/1/cgroup", "utf-8").includes("docker") || fs.readFileSync("/proc/1/cgroup", "utf-8").includes("containerd"); } catch { return false; } })();
+    if (!inContainer) return null;
+
+    const httpd = getHttpdPath();
+    if (!fs.existsSync(httpd)) return null;
+
+    try {
+        // Find a free port
+        const port = execFileSync("uv", ["run", "python3", httpd, "--find-port"], {
+            encoding: "utf-8",
+            timeout: 5000,
+        }).trim();
+
+        const dir = path.dirname(imagePath);
+        const filename = path.basename(imagePath);
+        const logFile = path.join(dir, `httpd-${port}.log`);
+
+        // Launch server in background — close FDs after spawn
+        const logFd = fs.openSync(logFile, "a");
+        const child = spawn("uv", ["run", "python3", httpd, "--port", port, "--dir", dir], {
+            detached: true,
+            stdio: ["ignore", logFd, logFd],
+        });
+        child.unref();
+        fs.closeSync(logFd);
+
+        return { url: `http://localhost:${port}/${filename}`, port, dir };
+    } catch {
+        return null;
+    }
+}
+
+export function createImageGenTool(): ToolDefinition {
+    return {
+        name: "generate_image",
+        label: "GenerateImage",
+        description: [
+            "Generate an image from a structured description using Gemini.",
+            "Provide a subject (required) and optional parameters for action, scene, composition, lighting, style, and text.",
+            "Returns the file path of the generated image.",
+            "Requires image_model in pi-config-settings.json (or PI_IMAGE_MODEL) and GEMINI_API_KEY/GOOGLE_API_KEY.",
+        ].join("\n"),
+        promptSnippet: "generate_image: Generate images from structured descriptions via Gemini API",
+        parameters: imageGenSchema,
+
+        async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+            const model = getModel(ctx.cwd);
+            if (!model) {
+                return {
+                    content: [{
+                        type: "text" as const,
+                        text: "Error: image model is not set. Add image_model to pi-config-settings.json (or PI_IMAGE_MODEL env) and reload pi.",
+                    }],
+                };
+            }
+
+            const apiKey = getApiKey();
+            if (!apiKey) {
+                return {
+                    content: [{
+                        type: "text" as const,
+                        text: "Error: No API key found. Set GEMINI_API_KEY or GOOGLE_API_KEY environment variable and restart pi.",
+                    }],
+                };
+            }
+
+            const promptText = assemblePrompt(params);
+
+            const generationConfig: Record<string, unknown> = {
+                responseModalities: ["IMAGE"],
+            };
+            if (params.aspect_ratio) {
+                generationConfig.imageConfig = { aspectRatio: params.aspect_ratio };
+            }
+
+            const requestBody = {
+                contents: [{ role: "user" as const, parts: [{ text: promptText }] }],
+                generationConfig,
+            };
+
+            const abortSignal = signal ?? AbortSignal.timeout(IMAGE_TIMEOUT);
+
+            let response: Response;
+            try {
+                response = await fetch(
+                    `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(model)}:generateContent`,
+                    {
+                        method: "POST",
+                        headers: {
+                            "Content-Type": "application/json",
+                            "x-goog-api-key": apiKey,
+                        },
+                        body: JSON.stringify(requestBody),
+                        signal: abortSignal,
+                    },
+                );
+            } catch (err: any) {
+                return {
+                    content: [{
+                        type: "text" as const,
+                        text: `Error: Gemini API request failed: ${err?.message ?? String(err)}`,
+                    }],
+                };
+            }
+
+            const rawText = await response.text();
+            if (!response.ok) {
+                let message = rawText;
+                try {
+                    const parsed = JSON.parse(rawText) as { error?: { message?: string } };
+                    message = parsed.error?.message ?? message;
+                } catch {
+                    // Keep raw text
+                }
+                return {
+                    content: [{
+                        type: "text" as const,
+                        text: `Error: Gemini image request failed (${response.status}): ${message}`,
+                    }],
+                };
+            }
+
+            let data: GeminiResponse;
+            try {
+                data = JSON.parse(rawText) as GeminiResponse;
+            } catch {
+                return {
+                    content: [{
+                        type: "text" as const,
+                        text: `Error: Failed to parse Gemini response: ${rawText.slice(0, 200)}`,
+                    }],
+                };
+            }
+
+            if (data.promptFeedback?.blockReason) {
+                return {
+                    content: [{
+                        type: "text" as const,
+                        text: `Error: Image generation blocked by safety filter: ${data.promptFeedback.blockReason}`,
+                    }],
+                };
+            }
+
+            const images: { data: string; mimeType: string }[] = [];
+            let responseText = "";
+
+            for (const candidate of data.candidates ?? []) {
+                for (const part of candidate.content?.parts ?? []) {
+                    if (part.inlineData?.data && part.inlineData?.mimeType) {
+                        images.push({
+                            data: part.inlineData.data,
+                            mimeType: part.inlineData.mimeType,
+                        });
+                    }
+                    if (part.text) {
+                        responseText += part.text;
+                    }
+                }
+            }
+
+            if (images.length === 0) {
+                const extra = responseText ? `\n\n${responseText}` : "";
+                return {
+                    content: [{
+                        type: "text" as const,
+                        text: `No image data returned from Gemini.${extra}`,
+                    }],
+                };
+            }
+
+            const cwd = ctx?.cwd ?? process.cwd();
+            const tempDir = getTempDir(cwd);
+            const savedPaths: string[] = [];
+
+            for (const image of images) {
+                const ext = getExtensionForMime(image.mimeType);
+                const filename = `pi-image-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.${ext}`;
+                const filepath = path.join(tempDir, filename);
+                try {
+                    const buffer = Buffer.from(image.data, "base64");
+                    if (buffer.length === 0) continue; // Skip empty/malformed data
+                    fs.writeFileSync(filepath, buffer);
+                    savedPaths.push(filepath);
+                } catch (err: any) {
+                    // Skip corrupted image data — log but don't crash
+                    console.debug(`[image-gen] Failed to decode/save image: ${err?.message?.slice(0, 100)}`);
+                }
+            }
+
+            // Start a single preview server for all images (container only)
+            let previewServer: { url: string; port: string; dir: string } | null = null;
+            if (savedPaths.length > 0) {
+                previewServer = serveImage(savedPaths[0]);
+            }
+
+            const lines = [
+                `Model: ${model}`,
+                `Generated ${savedPaths.length} image(s):`,
+            ];
+            for (const p of savedPaths) {
+                lines.push(`  ${p}`);
+                if (previewServer) {
+                    const filename = path.basename(p);
+                    lines.push(`  Preview: http://localhost:${previewServer.port}/${filename}`);
+                }
+            }
+            if (responseText.trim()) {
+                lines.push("", responseText.trim());
+            }
+
+            return {
+                content: [{
+                    type: "text" as const,
+                    text: lines.join("\n"),
+                }],
+            };
+        },
+    };
+}

package/extensions/image-gen/index.ts

@@ -0,0 +1,14 @@
+/**
+ * Image Generation Extension for pi
+ *
+ * Registers a `generate_image` tool that generates images via Gemini API.
+ * Requires image_model in pi-config-settings.json (or PI_IMAGE_MODEL) and
+ * GEMINI_API_KEY/GOOGLE_API_KEY environment variables.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { createImageGenTool } from "./image-gen.js";
+
+export default function (pi: ExtensionAPI) {
+    pi.registerTool(createImageGenTool());
+}

package/extensions/orchestrator/agents.ts

@@ -0,0 +1,134 @@
+/**
+ * Agent discovery — extended from pi's subagent example.
+ *
+ * Discovery sources (in priority order, later overrides earlier):
+ * 1. Package-bundled agents (this package's agents/ directory)
+ * 2. User agents (~/.pi/agent/agents/)
+ * 3. Project agents (.pi/agents/ in cwd or parent dirs)
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getAgentDir, parseFrontmatter } from "@earendil-works/pi-coding-agent";
+
+export type AgentScope = "user" | "project" | "both";
+
+export interface AgentConfig {
+	name: string;
+	description: string;
+	tools?: string[];
+	model?: string;
+	provider?: string;
+	systemPrompt: string;
+	source: "user" | "project" | "package";
+	filePath: string;
+}
+
+export interface AgentDiscoveryResult {
+	agents: AgentConfig[];
+	projectAgentsDir: string | null;
+}
+
+function loadAgentsFromDir(dir: string, source: "user" | "project" | "package"): AgentConfig[] {
+	const agents: AgentConfig[] = [];
+
+	if (!fs.existsSync(dir)) return agents;
+
+	let entries: fs.Dirent[];
+	try {
+		entries = fs.readdirSync(dir, { withFileTypes: true });
+	} catch {
+		return agents;
+	}
+
+	for (const entry of entries) {
+		if (!entry.name.endsWith(".md")) continue;
+		if (!entry.isFile() && !entry.isSymbolicLink()) continue;
+
+		const filePath = path.join(dir, entry.name);
+		let content: string;
+		try {
+			content = fs.readFileSync(filePath, "utf-8");
+		} catch {
+			continue;
+		}
+
+		const { frontmatter, body } = parseFrontmatter<Record<string, string>>(content);
+
+		if (!frontmatter.name || !frontmatter.description) continue;
+
+		const tools = frontmatter.tools
+			?.split(",")
+			.map((t: string) => t.trim())
+			.filter(Boolean);
+
+		agents.push({
+			name: frontmatter.name,
+			description: frontmatter.description,
+			tools: tools && tools.length > 0 ? tools : undefined,
+			model: typeof frontmatter.model === "string" ? frontmatter.model.trim() || undefined : undefined,
+			provider: typeof frontmatter.provider === "string" ? frontmatter.provider.trim() || undefined : undefined,
+			systemPrompt: body,
+			source,
+			filePath,
+		});
+	}
+
+	return agents;
+}
+
+function isDirectory(p: string): boolean {
+	try {
+		return fs.statSync(p).isDirectory();
+	} catch {
+		return false;
+	}
+}
+
+function findNearestProjectAgentsDir(cwd: string): string | null {
+	let currentDir = cwd;
+	while (true) {
+		const candidate = path.join(currentDir, ".pi", "agents");
+		if (isDirectory(candidate)) return candidate;
+
+		const parentDir = path.dirname(currentDir);
+		if (parentDir === currentDir) return null;
+		currentDir = parentDir;
+	}
+}
+
+/**
+ * Get the package's bundled agents directory.
+ * This file lives in extensions/orchestrator/agents.ts,
+ * and the agents are in ../../agents/ relative to this file.
+ */
+function getPackageAgentsDir(): string {
+	return path.resolve(__dirname, "..", "..", "agents");
+}
+
+export function discoverAgents(cwd: string, scope: AgentScope): AgentDiscoveryResult {
+	const packageDir = getPackageAgentsDir();
+	const userDir = path.join(getAgentDir(), "agents");
+	const projectAgentsDir = findNearestProjectAgentsDir(cwd);
+
+	// Load from all sources
+	const packageAgents = loadAgentsFromDir(packageDir, "package");
+	const userAgents = scope === "project" ? [] : loadAgentsFromDir(userDir, "user");
+	const projectAgents = scope === "user" || !projectAgentsDir ? [] : loadAgentsFromDir(projectAgentsDir, "project");
+
+	// Merge: package < user < project (later overrides earlier by name)
+	const agentMap = new Map<string, AgentConfig>();
+
+	// Package agents are always loaded as the base
+	for (const agent of packageAgents) agentMap.set(agent.name, agent);
+
+	if (scope !== "project") {
+		for (const agent of userAgents) agentMap.set(agent.name, agent);
+	}
+
+	if (scope !== "user" && projectAgentsDir) {
+		for (const agent of projectAgents) agentMap.set(agent.name, agent);
+	}
+
+	return { agents: Array.from(agentMap.values()), projectAgentsDir };
+}