@fitchmultz/pi-subagents 0.44.6 → 0.45.0

package/dist/shared/utils.js

@@ -2,34 +2,53 @@
  * General utility functions for the subagent extension
  */
 import * as fs from "node:fs";
-import * as os from "node:os";
 import * as path from "node:path";
-import { formatToolCall } from "./formatters.js";
+import { errorMessage, hasErrorCode, isRecord } from "./unknown.js";
+import { parseAsyncStatus } from "../runs/background/run-schemas.js";
+import { normalizeLegacyStatusAcceptance } from "../runs/background/legacy-status-acceptance.js";
 // ============================================================================
 // File System Utilities
 // ============================================================================
-export function getAgentDir() {
-    const configured = process.env.PI_CODING_AGENT_DIR;
-    if (configured === "~")
-        return os.homedir();
-    if (configured?.startsWith("~/"))
-        return path.join(os.homedir(), configured.slice(2));
-    return configured || path.join(os.homedir(), ".pi", "agent");
-}
+export { getAgentDir } from "./agent-dir.js";
 const statusCache = new Map();
-function getErrorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
+function rememberStatus(statusPath, version, status) {
+    statusCache.set(statusPath, { version, status });
+    if (statusCache.size > 50) {
+        const firstKey = statusCache.keys().next().value;
+        if (firstKey !== undefined) {
+            statusCache.delete(firstKey);
+        }
+    }
 }
 export function resolveChildCwd(baseCwd, childCwd) {
-    if (!childCwd)
+    if (childCwd === undefined || childCwd === "") {
         return baseCwd;
+    }
     return path.isAbsolute(childCwd) ? childCwd : path.resolve(baseCwd, childCwd);
 }
 function isNotFoundError(error) {
-    return typeof error === "object"
-        && error !== null
-        && "code" in error
-        && error.code === "ENOENT";
+    return hasErrorCode(error, "ENOENT");
+}
+function parseStatusForDisplay(value) {
+    try {
+        return parseAsyncStatus(value);
+    }
+    catch (error) {
+        if (!isRecord(value)) {
+            throw error;
+        }
+        // Legacy display metadata may be corrupt; every other persisted field must validate.
+        const { parallelGroups, ...remaining } = value;
+        if (parallelGroups === undefined) {
+            throw error;
+        }
+        try {
+            return parseAsyncStatus(remaining);
+        }
+        catch {
+            throw error;
+        }
+    }
 }
 /**
  * Read async job status from disk, invalidating on replacement and in-place updates.
@@ -45,8 +64,8 @@ export function readStatus(asyncDir) {
             statusCache.delete(statusPath);
             return null;
         }
-        throw new Error(`Failed to inspect async status file '${statusPath}': ${getErrorMessage(error)}`, {
-            cause: error instanceof Error ? error : undefined,
+        throw new Error(`Failed to inspect async status file '${statusPath}': ${errorMessage(error)}`, {
+            cause: error,
         });
     }
     const cached = statusCache.get(statusPath);
@@ -59,27 +78,24 @@ export function readStatus(asyncDir) {
         content = fs.readFileSync(statusPath, "utf-8");
     }
     catch (error) {
-        if (isNotFoundError(error))
+        if (isNotFoundError(error)) {
             return null;
-        throw new Error(`Failed to read async status file '${statusPath}': ${getErrorMessage(error)}`, {
-            cause: error instanceof Error ? error : undefined,
+        }
+        throw new Error(`Failed to read async status file '${statusPath}': ${errorMessage(error)}`, {
+            cause: error,
         });
     }
     let status;
     try {
-        status = JSON.parse(content);
+        const parsed = JSON.parse(content);
+        status = parseStatusForDisplay(normalizeLegacyStatusAcceptance(parsed));
     }
     catch (error) {
-        throw new Error(`Failed to parse async status file '${statusPath}': ${getErrorMessage(error)}`, {
-            cause: error instanceof Error ? error : undefined,
+        throw new Error(`Failed to parse async status file '${statusPath}': ${errorMessage(error)}`, {
+            cause: error,
         });
     }
-    statusCache.set(statusPath, { version, status });
-    if (statusCache.size > 50) {
-        const firstKey = statusCache.keys().next().value;
-        if (firstKey)
-            statusCache.delete(firstKey);
-    }
+    rememberStatus(statusPath, version, status);
     return status;
 }
 /**
@@ -89,12 +105,14 @@ export function findLatestSessionFile(sessionDir) {
     try {
         let latest;
         for (const file of fs.readdirSync(sessionDir)) {
-            if (!file.endsWith(".jsonl"))
+            if (!file.endsWith(".jsonl")) {
                 continue;
+            }
             const filePath = path.join(sessionDir, file);
             const mtime = fs.statSync(filePath).mtimeMs;
-            if (!latest || mtime > latest.mtime)
+            if (!latest || mtime > latest.mtime) {
                 latest = { path: filePath, mtime };
+            }
         }
         return latest?.path ?? null;
     }
@@ -102,233 +120,9 @@ export function findLatestSessionFile(sessionDir) {
         return null;
     }
 }
-// ============================================================================
-// Message Parsing Utilities
-// ============================================================================
-/**
- * Get the final text output from a list of messages
- */
-export function getFinalOutput(messages) {
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const msg = messages[i];
-        if (msg.role === "assistant") {
-            const hasAssistantError = ("errorMessage" in msg && typeof msg.errorMessage === "string" && msg.errorMessage.length > 0)
-                || ("stopReason" in msg && msg.stopReason === "error");
-            if (hasAssistantError)
-                continue;
-            for (let j = msg.content.length - 1; j >= 0; j--) {
-                const part = msg.content[j];
-                if (part.type === "text" && part.text.trim().length > 0)
-                    return part.text;
-            }
-        }
-    }
-    return "";
-}
-export function getSingleResultOutput(result) {
-    return result.finalOutput ?? getFinalOutput(result.messages ?? []);
-}
-export function formatResourceLimitExceeded(input) {
-    if (input.kind === "maxExecutionTimeMs") {
-        return `Resource limit exceeded for ${input.agent}: maxExecutionTimeMs ${input.limit}ms.`;
-    }
-    return `Resource limit exceeded for ${input.agent}: maxTokens ${input.limit}${input.observed !== undefined ? ` (observed ${input.observed})` : ""}.`;
-}
-/**
- * Extract display items (text and tool calls) from messages
- */
-export function getDisplayItems(messages) {
-    if (!messages || messages.length === 0)
-        return [];
-    const items = [];
-    for (const msg of messages) {
-        if (msg.role === "assistant") {
-            for (const part of msg.content) {
-                if (part.type === "text")
-                    items.push({ type: "text", text: part.text });
-                else if (part.type === "toolCall")
-                    items.push({ type: "tool", name: part.name, args: part.arguments });
-            }
-        }
-    }
-    return items;
-}
-function extractToolCallSummaries(messages) {
-    if (!messages?.length)
-        return [];
-    const summaries = [];
-    for (const msg of messages) {
-        if (msg.role !== "assistant")
-            continue;
-        for (const part of msg.content) {
-            if (part.type !== "toolCall")
-                continue;
-            const args = typeof part.arguments === "object" && part.arguments !== null && !Array.isArray(part.arguments)
-                ? part.arguments
-                : {};
-            summaries.push({
-                text: formatToolCall(part.name, args),
-                expandedText: formatToolCall(part.name, args, true),
-            });
-        }
-    }
-    return summaries;
-}
-export function compactForegroundResult(result) {
-    if (result.progress?.status === "running")
-        return result;
-    const toolCalls = result.toolCalls?.length ? result.toolCalls : extractToolCallSummaries(result.messages);
-    return {
-        ...result,
-        messages: undefined,
-        progress: undefined,
-        toolCalls: toolCalls.length ? toolCalls : undefined,
-    };
-}
-/**
- * Detect errors in subagent execution from messages (only errors with no subsequent success)
- */
-export function detectSubagentError(messages) {
-    let lastAssistantTextIndex = -1;
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const msg = messages[i];
-        if (msg.role === "assistant") {
-            const hasText = Array.isArray(msg.content) && msg.content.some((c) => c.type === "text" && "text" in c && typeof c.text === "string" && c.text.trim().length > 0);
-            if (hasText) {
-                lastAssistantTextIndex = i;
-                break;
-            }
-        }
-    }
-    const scanStart = lastAssistantTextIndex >= 0 ? lastAssistantTextIndex + 1 : 0;
-    for (let i = messages.length - 1; i >= scanStart; i--) {
-        const msg = messages[i];
-        if (msg.role !== "toolResult")
-            continue;
-        const toolName = "toolName" in msg && typeof msg.toolName === "string" ? msg.toolName : undefined;
-        const isError = "isError" in msg && msg.isError === true;
-        const observedExit = msg.observedExitCode;
-        if (isError) {
-            const text = msg.content.find((c) => c.type === "text");
-            const details = text && "text" in text ? text.text : undefined;
-            const exitMatch = details?.match(/exit(?:ed)?\s*(?:with\s*)?(?:code|status)?\s*[:\s]?\s*(\d+)/i);
-            return {
-                hasError: true,
-                exitCode: observedExit ?? (exitMatch ? parseInt(exitMatch[1], 10) : 1),
-                errorType: toolName || "tool",
-                details: details?.slice(0, 200),
-            };
-        }
-        if (toolName !== "bash")
-            continue;
-        const text = msg.content.find((c) => c.type === "text");
-        if (!text || !("text" in text))
-            continue;
-        const output = text.text;
-        const exitMatch = output.match(/exit(?:ed)?\s*(?:with\s*)?(?:code|status)?\s*[:\s]?\s*(\d+)/i);
-        if (exitMatch || observedExit !== undefined) {
-            const code = observedExit ?? parseInt(exitMatch[1], 10);
-            if (code !== 0) {
-                return { hasError: true, exitCode: code, errorType: "bash", details: output.slice(0, 200) };
-            }
-        }
-    }
-    return { hasError: false };
-}
-/**
- * Extract a preview of tool arguments for display
- */
-export function extractToolArgsPreview(args) {
-    const truncatePreview = (value, maxLength) => value.length > maxLength ? `${value.slice(0, maxLength - 3)}...` : value;
-    const stringifyPreviewValue = (value) => {
-        if (typeof value === "string" && value.trim().length > 0)
-            return value;
-        if (typeof value === "number" || typeof value === "boolean")
-            return String(value);
-        return undefined;
-    };
-    const previewArray = (value) => {
-        if (!Array.isArray(value) || value.length === 0)
-            return undefined;
-        const first = stringifyPreviewValue(value[0]);
-        if (!first)
-            return undefined;
-        const suffix = value.length > 1 ? ` (+${value.length - 1} more)` : "";
-        return `${first}${suffix}`;
-    };
-    // Handle MCP tool calls - show server/tool info
-    if (args.tool && typeof args.tool === "string") {
-        const server = args.server && typeof args.server === "string" ? `${args.server}/` : "";
-        const toolArgs = args.args && typeof args.args === "string" ? ` ${args.args.slice(0, 40)}` : "";
-        return `${server}${args.tool}${toolArgs}`;
-    }
-    const queriesPreview = previewArray(args.queries);
-    if (queriesPreview)
-        return truncatePreview(queriesPreview, 60);
-    if (typeof args.query === "string" && args.query.trim().length > 0)
-        return truncatePreview(args.query, 60);
-    if (typeof args.workflow === "string" && args.workflow.trim().length > 0)
-        return `workflow=${truncatePreview(args.workflow, 48)}`;
-    if (typeof args.url === "string" && args.url.trim().length > 0)
-        return truncatePreview(args.url, 60);
-    const urlsPreview = previewArray(args.urls);
-    if (urlsPreview)
-        return truncatePreview(urlsPreview, 60);
-    if (typeof args.prompt === "string" && args.prompt.trim().length > 0)
-        return truncatePreview(args.prompt, 60);
-    const previewKeys = ["command", "path", "file_path", "pattern", "query", "url", "task", "describe", "search"];
-    for (const key of previewKeys) {
-        if (args[key] && typeof args[key] === "string") {
-            const value = args[key];
-            return truncatePreview(value, 60);
-        }
-    }
-    // Fallback: show first string value found
-    for (const [key, value] of Object.entries(args)) {
-        const arrayPreview = previewArray(value);
-        if (arrayPreview)
-            return `${key}=${truncatePreview(arrayPreview, 50)}`;
-        if (typeof value === "string" && value.length > 0) {
-            const preview = truncatePreview(value, 50);
-            return `${key}=${preview}`;
-        }
-    }
-    return "";
-}
-/**
- * Extract text content from various message content formats
- */
-export function extractTextFromContent(content) {
-    if (!content)
-        return "";
-    // Handle string content directly
-    if (typeof content === "string")
-        return content;
-    // Handle array content
-    if (!Array.isArray(content))
-        return "";
-    const texts = [];
-    for (const part of content) {
-        if (part && typeof part === "object") {
-            // Handle { type: "text", text: "..." }
-            if ("type" in part && part.type === "text" && "text" in part) {
-                texts.push(String(part.text));
-            }
-            // Handle { type: "tool_result", content: "..." }
-            else if ("type" in part && part.type === "tool_result" && "content" in part) {
-                const inner = extractTextFromContent(part.content);
-                if (inner)
-                    texts.push(inner);
-            }
-            // Handle { text: "..." } without type
-            else if ("text" in part) {
-                texts.push(String(part.text));
-            }
-        }
-    }
-    return texts.join("\n");
-}
+export { getFinalOutput, getSingleResultOutput, formatResourceLimitExceeded, getDisplayItems, compactForegroundResult, detectSubagentError, } from "./message-output.js";
+export { extractToolArgsPreview, extractTextFromContent } from "./content-preview.js";
 // ============================================================================
 // Concurrency Utilities
 // ============================================================================
