@fitchmultz/pi-subagents 0.49.1 → 0.50.0

package/dist/slash/result-delivery.js

@@ -1,237 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { Key, matchesKey } from "@earendil-works/pi-tui";
-import { errorMessage, isRecord } from "../shared/unknown.js";
-import { isTuiContext } from "../shared/ui-mode.js";
-import { SLASH_RESULT_TYPE, SLASH_SUBAGENT_CANCEL_EVENT, SLASH_SUBAGENT_REQUEST_EVENT, SLASH_SUBAGENT_RESPONSE_EVENT, SLASH_SUBAGENT_STARTED_EVENT, SLASH_SUBAGENT_UPDATE_EVENT, } from "../shared/types.js";
-import { applySlashUpdate, buildSlashInitialResult, failSlashResult, finalizeSlashResult, } from "./slash-live-state.js";
-import { slashResponse, slashUpdate } from "./request-protocol.js";
-function disposeSubscriptions(subscriptions) {
-    for (const unsubscribe of subscriptions) {
-        try {
-            unsubscribe();
-        }
-        catch (error) {
-            console.error("Could not unsubscribe slash subagent request:", error);
-        }
-    }
-}
-function subscribeRequest(pi, ctx, requestId, callbacks) {
-    const subscriptions = [];
-    const dispose = () => {
-        disposeSubscriptions(subscriptions);
-    };
-    try {
-        subscriptions.push(pi.events.on(SLASH_SUBAGENT_STARTED_EVENT, (data) => {
-            if (callbacks.active() && isRecord(data) && data.requestId === requestId) {
-                callbacks.started();
-                if (ctx.hasUI) {
-                    ctx.ui.setStatus("subagent-slash", "running...");
-                }
-            }
-        }));
-        subscriptions.push(pi.events.on(SLASH_SUBAGENT_RESPONSE_EVENT, (data) => {
-            if (!callbacks.active()) {
-                return;
-            }
-            try {
-                const parsed = slashResponse(data, requestId);
-                if (parsed) {
-                    callbacks.response(parsed);
-                }
-            }
-            catch (error) {
-                if (!(error instanceof Error)) {
-                    throw error;
-                }
-                callbacks.failed(error);
-            }
-        }));
-        subscriptions.push(pi.events.on(SLASH_SUBAGENT_UPDATE_EVENT, (data) => {
-            if (!callbacks.active()) {
-                return;
-            }
-            const parsed = slashUpdate(data, requestId);
-            if (!parsed) {
-                return;
-            }
-            applySlashUpdate(requestId, parsed);
-            if (ctx.hasUI) {
-                const tool = parsed.currentTool ?? "";
-                ctx.ui.setStatus("subagent-slash", `${parsed.toolCount ?? 0} tools${tool.length > 0 ? ` ${tool}` : ""}`);
-            }
-        }));
-        const terminal = isTuiContext(ctx)
-            ? ctx.ui.onTerminalInput((input) => {
-                if (!callbacks.active() || !matchesKey(input, Key.escape)) {
-                    return;
-                }
-                pi.events.emit(SLASH_SUBAGENT_CANCEL_EVENT, { requestId });
-                callbacks.failed(new Error("Cancelled"));
-                return { consume: true };
-            })
-            : undefined;
-        if (terminal) {
-            subscriptions.push(terminal);
-        }
-        return dispose;
-    }
-    catch (error) {
-        dispose();
-        throw error;
-    }
-}
-class PendingSlashRequest {
-    pending = Promise.withResolvers();
-    timer;
-    started = false;
-    settled = false;
-    constructor() {
-        this.timer = setTimeout(() => this.fail(new Error("Slash subagent bridge did not start within 15s. Ensure the extension is loaded correctly.")), 15_000);
-    }
-    active() {
-        return !this.settled;
-    }
-    admitted() {
-        return this.started;
-    }
-    result() {
-        return this.pending.promise;
-    }
-    start() {
-        this.started = true;
-        clearTimeout(this.timer);
-    }
-    respond(response) {
-        if (this.settled) {
-            return;
-        }
-        this.settled = true;
-        clearTimeout(this.timer);
-        this.pending.resolve(response);
-    }
-    fail(error) {
-        if (this.settled) {
-            return;
-        }
-        this.settled = true;
-        clearTimeout(this.timer);
-        this.pending.reject(error);
-    }
-    dispose() {
-        clearTimeout(this.timer);
-    }
-}
-async function requestSlashRun(pi, ctx, request) {
-    const pending = new PendingSlashRequest();
-    let dispose;
-    try {
-        dispose = subscribeRequest(pi, ctx, request.requestId, {
-            active: () => pending.active(),
-            started: () => {
-                pending.start();
-            },
-            response: (response) => {
-                pending.respond(response);
-            },
-            failed: (error) => {
-                pending.fail(error);
-            },
-        });
-        pi.events.emit(SLASH_SUBAGENT_REQUEST_EVENT, request);
-        // STARTED is synchronous: its absence means no bridge admitted this request.
-        if (!pending.admitted() && pending.active()) {
-            pending.fail(new Error("No slash subagent bridge responded. Ensure the subagent extension is loaded correctly."));
-        }
-        return await pending.result();
-    }
-    catch (error) {
-        // A synchronous response may settle before a later subscription or bus listener fails.
-        if (!pending.active()) {
-            return await pending.result();
-        }
-        throw error;
-    }
-    finally {
-        pending.dispose();
-        dispose?.();
-    }
-}
-function messageText(content) {
-    return content
-        .filter((part) => part.type === "text")
-        .map((part) => part.text)
-        .join("\n");
-}
-function resultPaths(results, getPath) {
-    return results
-        .map(getPath)
-        .filter((file) => file !== undefined && file.length > 0);
-}
-function fallbackText(text) {
-    return text.length > 0 ? text : "(no output)";
-}
-function exportText(response) {
-    const output = messageText(response.result.content);
-    const results = response.result.details.results;
-    const fallback = response.errorText ?? "";
-    const sections = ["## Subagent result", output.length > 0 ? output : fallbackText(fallback)];
-    for (const [title, paths] of [
-        ["Child session exports", resultPaths(results, (result) => result.sessionFile)],
-        ["Saved outputs", resultPaths(results, (result) => result.savedOutputPath)],
-        ["Artifact outputs", resultPaths(results, (result) => result.artifactPaths?.outputPath)],
-    ]) {
-        if (paths.length > 0) {
-            sections.push(`## ${title}`, paths.map((file) => `- \`${file}\``).join("\n"));
-        }
-    }
-    return sections.join("\n\n");
-}
-function finishSlashStatus(ctx, response) {
-    if (!ctx.hasUI) {
-        return;
-    }
-    ctx.ui.setStatus("subagent-slash", undefined);
-    if (response.isError) {
-        const error = response.errorText ?? "";
-        ctx.ui.notify(error.length > 0 ? error : "Subagent failed", "error");
-    }
-}
-export async function runSlashSubagent(pi, ctx, params, executionCwd) {
-    const requestId = randomUUID();
-    const initialDetails = buildSlashInitialResult(requestId, params);
-    const text = messageText(initialDetails.result.content);
-    pi.sendMessage({
-        customType: SLASH_RESULT_TYPE,
-        content: text.length > 0 ? text : "Running subagent...",
-        display: true,
-        details: initialDetails,
-    });
-    try {
-        const response = await requestSlashRun(pi, ctx, {
-            requestId,
-            params,
-            ...(executionCwd !== undefined && executionCwd.length > 0 ? { executionCwd } : {}),
-        });
-        const finalDetails = finalizeSlashResult(response);
-        pi.sendMessage({
-            customType: SLASH_RESULT_TYPE,
-            content: exportText(response),
-            display: false,
-            details: finalDetails,
-        });
-        finishSlashStatus(ctx, response);
-    }
-    catch (error) {
-        const message = errorMessage(error);
-        pi.sendMessage({
-            customType: SLASH_RESULT_TYPE,
-            content: `## Subagent result\n\n${message}`,
-            display: false,
-            details: failSlashResult(requestId, params, message),
-        });
-        if (ctx.hasUI) {
-            ctx.ui.setStatus("subagent-slash", undefined);
-            ctx.ui.notify(message, message === "Cancelled" ? "warning" : "error");
-        }
-    }
-}

