@dreki-gg/pi-subagent 0.7.0 → 0.8.0

package/extensions/subagent/spawn-utils.ts

@@ -0,0 +1,198 @@
+/**
+ * Shared utilities for spawning pi subagent processes.
+ * Used by both the `subagent` tool (index.ts) and the `/run-agent` command (agent-runner.ts).
+ */
+
+import { spawn } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { withFileMutationQueue } from '@earendil-works/pi-coding-agent';
+import type { Message } from '@earendil-works/pi-ai';
+import type { UsageStats } from './agent-runner-types.js';
+
+export function emptyUsage(): UsageStats {
+  return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 };
+}
+
+function getPiInvocation(args: string[]): { command: string; args: string[] } {
+  const currentScript = process.argv[1];
+
+  // Bun standalone binaries set argv[1] to a virtual FS path (e.g. /$bunfs/root/pi)
+  // that only resolves inside the running Bun process. Skip it — the binary IS the entry point.
+  const isBunVirtualPath = currentScript?.startsWith('/$bunfs/');
+
+  if (currentScript && !isBunVirtualPath && fs.existsSync(currentScript)) {
+    return { command: process.execPath, args: [currentScript, ...args] };
+  }
+
+  const execName = path.basename(process.execPath).toLowerCase();
+  const isGenericRuntime = /^(node|bun)(\.exe)?$/.test(execName);
+  if (!isGenericRuntime) {
+    // Standalone binary (e.g. pi compiled with Bun) — invoke directly
+    return { command: process.execPath, args };
+  }
+
+  return { command: 'pi', args };
+}
+
+async function writePromptToTempFile(
+  agentName: string,
+  prompt: string,
+): Promise<{ dir: string; filePath: string }> {
+  const tmpDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'pi-subagent-'));
+  const safeName = agentName.replace(/[^\w.-]+/g, '_');
+  const filePath = path.join(tmpDir, `prompt-${safeName}.md`);
+  await withFileMutationQueue(filePath, async () => {
+    await fs.promises.writeFile(filePath, prompt, { encoding: 'utf-8', mode: 0o600 });
+  });
+  return { dir: tmpDir, filePath };
+}
+
+function cleanupTempFiles(
+  tmpPromptPath: string | null,
+  tmpPromptDir: string | null,
+): void {
+  if (tmpPromptPath) try { fs.unlinkSync(tmpPromptPath); } catch { /* ignore */ }
+  if (tmpPromptDir) try { fs.rmdirSync(tmpPromptDir); } catch { /* ignore */ }
+}
+
+export interface SpawnPiAgentOptions {
+  cwd: string;
+  agentName: string;
+  task: string;
+  systemPrompt?: string;
+  model?: string;
+  thinking?: string;
+  tools?: string[];
+  signal?: AbortSignal;
+  onMessage?: (msg: Message) => void;
+  onToolResult?: (msg: Message) => void;
+}
+
+export interface SpawnPiAgentResult {
+  exitCode: number;
+  messages: Message[];
+  stderr: string;
+  wasAborted: boolean;
+  usage: UsageStats;
+  model?: string;
+  stopReason?: string;
+  errorMessage?: string;
+}
+
+/**
+ * Spawn a pi process for a subagent and collect results.
+ * This is the shared core that both the tool and the /run-agent command use.
+ */
+export async function spawnPiAgent(options: SpawnPiAgentOptions): Promise<SpawnPiAgentResult> {
+  const args: string[] = ['--mode', 'json', '-p', '--no-session'];
+  if (options.model) args.push('--model', options.model);
+  if (options.thinking) args.push('--thinking', options.thinking);
+  if (options.tools && options.tools.length > 0) args.push('--tools', options.tools.join(','));
+
+  let tmpPromptDir: string | null = null;
+  let tmpPromptPath: string | null = null;
+
+  const result: SpawnPiAgentResult = {
+    exitCode: 0,
+    messages: [],
+    stderr: '',
+    wasAborted: false,
+    usage: emptyUsage(),
+  };
+
+  try {
+    if (options.systemPrompt?.trim()) {
+      const tmp = await writePromptToTempFile(options.agentName, options.systemPrompt);
+      tmpPromptDir = tmp.dir;
+      tmpPromptPath = tmp.filePath;
+      args.push('--append-system-prompt', tmpPromptPath);
+    }
+
+    args.push(`Task: ${options.task}`);
+
+    const exitCode = await new Promise<number>((resolve) => {
+      const invocation = getPiInvocation(args);
+      const proc = spawn(invocation.command, invocation.args, {
+        cwd: options.cwd,
+        shell: false,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+      let buffer = '';
+
+      const processLine = (line: string) => {
+        if (!line.trim()) return;
+        let event: any;
+        try {
+          event = JSON.parse(line);
+        } catch {
+          return;
+        }
+
+        if (event.type === 'message_end' && event.message) {
+          const msg = event.message as Message;
+          result.messages.push(msg);
+
+          if (msg.role === 'assistant') {
+            result.usage.turns++;
+            const usage = msg.usage;
+            if (usage) {
+              result.usage.input += usage.input || 0;
+              result.usage.output += usage.output || 0;
+              result.usage.cacheRead += usage.cacheRead || 0;
+              result.usage.cacheWrite += usage.cacheWrite || 0;
+              result.usage.cost += usage.cost?.total || 0;
+              result.usage.contextTokens = usage.totalTokens || 0;
+            }
+            if (!result.model && msg.model) result.model = msg.model;
+            if (msg.stopReason) result.stopReason = msg.stopReason;
+            if (msg.errorMessage) result.errorMessage = msg.errorMessage;
+          }
+
+          options.onMessage?.(msg);
+        }
+
+        if (event.type === 'tool_result_end' && event.message) {
+          result.messages.push(event.message as Message);
+          options.onToolResult?.(event.message as Message);
+        }
+      };
+
+      proc.stdout.on('data', (data: Buffer) => {
+        buffer += data.toString();
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+        for (const line of lines) processLine(line);
+      });
+
+      proc.stderr.on('data', (data: Buffer) => {
+        result.stderr += data.toString();
+      });
+
+      proc.on('close', (code: number | null) => {
+        if (buffer.trim()) processLine(buffer);
+        resolve(code ?? 0);
+      });
+
+      proc.on('error', () => resolve(1));
+
+      if (options.signal) {
+        const killProc = () => {
+          result.wasAborted = true;
+          proc.kill('SIGTERM');
+          setTimeout(() => {
+            if (!proc.killed) proc.kill('SIGKILL');
+          }, 5000);
+        };
+        if (options.signal.aborted) killProc();
+        else options.signal.addEventListener('abort', killProc, { once: true });
+      }
+    });
+
+    result.exitCode = exitCode;
+    return result;
+  } finally {
+    cleanupTempFiles(tmpPromptPath, tmpPromptDir);
+  }
+}

package/extensions/subagent/synthesis.ts

@@ -1,42 +1,7 @@
-import type { ExtensionCommandContext } from '@mariozechner/pi-coding-agent';
+import type { ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
 
 const MAX_MESSAGES = 40;
 
-const SYNTHESIS_INSTRUCTION = `Synthesize the current conversation into a clear task specification for a team of subagents that will execute it.
-
-Your synthesis MUST capture:
-
-1. **Goal** — What are we building, changing, or investigating?
-2. **Decisions made** — Every locked choice, preference, or constraint the user confirmed.
-3. **Constraints** — What was explicitly rejected and why.
-4. **Architecture** — The agreed structure, file layout, data flow, or integration shape.
-5. **Open questions** — Anything flagged but not resolved yet.
-6. **Intent** — The user's real motivation and the nuance behind the decisions.
-
-Be specific and actionable. Do NOT summarize vaguely. Include concrete names, paths, tools, APIs, and patterns that were discussed.
-
-The output should be usable by agents who have NOT seen this conversation.
-
-Format:
-
-## Goal
-<one paragraph>
-
-## Decisions
-<bulleted list of every locked decision>
-
-## Constraints
-<bulleted list of what was rejected and why>
-
-## Architecture
-<concrete structure, files, data flow>
-
-## Open Questions
-<anything unresolved>
-
-## Intent
-<the user's real motivation>`;
-
 export function extractRecentConversation(ctx: ExtensionCommandContext): string {
   const entries = ctx.sessionManager.getBranch();
   const messages: string[] = [];
@@ -61,18 +26,3 @@ export function extractRecentConversation(ctx: ExtensionCommandContext): string
 
   return messages.slice(-MAX_MESSAGES).join('\n\n---\n\n');
 }
-
-export function buildSynthesisPrompt(conversation: string, explicitTask?: string): string {
-  const parts = [SYNTHESIS_INSTRUCTION];
-
-  if (explicitTask) {
-    parts.push(`\nThe user explicitly specified the task as:\n${explicitTask}`);
-    parts.push(
-      '\nUse this as the primary goal, but enrich it with relevant context from the conversation.',
-    );
-  }
-
-  parts.push(`\n\n## Conversation\n\n${conversation}`);
-
-  return parts.join('\n');
-}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dreki-gg/pi-subagent",
-  "version": "0.7.0",
-  "description": "Subagent tool and direct agent runs for pi — isolated agents, parallel scouts, manager workflows, and bundled agents",
+  "version": "0.8.0",
+  "description": "Subagent tool and direct agent runs for pi — isolated agents, parallel scouts, manager workflows, and bundled prompts",
   "keywords": [
     "pi-package"
   ],
@@ -26,8 +26,8 @@
     "skills": [
       "./skills"
     ],
-    "agents": [
-      "./agents"
+    "prompts": [
+      "./prompts"
     ]
   },
   "devDependencies": {
@@ -37,10 +37,10 @@
     "typescript": "^6.0.0"
   },
   "peerDependencies": {
-    "@mariozechner/pi-ai": "*",
-    "@mariozechner/pi-agent-core": "*",
-    "@mariozechner/pi-coding-agent": "*",
-    "@mariozechner/pi-tui": "*",
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-agent-core": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
     "typebox": "*"
   }
 }

package/skills/write-an-agent/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: write-an-agent
-description: Writes or refines concise pi subagent definitions for this repo, keeping each agent under 100 lines with a sharp role, tool policy, and output contract. Use when creating, rewriting, or tightening agent prompts in `.pi/agents/` or `packages/subagent/agents/`.
+description: Writes or refines concise pi subagent definitions for this repo, keeping each agent under 100 lines with a sharp role, tool policy, and output contract. Use when creating, rewriting, or tightening agent prompts in `.pi/prompts/` or `packages/subagent/prompts/`.
 ---
 
 # Write an Agent
@@ -8,8 +8,8 @@ description: Writes or refines concise pi subagent definitions for this repo, ke
 Goal: produce a high-signal agent file in fewer than 100 lines.
 
 ## Use this for
-- new repo-local agents in `.pi/agents/`
-- bundled package agents in `packages/subagent/agents/`
+- new repo-local agent prompts in `.pi/prompts/`
+- bundled package agent prompts in `packages/subagent/prompts/`
 - tightening bloated prompts into a crisp reusable worker
 
 ## Design rules
@@ -53,8 +53,8 @@ Output:
 7. Count lines. Trim anything decorative.
 
 ## Repo conventions
-- Repo-local overrides belong in `.pi/agents/`.
-- Bundled reusable agents belong in `packages/subagent/agents/`.
+- Repo-local overrides belong in `.pi/prompts/`.
+- Bundled reusable agent prompts belong in `packages/subagent/prompts/`.
 - For this repo, default roles are `scout`, `docs-scout`, `planner`, `worker`, `reviewer`.
 - Prefer local pi docs before external docs when writing `docs-scout`.
 - Mention validation commands in planner/worker/reviewer when package behavior changes.