-export { mapConcurrent } from "../runs/shared/parallel-utils.js";
+export { mapConcurrent } from "./concurrency.js";

package/dist/slash/command-discovery.js

@@ -0,0 +1,82 @@
+import { discoverAgents, discoverAgentsAll } from "../agents/agents.js";
+import { resolveExecutionCwd } from "../shared/execution-cwd.js";
+function projectTrusted(state) {
+    return state.lastUiContext ? state.lastUiContext.isProjectTrusted() : true;
+}
+function completionCwd(pi, state) {
+    try {
+        return state.lastUiContext ? resolveExecutionCwd(pi, state.lastUiContext) : state.baseCwd;
+    }
+    catch {
+        return null;
+    }
+}
+export function assertKnownAgents(cwd, names, trusted) {
+    const agents = discoverAgents(cwd, "both", { projectTrusted: trusted }).agents;
+    for (const name of names) {
+        if (!agents.some((agent) => agent.name === name)) {
+            throw new Error(`Unknown agent: ${name}`);
+        }
+    }
+}
+function completionPosition(prefix) {
+    const lastArrow = prefix.lastIndexOf(" -> ");
+    const segment = lastArrow !== -1 ? prefix.slice(lastArrow + 4) : prefix;
+    if (segment.includes(" -- ") || segment.includes('"') || segment.includes("'")) {
+        return undefined;
+    }
+    const word = prefix.match(/(\S*)$/)?.at(1) ?? "";
+    return { word, before: prefix.slice(0, prefix.length - word.length) };
+}
+export function makeAgentCompletions(pi, state, multiAgent) {
+    return (prefix) => {
+        const cwd = completionCwd(pi, state);
+        if (cwd === null || cwd.length === 0) {
+            return null;
+        }
+        const agents = discoverAgents(cwd, "both", { projectTrusted: projectTrusted(state) }).agents;
+        if (!multiAgent) {
+            return prefix.includes(" ")
+                ? null
+                : agents
+                    .filter((agent) => agent.name.startsWith(prefix))
+                    .map((agent) => ({ value: agent.name, label: agent.name }));
+        }
+        const position = completionPosition(prefix);
+        if (!position) {
+            return null;
+        }
+        const { word: lastWord, before: beforeLastWord } = position;
+        if (lastWord === "->") {
+            return agents.map((agent) => ({ value: `${prefix} ${agent.name}`, label: agent.name }));
+        }
+        return agents
+            .filter((agent) => agent.name.startsWith(lastWord))
+            .map((agent) => ({ value: `${beforeLastWord}${agent.name}`, label: agent.name }));
+    };
+}
+export function discoverSavedChains(cwd, trusted) {
+    const chains = new Map();
+    for (const chain of discoverAgentsAll(cwd, { projectTrusted: trusted }).chains) {
+        const existing = chains.get(chain.name);
+        const projectOverride = existing?.source === "user" && chain.source === "project";
+        const jsonOverride = existing?.source === chain.source &&
+            chain.filePath.endsWith(".chain.json") &&
+            !existing.filePath.endsWith(".chain.json");
+        if (!existing || projectOverride || jsonOverride) {
+            chains.set(chain.name, chain);
+        }
+    }
+    return [...chains.values()];
+}
+export function makeChainCompletions(pi, state) {
+    return (prefix) => {
+        const cwd = completionCwd(pi, state);
+        if (prefix.includes(" ") || cwd === null || cwd.length === 0) {
+            return null;
+        }
+        return discoverSavedChains(cwd, projectTrusted(state))
+            .filter((chain) => chain.name.startsWith(prefix))
+            .map((chain) => ({ value: chain.name, label: chain.name }));
+    };
+}