package/dist/slash/saved-chain.js

@@ -1,78 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { isRecord, isUnknownArray } from "../shared/unknown.js";
-import { assertJsonSchemaObject } from "../runs/shared/structured-output.js";
-import { normalizeSubagentParamsLike, } from "../runs/foreground/subagent-executor.js";
-function loadOutputSchema(chain, agent, value) {
-    if (value === undefined) {
-        return undefined;
-    }
-    if (typeof value === "string") {
-        const file = path.isAbsolute(value) ? value : path.join(path.dirname(chain.filePath), value);
-        const parsed = JSON.parse(fs.readFileSync(file, "utf-8"));
-        assertJsonSchemaObject(parsed, `outputSchema for chain '${chain.name}' step '${agent}' (${file})`);
-        return parsed;
-    }
-    assertJsonSchemaObject(value, `outputSchema for chain '${chain.name}' step '${agent}'`);
-    return value;
-}
-function taskWithSchema(chain, task) {
-    if (!isRecord(task) || typeof task.agent !== "string") {
-        throw new Error(`Chain '${chain.name}' contains a task without an agent.`);
-    }
-    const { outputSchema: raw, ...rest } = task;
-    const outputSchema = loadOutputSchema(chain, task.agent, raw);
-    return { ...rest, ...(outputSchema !== undefined ? { outputSchema } : {}) };
-}
-function dynamicStep(chain, step) {
-    if (!isRecord(step.collect) || typeof step.collect.as !== "string") {
-        throw new Error(`Chain '${chain.name}' dynamic collection requires an output name.`);
-    }
-    const schema = loadOutputSchema(chain, `${step.collect.as} collection`, step.collect.outputSchema);
-    return {
-        ...step,
-        parallel: taskWithSchema(chain, step.parallel),
-        collect: { ...step.collect, ...(schema !== undefined ? { outputSchema: schema } : {}) },
-    };
-}
-function nonempty(value) {
-    return typeof value === "string" && value.length > 0;
-}
-function sequentialStep(chain, step) {
-    if (typeof step.agent !== "string") {
-        throw new Error(`Chain '${chain.name}' contains a step without an agent.`);
-    }
-    const outputSchema = loadOutputSchema(chain, step.agent, step.outputSchema);
-    const named = {};
-    for (const key of ["task", "phase", "label", "as"]) {
-        if (nonempty(step[key])) {
-            named[key] = step[key];
-        }
-    }
-    return {
-        agent: step.agent,
-        ...named,
-        ...(step.cwd !== undefined ? { cwd: step.cwd } : {}),
-        ...(outputSchema !== undefined ? { outputSchema } : {}),
-        output: step.output,
-        outputMode: step.outputMode,
-        reads: step.reads,
-        progress: step.progress,
-        skill: step.skill ?? step.skills,
-        model: step.model,
-        ...(step.acceptance !== undefined ? { acceptance: step.acceptance } : {}),
-    };
-}
-function resolveStep(chain, step) {
-    if (isUnknownArray(step.parallel)) {
-        return { ...step, parallel: step.parallel.map((task) => taskWithSchema(chain, task)) };
-    }
-    return "expand" in step && "collect" in step && "parallel" in step
-        ? dynamicStep(chain, step)
-        : sequentialStep(chain, step);
-}
-/** Resolve file schemas before the executor's canonical argument decoder owns the runtime shape. */
-export function mapSavedChainSteps(chain) {
-    const steps = chain.steps.map((step) => resolveStep(chain, { ...step }));
-    return [...(normalizeSubagentParamsLike({ chain: steps }).chain ?? [])];
-}

