gsd-pi 2.53.0 → 2.54.0-dev.16631ca

package/dist/cli.js

@@ -103,19 +103,6 @@ const cliFlags = parseCliArgs(process.argv);
 const isPrintMode = cliFlags.print || cliFlags.mode !== undefined;
 // Early resource-skew check — must run before TTY gate so version mismatch
 // errors surface even in non-TTY environments.
-exitIfManagedResourcesAreNewer(agentDir);
-// Early TTY check — must come before heavy initialization to avoid dangling
-// handles that prevent process.exit() from completing promptly.
-const hasSubcommand = cliFlags.messages.length > 0;
-if (!process.stdin.isTTY && !isPrintMode && !hasSubcommand && !cliFlags.listModels && !cliFlags.web) {
-    process.stderr.write('[gsd] Error: Interactive mode requires a terminal (TTY).\n');
-    process.stderr.write('[gsd] Non-interactive alternatives:\n');
-    process.stderr.write('[gsd]   gsd --print "your message"     Single-shot prompt\n');
-    process.stderr.write('[gsd]   gsd --mode rpc                 JSON-RPC over stdin/stdout\n');
-    process.stderr.write('[gsd]   gsd --mode mcp                 MCP server over stdin/stdout\n');
-    process.stderr.write('[gsd]   gsd --mode text "message"      Text output mode\n');
-    process.exit(1);
-}
 async function ensureRtkBootstrap() {
     if (ensureRtkBootstrap._done)
         return;
@@ -136,6 +123,25 @@ async function ensureRtkBootstrap() {
         process.stderr.write(`[gsd] Warning: RTK unavailable — continuing without shell-command compression (${rtkStatus.reason}).\n`);
     }
 }