package/dist/slash/command-input.js

@@ -0,0 +1,190 @@
+function inlineOption(key, value) {
+    switch (key) {
+        case "output":
+            return { output: value === "false" ? false : value };
+        case "outputMode":
+            if (value !== "inline" && value !== "file-only") {
+                throw new Error("outputMode must be inline or file-only.");
+            }
+            return { outputMode: value };
+        case "reads":
+            return {
+                reads: value === "false" ? false : value.split("+").filter((item) => item.length > 0),
+            };
+        case "model":
+            return { model: value.length > 0 ? value : undefined };
+        case "skill":
+        case "skills":
+            return {
+                skill: value === "false" ? false : value.split("+").filter((item) => item.length > 0),
+            };
+        case "progress":
+            if (value !== "true" && value !== "false") {
+                throw new Error("progress must be true or false.");
+            }
+            return { progress: value === "true" };
+        default:
+            throw new Error(`Unknown inline option '${key}'.`);
+    }
+}
+function parseInlineConfig(raw) {
+    const config = {};
+    for (const part of raw.split(",")) {
+        const trimmed = part.trim();
+        if (trimmed.length === 0) {
+            continue;
+        }
+        const eq = trimmed.indexOf("=");
+        if (eq === -1) {
+            if (trimmed !== "progress") {
+                throw new Error(`Unknown inline option '${trimmed}'.`);
+            }
+            config.progress = true;
+        }
+        else {
+            Object.assign(config, inlineOption(trimmed.slice(0, eq).trim(), trimmed.slice(eq + 1).trim()));
+        }
+    }
+    return config;
+}
+export function parseAgentToken(token) {
+    const bracket = token.indexOf("[");
+    if (bracket === -1) {
+        return { name: token, config: {} };
+    }
+    const end = token.lastIndexOf("]");
+    if (end !== token.length - 1 || end < bracket) {
+        throw new Error(`Malformed inline options in '${token}'; close the trailing ].`);
+    }
+    const name = token.slice(0, bracket);
+    if (name.length === 0) {
+        throw new Error("Agent name is required before inline options.");
+    }
+    return { name, config: parseInlineConfig(token.slice(bracket + 1, end)) };
+}
+export function extractExecutionFlags(rawArgs) {
+    let args = rawArgs.trim();
+    let asyncMode;
+    let fork = false;
+    while (true) {
+        const match = args.match(/(?:^| )(--bg|--fg|--fork)$/);
+        if (!match) {
+            break;
+        }
+        const flag = match.at(1);
+        if (flag === "--fork") {
+            fork = true;
+        }
+        else {
+            const nextAsync = flag === "--bg";
+            if (asyncMode !== undefined && asyncMode !== nextAsync) {
+                return { args, fork, error: "Choose only one of --bg or --fg" };
+            }
+            asyncMode = nextAsync;
+        }
+        args = args.slice(0, match.index).trim();
+    }
+    return { args, async: asyncMode, fork };
+}
+function parseSegment(segment) {
+    const trimmed = segment.trim();
+    const quoted = trimmed.match(/^(\S+(?:\[[^\]]*\])?)\s+(?:"([^"]*)"|'([^']*)')$/);
+    if (quoted) {
+        const agent = quoted.at(1) ?? "";
+        const task = quoted.at(2) ?? quoted.at(3) ?? "";
+        return { ...parseAgentToken(agent), task: task.length > 0 ? task : undefined };
+    }
+    const delimiter = trimmed.indexOf(" -- ");
+    if (delimiter === -1) {
+        return parseAgentToken(trimmed);
+    }
+    const task = trimmed.slice(delimiter + 4).trim();
+    return {
+        ...parseAgentToken(trimmed.slice(0, delimiter).trim()),
+        task: task.length > 0 ? task : undefined,
+    };
+}
+function sharedArguments(input, usage) {
+    const delimiter = input.indexOf(" -- ");
+    if (delimiter === -1) {
+        throw new Error(usage);
+    }
+    const agents = input.slice(0, delimiter).trim();
+    const task = input.slice(delimiter + 4).trim();
+    if (agents.length === 0 || task.length === 0) {
+        throw new Error(usage);
+    }
+    return {
+        steps: agents
+            .split(/\s+/)
+            .filter((token) => token.length > 0)
+            .map(parseAgentToken),
+        task,
+    };
+}
+function hasTask(step) {
+    return step?.task !== undefined && step.task.length > 0;
+}
+export function assertCommandTask(parsed, command) {
+    const { steps, task, perStep } = parsed;
+    if (command === "chain" && !hasTask(steps.at(0)) && (perStep || task.length === 0)) {
+        throw new Error('First step must have a task: /chain agent "task" -> agent2');
+    }
+    if (command === "parallel" && !steps.some(hasTask) && task.length === 0) {
+        throw new Error("At least one step must have a task");
+    }
+}
+export function parseAgentArgs(args, command) {
+    const input = args.trim();
+    const usage = `Usage: /${command} agent1 "task1" -> agent2 "task2"`;
+    const perStep = input.includes(" -> ");
+    const parsed = perStep
+        ? {
+            steps: input
+                .split(" -> ")
+                .filter((segment) => segment.trim().length > 0)
+                .map(parseSegment),
+        }
+        : sharedArguments(input, usage);
+    const task = "task" in parsed ? parsed.task : (parsed.steps.find(hasTask)?.task ?? "");
+    if (parsed.steps.length === 0) {
+        throw new Error(usage);
+    }
+    return { steps: parsed.steps, task, perStep };
+}
+export function parseSingleArgs(args) {
+    const input = args.trim();
+    if (input.length === 0) {
+        throw new Error("Usage: /run <agent> [task] [--bg|--fg] [--fork]");
+    }
+    const space = input.indexOf(" ");
+    const rawTask = space === -1 ? "" : input.slice(space + 1).trim();
+    const quoted = rawTask.match(/^(?:"([\s\S]*)"|'([\s\S]*)')$/);
+    return {
+        agent: parseAgentToken(space === -1 ? input : input.slice(0, space)),
+        task: quoted ? (quoted.at(1) ?? quoted.at(2) ?? "") : rawTask,
+    };
+}
+export function parseSavedChainArgs(args) {
+    const delimiter = args.indexOf(" -- ");
+    const usage = "Usage: /run-chain <chainName> -- <task> [--bg|--fg] [--fork]";
+    if (delimiter === -1) {
+        throw new Error(usage);
+    }
+    const name = args.slice(0, delimiter).trim();
+    const task = args.slice(delimiter + 4).trim();
+    if (name.length === 0 || task.length === 0) {
+        throw new Error(usage);
+    }
+    return { name, task };
+}
+export function inlineOverrides(config) {
+    return {
+        ...(config.output !== undefined ? { output: config.output } : {}),
+        ...(config.outputMode !== undefined ? { outputMode: config.outputMode } : {}),
+        ...(config.reads !== undefined ? { reads: config.reads } : {}),
+        ...(config.model !== undefined && config.model.length > 0 ? { model: config.model } : {}),
+        ...(config.skill !== undefined ? { skill: config.skill } : {}),
+        ...(config.progress !== undefined ? { progress: config.progress } : {}),
+    };
+}