package/dist/slash/slash-bridge.js

@@ -1,150 +0,0 @@
-import { normalizeSubagentParamsLike, } from "../runs/foreground/subagent-executor.js";
-import { errorMessage, isRecord } from "../shared/unknown.js";
-import { SLASH_SUBAGENT_CANCEL_EVENT, SLASH_SUBAGENT_REQUEST_EVENT, SLASH_SUBAGENT_RESPONSE_EVENT, SLASH_SUBAGENT_STARTED_EVENT, SLASH_SUBAGENT_UPDATE_EVENT, } from "../shared/types.js";
-function failedResponse(requestId, errorText, content = errorText) {
-    return {
-        requestId,
-        isError: true,
-        errorText,
-        result: {
-            content: [{ type: "text", text: content }],
-            details: { mode: "single", results: [] },
-        },
-    };
-}
-class SlashBridge {
-    options;
-    controllers = new Map();
-    pendingCancels = new Set();
-    subscriptions = [];
-    pending = new Set();
-    constructor(options) {
-        this.options = options;
-    }
-    register() {
-        this.subscribe(SLASH_SUBAGENT_CANCEL_EVENT, (data) => this.cancel(data));
-        this.subscribe(SLASH_SUBAGENT_REQUEST_EVENT, (data) => {
-            const operation = this.receive(data);
-            this.pending.add(operation);
-            operation
-                .finally(() => {
-                this.pending.delete(operation);
-            })
-                .catch((error) => {
-                console.error("Slash subagent bridge failed:", error);
-            });
-        });
-    }
-    subscribe(event, handler) {
-        const unsubscribe = this.options.events.on(event, handler);
-        if (typeof unsubscribe === "function") {
-            this.subscriptions.push(unsubscribe);
-        }
-    }
-    cancel(data) {
-        if (!isRecord(data) || typeof data.requestId !== "string") {
-            return;
-        }
-        const controller = this.controllers.get(data.requestId);
-        if (controller) {
-            controller.abort();
-        }
-        else {
-            this.pendingCancels.add(data.requestId);
-        }
-    }
-    respond(response) {
-        this.options.events.emit(SLASH_SUBAGENT_RESPONSE_EVENT, response);
-    }
-    async receive(data) {
-        if (!isRecord(data) || typeof data.requestId !== "string" || data.params === undefined) {
-            return;
-        }
-        const requestId = data.requestId;
-        const ctx = this.options.getContext();
-        if (!ctx) {
-            this.respond(failedResponse(requestId, "No active extension context.", "No active extension context for slash subagent execution."));
-            return;
-        }
-        if (!isRecord(data.params)) {
-            this.respond(failedResponse(requestId, "Slash subagent parameters must be an object."));
-            return;
-        }
-        let request;
-        try {
-            request = {
-                requestId,
-                params: normalizeSubagentParamsLike(data.params),
-                ...(typeof data.executionCwd === "string" ? { executionCwd: data.executionCwd } : {}),
-            };
-        }
-        catch (error) {
-            this.respond(failedResponse(requestId, errorMessage(error)));
-            return;
-        }
-        const controller = new AbortController();
-        this.controllers.set(requestId, controller);
-        if (this.pendingCancels.delete(requestId)) {
-            controller.abort();
-            this.respond(failedResponse(requestId, "Cancelled before start.", "Cancelled."));
-            this.controllers.delete(requestId);
-            return;
-        }
-        this.options.events.emit(SLASH_SUBAGENT_STARTED_EVENT, { requestId });
-        await this.execute(request, controller.signal, ctx);
-    }
-    async execute(request, signal, ctx) {
-        try {
-            const result = await this.options.execute({
-                toolCallId: request.requestId,
-                params: request.params,
-                signal,
-                onUpdate: (update) => {
-                    const progress = update.details.progress;
-                    const first = progress?.at(0);
-                    this.options.events.emit(SLASH_SUBAGENT_UPDATE_EVENT, {
-                        requestId: request.requestId,
-                        progress,
-                        currentTool: first?.currentTool,
-                        toolCount: first?.toolCount,
-                    });
-                },
-                ctx,
-                executionCwd: request.executionCwd,
-            });
-            this.respond({
-                requestId: request.requestId,
-                result,
-                isError: result.isError === true,
-                errorText: result.isError === true
-                    ? result.content.find((part) => part.type === "text")?.text
-                    : undefined,
-            });
-        }
-        catch (error) {
-            this.respond(failedResponse(request.requestId, errorMessage(error)));
-        }
-        finally {
-            this.controllers.delete(request.requestId);
-        }
-    }
-    cancelAll() {
-        for (const controller of this.controllers.values()) {
-            controller.abort();
-        }
-        this.controllers.clear();
-        this.pendingCancels.clear();
-    }
-    dispose() {
-        for (const unsubscribe of this.subscriptions) {
-            unsubscribe();
-        }
-        this.subscriptions.length = 0;
-        this.pendingCancels.clear();
-    }
-}
-export function registerSlashSubagentBridge(options) {
-    const bridge = new SlashBridge(options);
-    bridge.register();
-    return { cancelAll: () => bridge.cancelAll(), dispose: () => bridge.dispose() };
-}