+// `gsd update` — update to the latest version via npm
+if (cliFlags.messages[0] === 'update') {
+    const { runUpdate } = await import('./update-cmd.js');
+    await runUpdate();
+    process.exit(0);
+}
+exitIfManagedResourcesAreNewer(agentDir);
+// Early TTY check — must come before heavy initialization to avoid dangling
+// handles that prevent process.exit() from completing promptly.
+const hasSubcommand = cliFlags.messages.length > 0;
+if (!process.stdin.isTTY && !isPrintMode && !hasSubcommand && !cliFlags.listModels && !cliFlags.web) {
+    process.stderr.write('[gsd] Error: Interactive mode requires a terminal (TTY).\n');
+    process.stderr.write('[gsd] Non-interactive alternatives:\n');
+    process.stderr.write('[gsd]   gsd --print "your message"     Single-shot prompt\n');
+    process.stderr.write('[gsd]   gsd --mode rpc                 JSON-RPC over stdin/stdout\n');
+    process.stderr.write('[gsd]   gsd --mode mcp                 MCP server over stdin/stdout\n');
+    process.stderr.write('[gsd]   gsd --mode text "message"      Text output mode\n');
+    process.exit(1);
+}
 // `gsd <subcommand> --help` — show subcommand-specific help
 const subcommand = cliFlags.messages[0];
 if (subcommand && process.argv.includes('--help')) {
@@ -162,12 +168,6 @@ if (cliFlags.messages[0] === 'config') {
     await runOnboarding(authStorage);
     process.exit(0);
 }
-// `gsd update` — update to the latest version via npm
-if (cliFlags.messages[0] === 'update') {
-    const { runUpdate } = await import('./update-cmd.js');
-    await runUpdate();
-    process.exit(0);
-}
 // `gsd web stop [path|all]` — stop web server before anything else
 if (cliFlags.messages[0] === 'web' && cliFlags.messages[1] === 'stop') {
     const webFlags = parseWebCliArgs(process.argv);

package/dist/headless-ui.d.ts

@@ -18,6 +18,32 @@ interface ExtensionUIRequest {
     [key: string]: unknown;
 }
 export type { ExtensionUIRequest };
-export declare function handleExtensionUIRequest(event: ExtensionUIRequest, writeToStdin: (data: string) => void): void;
-export declare function formatProgress(event: Record<string, unknown>, verbose: boolean): string | null;
-export declare function startSupervisedStdinReader(stdinWriter: (data: string) => void, client: RpcClient, onResponse: (id: string) => void): () => void;
+/** Context passed alongside an event for richer formatting. */
+export interface ProgressContext {
+    verbose: boolean;
+    toolDuration?: number;
+    lastCost?: {
+        costUsd: number;
+        inputTokens: number;
+        outputTokens: number;
+    };
+    thinkingPreview?: string;
+    isError?: boolean;
+}
+/**
+ * Produce a short human-readable summary of tool arguments.
+ * Returns a string like "path/to/file.ts" or "grep pattern *.ts" — never the
+ * full JSON blob.
+ */
+export declare function summarizeToolArgs(toolName: unknown, toolInput: unknown): string;
+export declare function handleExtensionUIRequest(event: ExtensionUIRequest, client: RpcClient): void;
+export declare function formatProgress(event: Record<string, unknown>, ctx: ProgressContext): string | null;
+/**
+ * Format a thinking preview line from accumulated LLM text deltas.
+ */
+export declare function formatThinkingLine(text: string): string;
+/**
+ * Format a cost line (used for periodic cost updates in verbose mode).
+ */
+export declare function formatCostLine(costUsd: number, inputTokens: number, outputTokens: number): string;
+export declare function startSupervisedStdinReader(client: RpcClient, onResponse: (id: string) => void): () => void;

package/dist/headless-ui.js

@@ -5,13 +5,107 @@
  * formats progress events for stderr output, and reads orchestrator
  * commands from stdin in supervised mode.
  */
-import { attachJsonlLineReader, serializeJsonLine } from '@gsd/pi-coding-agent';
+import { attachJsonlLineReader } from '@gsd/pi-coding-agent';
+// ---------------------------------------------------------------------------
+// ANSI Color Helpers
+// ---------------------------------------------------------------------------
+const _c = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    italic: '\x1b[3m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m',
+};
+/** Build a no-op color map (all codes empty). */
+function noColor() {
+    const nc = {};
+    for (const k of Object.keys(_c))
+        nc[k] = '';
+    return nc;
+}
+const colorsDisabled = !!process.env['NO_COLOR'] || !process.stderr.isTTY;
+const c = colorsDisabled ? noColor() : _c;
+// ---------------------------------------------------------------------------
+// Tool-Arg Summarizer
+// ---------------------------------------------------------------------------
+/**
+ * Produce a short human-readable summary of tool arguments.
+ * Returns a string like "path/to/file.ts" or "grep pattern *.ts" — never the
+ * full JSON blob.
+ */
+export function summarizeToolArgs(toolName, toolInput) {
+    const name = String(toolName ?? '');
+    const input = (toolInput && typeof toolInput === 'object') ? toolInput : {};
+    switch (name) {
+        case 'Read':
+        case 'read':
+            return shortPath(input.file_path) || '';
+        case 'Write':
+        case 'write':
+            return shortPath(input.file_path) || '';
+        case 'Edit':
+        case 'edit':
+            return shortPath(input.file_path) || '';
+        case 'Bash':
+        case 'bash': {
+            const cmd = String(input.command ?? '');
+            return cmd.length > 80 ? cmd.slice(0, 77) + '...' : cmd;
+        }
+        case 'Glob':
+        case 'glob':
+            return String(input.pattern ?? '');
+        case 'Grep':
+        case 'grep':
+        case 'Search':
+        case 'search': {
+            const pat = String(input.pattern ?? '');
+            const g = input.glob ? ` ${input.glob}` : '';
+            return `${pat}${g}`;
+        }
+        case 'Task':
+        case 'task': {
+            const desc = String(input.description ?? input.prompt ?? '');
+            return desc.length > 60 ? desc.slice(0, 57) + '...' : desc;
+        }
+        default: {
+            // Fallback: show first string-valued key up to 60 chars
+            for (const v of Object.values(input)) {
+                if (typeof v === 'string' && v.length > 0) {
+                    return v.length > 60 ? v.slice(0, 57) + '...' : v;
+                }
+            }
+            return '';
+        }
+    }
+}
+function shortPath(p) {
+    if (typeof p !== 'string')
+        return '';
+    // Strip common CWD prefix to save space
+    const cwd = process.cwd();
+    if (p.startsWith(cwd + '/'))
+        return p.slice(cwd.length + 1);
+    // Strip /Users/*/Developer/ prefix
+    return p.replace(/^\/Users\/[^/]+\/Developer\//, '');
+}
+// ---------------------------------------------------------------------------
+// Format Duration
+// ---------------------------------------------------------------------------
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    const s = (ms / 1000).toFixed(1);
+    return `${s}s`;
+}
 // ---------------------------------------------------------------------------
 // Extension UI Auto-Responder
 // ---------------------------------------------------------------------------
-export function handleExtensionUIRequest(event, writeToStdin) {
+export function handleExtensionUIRequest(event, client) {
     const { id, method } = event;
-    let response;
     switch (method) {
         case 'select': {
             // Lock-guard prompts list "View status" first, but headless needs "Force start"
@@ -23,62 +117,156 @@ export function handleExtensionUIRequest(event, writeToStdin) {
                 if (forceOption)
                     selected = forceOption;
             }
-            response = { type: 'extension_ui_response', id, value: selected };
+            client.sendUIResponse(id, { value: selected });
             break;
         }
         case 'confirm':
-            response = { type: 'extension_ui_response', id, confirmed: true };
+            client.sendUIResponse(id, { confirmed: true });
             break;
         case 'input':
-            response = { type: 'extension_ui_response', id, value: '' };
+            client.sendUIResponse(id, { value: '' });
             break;
         case 'editor':
-            response = { type: 'extension_ui_response', id, value: event.prefill ?? '' };
+            client.sendUIResponse(id, { value: event.prefill ?? '' });
             break;
         case 'notify':
         case 'setStatus':
         case 'setWidget':
         case 'setTitle':
         case 'set_editor_text':
-            response = { type: 'extension_ui_response', id, value: '' };
+            client.sendUIResponse(id, { value: '' });
             break;
         default:
             process.stderr.write(`[headless] Warning: unknown extension_ui_request method "${method}", cancelling\n`);
-            response = { type: 'extension_ui_response', id, cancelled: true };
+            client.sendUIResponse(id, { cancelled: true });
             break;
     }
-    writeToStdin(serializeJsonLine(response));
 }
 // ---------------------------------------------------------------------------
 // Progress Formatter
 // ---------------------------------------------------------------------------
-export function formatProgress(event, verbose) {
+export function formatProgress(event, ctx) {
     const type = String(event.type ?? '');
+    // Emit accumulated thinking preview before tool calls
+    if (ctx.thinkingPreview) {
+        // thinkingPreview is handled by the caller in headless.ts — it prepends
+        // the thinking line before the current event's line. We return the thinking
+        // line as a prefix joined with newline.
+    }
     switch (type) {
-        case 'tool_execution_start':
-            if (verbose)
-                return `  [tool]    ${event.toolName ?? 'unknown'}`;
-            return null;
+        case 'tool_execution_start': {
+            if (!ctx.verbose)
+                return null;
+            const name = String(event.toolName ?? 'unknown');
+            const args = summarizeToolArgs(event.toolName, event.args);
+            const argStr = args ? ` ${c.dim}${args}${c.reset}` : '';
+            return `  ${c.dim}[tool]${c.reset}    ${name}${argStr}`;
+        }
+        case 'tool_execution_end': {
+            if (!ctx.verbose)
+                return null;
+            const name = String(event.toolName ?? 'unknown');
+            const durationStr = ctx.toolDuration != null ? ` ${c.dim}${formatDuration(ctx.toolDuration)}${c.reset}` : '';
+            if (ctx.isError) {
+                return `  ${c.red}[tool]    ${name} error${c.reset}${durationStr}`;
+            }
+            return `  ${c.dim}[tool]    ${name} done${c.reset}${durationStr}`;
+        }
         case 'agent_start':
-            return '[agent]   Session started';
-        case 'agent_end':
-            return '[agent]   Session ended';
-        case 'extension_ui_request':
-            if (event.method === 'notify') {
-                return `[gsd]     ${event.message ?? ''}`;
+            return `${c.dim}[agent]   Session started${c.reset}`;
+        case 'agent_end': {
+            let line = `${c.dim}[agent]   Session ended${c.reset}`;
+            if (ctx.lastCost) {
+                const cost = `$${ctx.lastCost.costUsd.toFixed(4)}`;
+                const tokens = `${ctx.lastCost.inputTokens + ctx.lastCost.outputTokens} tokens`;
+                line += ` ${c.dim}(${cost}, ${tokens})${c.reset}`;
+            }
+            return line;
+        }
+        case 'extension_ui_request': {
+            const method = String(event.method ?? '');
+            if (method === 'notify') {
+                const msg = String(event.message ?? '');
+                if (!msg)
+                    return null;
+                // Bold important notifications
+                const isImportant = /^(committed:|verification gate:|milestone|blocked:)/i.test(msg);
+                return isImportant
+                    ? `${c.bold}[gsd]     ${msg}${c.reset}`
+                    : `[gsd]     ${msg}`;
             }
-            if (event.method === 'setStatus') {
-                return `[status]  ${event.message ?? ''}`;
+            if (method === 'setStatus') {
+                // Parse statusKey for phase transitions
+                const statusKey = String(event.statusKey ?? '');
+                const msg = String(event.message ?? '');
+                if (!statusKey && !msg)
+                    return null; // suppress empty status lines
+                // Show meaningful phase transitions
+                if (statusKey) {
+                    const label = parsePhaseLabel(statusKey, msg);
+                    if (label)
+                        return `${c.cyan}[phase]   ${label}${c.reset}`;
+                }
+                // Fallback: show message if non-empty
+                if (msg)
+                    return `${c.cyan}[phase]   ${msg}${c.reset}`;
+                return null;
             }
             return null;
+        }
         default:
             return null;
     }
 }
+/**
+ * Format a thinking preview line from accumulated LLM text deltas.
+ */
+export function formatThinkingLine(text) {
+    const trimmed = text.replace(/\s+/g, ' ').trim();
+    const truncated = trimmed.length > 120 ? trimmed.slice(0, 117) + '...' : trimmed;
+    return `${c.dim}${c.italic}[thinking] ${truncated}${c.reset}`;
+}
+/**
+ * Format a cost line (used for periodic cost updates in verbose mode).
+ */
+export function formatCostLine(costUsd, inputTokens, outputTokens) {
+    return `${c.dim}[cost]    $${costUsd.toFixed(4)} (${inputTokens + outputTokens} tokens)${c.reset}`;
+}
+// ---------------------------------------------------------------------------
+// Phase Label Parser
+// ---------------------------------------------------------------------------
+/**
+ * Parse a statusKey into a human-readable phase label.
+ * statusKey format varies but common patterns:
+ *   "milestone:M1", "slice:S1.1", "task:T1.1.1", "phase:discuss", etc.
+ */
+function parsePhaseLabel(statusKey, message) {
+    // Direct phase/milestone/slice/task keys
+    const parts = statusKey.split(':');
+    if (parts.length >= 2) {
+        const [kind, value] = parts;
+        switch (kind.toLowerCase()) {
+            case 'milestone':
+                return `Milestone ${value}${message ? ' -- ' + message : ''}`;
+            case 'slice':
+                return `Slice ${value}${message ? ' -- ' + message : ''}`;
+            case 'task':
+                return `Task ${value}${message ? ' -- ' + message : ''}`;
+            case 'phase':
+                return `Phase: ${value}${message ? ' -- ' + message : ''}`;
+            default:
+                return `${kind}: ${value}${message ? ' -- ' + message : ''}`;
+        }
+    }
+    // Single-word status keys with a message
+    if (message)
+        return `${statusKey}: ${message}`;
+    return statusKey || null;
+}
 // ---------------------------------------------------------------------------
 // Supervised Stdin Reader
 // ---------------------------------------------------------------------------
-export function startSupervisedStdinReader(stdinWriter, client, onResponse) {
+export function startSupervisedStdinReader(client, onResponse) {
     return attachJsonlLineReader(process.stdin, (line) => {
         let msg;
         try {
@@ -90,12 +278,17 @@ export function startSupervisedStdinReader(stdinWriter, client, onResponse) {
         }
         const type = String(msg.type ?? '');
         switch (type) {
-            case 'extension_ui_response':
-                stdinWriter(line + '\n');
-                if (typeof msg.id === 'string') {
-                    onResponse(msg.id);
+            case 'extension_ui_response': {
+                const id = String(msg.id ?? '');
+                const value = msg.value !== undefined ? String(msg.value) : undefined;
+                const confirmed = typeof msg.confirmed === 'boolean' ? msg.confirmed : undefined;
+                const cancelled = typeof msg.cancelled === 'boolean' ? msg.cancelled : undefined;
+                client.sendUIResponse(id, { value, confirmed, cancelled });
+                if (id) {
+                    onResponse(id);
                 }
                 break;
+            }
             case 'prompt':
                 client.prompt(String(msg.message ?? ''));
                 break;

package/dist/headless.d.ts

@@ -11,6 +11,7 @@
  *   10 — blocked (command reported a blocker)
  *   11 — cancelled (SIGINT/SIGTERM received)
  */
+import type { SessionInfo } from '@gsd/pi-coding-agent';
 import type { OutputFormat } from './headless-types.js';
 export interface HeadlessOptions {
     timeout: number;
@@ -31,5 +32,15 @@ export interface HeadlessOptions {
     resumeSession?: string;
     bare?: boolean;
 }
+export interface ResumeSessionResult {
+    session?: SessionInfo;
+    error?: string;
+}
+/**
+ * Resolve a session prefix to a single session.
+ * Exact id match is preferred over prefix match.
+ * Returns `{ session }` on unique match or `{ error }` on 0/ambiguous matches.
+ */
+export declare function resolveResumeSession(sessions: SessionInfo[], prefix: string): ResumeSessionResult;
 export declare function parseHeadlessArgs(argv: string[]): HeadlessOptions;
 export declare function runHeadless(options: HeadlessOptions): Promise<void>;