package/dist/slash/slash-commands.js

@@ -1,136 +0,0 @@
-import { errorMessage } from "../shared/unknown.js";
-import { resolveExecutionCwd } from "../shared/execution-cwd.js";
-import { assertCommandTask, extractExecutionFlags, inlineOverrides, parseAgentArgs, parseSavedChainArgs, parseSingleArgs, } from "./command-input.js";
-import { assertKnownAgents, discoverSavedChains, makeAgentCompletions, makeChainCompletions, } from "./command-discovery.js";
-import { mapSavedChainSteps } from "./saved-chain.js";
-import { runSlashSubagent } from "./result-delivery.js";
-function executionFlags(args) {
-    const flags = extractExecutionFlags(args);
-    if (flags.error !== undefined) {
-        throw new Error(flags.error);
-    }
-    return flags;
-}
-function executionOverrides(flags) {
-    return {
-        ...(flags.async !== undefined ? { async: flags.async } : {}),
-        ...(flags.fork ? { context: "fork" } : {}),
-    };
-}
-function commandHandler(execute) {
-    return async (args, ctx) => {
-        try {
-            await execute(args, ctx);
-        }
-        catch (error) {
-            ctx.ui.notify(errorMessage(error), "error");
-        }
-    };
-}
-async function runSingle(pi, args, ctx) {
-    const flags = executionFlags(args);
-    const { agent, task } = parseSingleArgs(flags.args);
-    const cwd = resolveExecutionCwd(pi, ctx);
-    assertKnownAgents(cwd, [agent.name], ctx.isProjectTrusted());
-    const { reads, ...overrides } = inlineOverrides(agent.config);
-    const finalTask = reads !== undefined && reads !== false && reads.length > 0
-        ? `[Read from: ${reads.join(", ")}]\n\n${task}`
-        : task;
-    const params = {
-        agent: agent.name,
-        task: finalTask,
-        clarify: false,
-        agentScope: "both",
-        ...overrides,
-        ...executionOverrides(flags),
-    };
-    await runSlashSubagent(pi, ctx, params, cwd);
-}
-async function runChain(pi, args, ctx) {
-    const flags = executionFlags(args);
-    const cwd = resolveExecutionCwd(pi, ctx);
-    const parsed = parseAgentArgs(flags.args, "chain");
-    assertKnownAgents(cwd, parsed.steps.map((step) => step.name), ctx.isProjectTrusted());
-    assertCommandTask(parsed, "chain");
-    const chain = parsed.steps.map((step, index) => {
-        const task = step.task ?? (index === 0 && parsed.task.length > 0 ? parsed.task : undefined);
-        return {
-            agent: step.name,
-            ...(task !== undefined ? { task } : {}),
-            ...inlineOverrides(step.config),
-        };
-    });
-    await runSlashSubagent(pi, ctx, {
-        chain,
-        task: parsed.task,
-        clarify: false,
-        agentScope: "both",
-        ...executionOverrides(flags),
-    }, cwd);
-}
-async function runParallel(pi, args, ctx) {
-    const flags = executionFlags(args);
-    const cwd = resolveExecutionCwd(pi, ctx);
-    const parsed = parseAgentArgs(flags.args, "parallel");
-    assertKnownAgents(cwd, parsed.steps.map((step) => step.name), ctx.isProjectTrusted());
-    assertCommandTask(parsed, "parallel");
-    const tasks = parsed.steps.map((step) => Object.assign({ agent: step.name, task: step.task ?? parsed.task }, inlineOverrides(step.config)));
-    await runSlashSubagent(pi, ctx, {
-        tasks,
-        clarify: false,
-        agentScope: "both",
-        ...executionOverrides(flags),
-    }, cwd);
-}
-async function runSavedChain(pi, args, ctx) {
-    const flags = executionFlags(args);
-    const { name, task } = parseSavedChainArgs(flags.args);
-    const cwd = resolveExecutionCwd(pi, ctx);
-    const chain = discoverSavedChains(cwd, ctx.isProjectTrusted()).find((candidate) => candidate.name === name);
-    if (!chain) {
-        throw new Error(`Unknown chain: ${name}`);
-    }
-    let steps;
-    try {
-        steps = mapSavedChainSteps(chain);
-    }
-    catch (error) {
-        ctx.ui.notify(`Cannot load chain '${name}': ${errorMessage(error)}`, "error");
-        return;
-    }
-    await runSlashSubagent(pi, ctx, {
-        chain: steps,
-        task,
-        clarify: false,
-        agentScope: "both",
-        ...executionOverrides(flags),
-    }, cwd);
-}
-export function registerSlashCommands(pi, state) {
-    pi.registerCommand("run", {
-        description: "Run a subagent directly: /run agent[output=file] [task] [--bg|--fg] [--fork]",
-        getArgumentCompletions: makeAgentCompletions(pi, state, false),
-        handler: commandHandler((args, ctx) => runSingle(pi, args, ctx)),
-    });
-    pi.registerCommand("chain", {
-        description: 'Run agents in sequence: /chain scout "task" -> oracle [--bg|--fg] [--fork]',
-        getArgumentCompletions: makeAgentCompletions(pi, state, true),
-        handler: commandHandler((args, ctx) => runChain(pi, args, ctx)),
-    });
-    pi.registerCommand("run-chain", {
-        description: "Run a saved chain: /run-chain chainName -- task [--bg|--fg] [--fork]",
-        getArgumentCompletions: makeChainCompletions(pi, state),
-        handler: commandHandler((args, ctx) => runSavedChain(pi, args, ctx)),
-    });
-    pi.registerCommand("parallel", {
-        description: 'Run agents in parallel: /parallel scout "task1" -> oracle "task2" [--bg|--fg] [--fork]',
-        getArgumentCompletions: makeAgentCompletions(pi, state, true),
-        handler: commandHandler((args, ctx) => runParallel(pi, args, ctx)),
-    });
-    pi.registerCommand("subagents-doctor", {
-        description: "Show subagent diagnostics",
-        handler: async (_args, ctx) => {
-            await runSlashSubagent(pi, ctx, { action: "doctor" });
-        },
-    });
-}