pi-ui-extend 0.1.1

package/dist/tool-renderers/question.js

@@ -0,0 +1,88 @@
+import { argsRecord, expandedTextFromParts, renderWithArgsAndResult } from "./utils.js";
+const CUSTOM_ANSWER_LABEL = "Something else…";
+export const renderQuestionTool = (input) => {
+    const args = argsRecord(input);
+    const questions = questionItems(args?.questions);
+    const count = questions?.length;
+    if (!questions) {
+        return renderWithArgsAndResult(input, {
+            headerArgs: count != null ? `${count} question${count === 1 ? "" : "s"}` : undefined,
+            collapsedBody: input.output,
+        });
+    }
+    const resultText = formatQuestionResult(input.details, questions)
+        ?? (input.output.trim() || (input.status === "running" ? "waiting for answers…" : "(empty)"));
+    const questionsText = formatQuestions(questions);
+    return {
+        headerArgs: formatHeader(questions),
+        collapsedBody: resultText,
+        ...expandedTextFromParts({ text: questionsText, color: "muted" }, { text: input.isError ? `error\n${resultText}` : resultText }),
+    };
+};
+function questionItems(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    return value.filter(isPlainRecord);
+}
+function formatHeader(questions) {
+    const labels = questions
+        .map((question) => stringValue(question.label) ?? stringValue(question.id))
+        .filter((label) => label !== undefined);
+    const countText = `${questions.length} question${questions.length === 1 ? "" : "s"}`;
+    if (labels.length === 0)
+        return countText;
+    const suffix = labels.length > 3 ? ", …" : "";
+    return `${countText} · ${labels.slice(0, 3).join(", ")}${suffix}`;
+}
+function formatQuestions(questions) {
+    return questions.map((question, index) => {
+        const title = `◇ ${index + 1}/${questions.length} ${questionLabel(question)}`;
+        const prompt = stringValue(question.prompt) ?? "(no prompt)";
+        const choices = Array.isArray(question.choices)
+            ? question.choices.filter(isPlainRecord)
+            : [];
+        const choiceLines = choices.map((choice, choiceIndex) => {
+            const label = stringValue(choice.label) ?? stringValue(choice.value) ?? `Choice ${choiceIndex + 1}`;
+            const description = stringValue(choice.description);
+            return description ? `  ${choiceIndex + 1}. ${label} — ${description}` : `  ${choiceIndex + 1}. ${label}`;
+        });
+        choiceLines.push(`  ${choices.length + 1}. ${CUSTOM_ANSWER_LABEL} (custom answer)`);
+        return [title, `  ${prompt}`, ...choiceLines].join("\n");
+    }).join("\n\n");
+}
+function formatQuestionResult(details, questions) {
+    if (!isPlainRecord(details))
+        return undefined;
+    const questionLabels = new Map(questions.map((question) => [stringValue(question.id), questionLabel(question)]));
+    const questionDetails = details;
+    if (questionDetails.canceled === true) {
+        const reason = stringValue(questionDetails.reason) ?? "canceled";
+        const fallback = stringValue(questionDetails.fallbackPrompt);
+        return fallback ? `⚠ canceled: ${reason}\n\n${fallback}` : `⚠ canceled: ${reason}`;
+    }
+    if (!Array.isArray(questionDetails.answers))
+        return undefined;
+    if (questionDetails.answers.length === 0)
+        return "question returned no answers";
+    return questionDetails.answers
+        .filter(isPlainRecord)
+        .map((answer) => formatAnswer(answer, questionLabels))
+        .join("\n");
+}
+function formatAnswer(answer, questionLabels) {
+    const label = questionLabels.get(stringValue(answer.id)) ?? stringValue(answer.id) ?? "Question";
+    const answerLabel = stringValue(answer.label) ?? "(empty)";
+    if (answer.wasCustom === true)
+        return `✓ ${label}: ${answerLabel} (custom answer)`;
+    const index = typeof answer.index === "number" && Number.isFinite(answer.index) ? `choice ${answer.index}` : "choice";
+    return `✓ ${label}: ${answerLabel} (${index})`;
+}
+function questionLabel(question) {
+    return stringValue(question.label) ?? stringValue(question.id) ?? "Question";
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function isPlainRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/tool-renderers/read.d.ts

@@ -0,0 +1,2 @@
+import type { ToolRendererMiddleware } from "./types.js";
+export declare const renderReadTool: ToolRendererMiddleware;

package/dist/tool-renderers/read.js

@@ -0,0 +1,36 @@
+import { isAbsolute, relative, sep } from "node:path";
+import { syntaxHighlightLanguageForPath } from "../syntax-highlight.js";
+import { numberArg, stringArg } from "./utils.js";
+export const renderReadTool = (input) => {
+    const filePath = stringArg(input, ["path", "file", "target"]);
+    if (!filePath)
+        return undefined;
+    const displayPath = pathForDisplay(filePath, input.cwd);
+    const offset = numberArg(input, ["offset"]);
+    const limit = numberArg(input, ["limit"]);
+    const range = offset != null ? `:${offset}${limit != null ? `+${limit}` : ""}` : "";
+    const rendered = {
+        headerArgs: `${displayPath}${range}`,
+        collapsedBody: input.output,
+        expandedText: input.output || (input.status === "running" ? "running…" : "(empty)"),
+    };
+    const syntaxLanguage = !input.isError && input.output ? syntaxHighlightLanguageForPath(filePath) : undefined;
+    if (!syntaxLanguage)
+        return rendered;
+    return {
+        ...rendered,
+        syntaxHighlight: {
+            language: syntaxLanguage,
+            startLine: 0,
+            startColumn: 0,
+        },
+    };
+};
+function pathForDisplay(filePath, cwd) {
+    if (!cwd || !isAbsolute(filePath))
+        return filePath;
+    const relativePath = relative(cwd, filePath);
+    if (!relativePath)
+        return ".";
+    return relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath) ? filePath : relativePath.replace(/\\/gu, "/");
+}

package/dist/tool-renderers/repo.d.ts

@@ -0,0 +1,2 @@
+import type { ToolRendererMiddleware } from "./types.js";
+export declare const renderRepoTool: ToolRendererMiddleware;

package/dist/tool-renderers/repo.js

@@ -0,0 +1,13 @@
+import { argsRecord, formatArgsInline } from "./utils.js";
+const PREFERRED_KEYS = ["target", "path", "args", "maxLines", "maxBytes"];
+export const renderRepoTool = (input) => {
+    const args = argsRecord(input);
+    if (!args)
+        return undefined;
+    const result = input.output || (input.status === "running" ? "running…" : "(empty)");
+    return {
+        headerArgs: formatArgsInline(args, PREFERRED_KEYS),
+        collapsedBody: input.output,
+        expandedText: result,
+    };
+};

package/dist/tool-renderers/shell.d.ts

@@ -0,0 +1,3 @@
+import type { ToolRendererMiddleware } from "./types.js";
+export declare const renderShellTool: ToolRendererMiddleware;
+export declare const renderExecTool: ToolRendererMiddleware;

package/dist/tool-renderers/shell.js

@@ -0,0 +1,27 @@
+import { argsAndResultExpandedText, compactCommand, renderWithArgsAndResult, stringArg } from "./utils.js";
+export const renderShellTool = (input) => {
+    const command = compactCommand(stringArg(input, ["command", "cmd", "script"]));
+    if (!command)
+        return undefined;
+    const result = input.output || (input.status === "running" ? "running…" : "(empty)");
+    if (isGitDiffCommand(command)) {
+        return {
+            headerArgs: command,
+            bodyStyle: "diff",
+            preserveAnsi: true,
+            collapsedBody: input.output,
+            expandedText: result,
+        };
+    }
+    const expanded = argsAndResultExpandedText(input, `$ ${command}`);
+    return {
+        headerArgs: command,
+        preserveAnsi: true,
+        collapsedBody: input.output || `$ ${command}`,
+        ...expanded,
+    };
+};
+export const renderExecTool = (input) => renderWithArgsAndResult(input);
+function isGitDiffCommand(command) {
+    return /(?:^|[;&|()]\s*)git\b[^;&|()]*\bdiff\b/.test(command);
+}

package/dist/tool-renderers/skill.d.ts

@@ -0,0 +1,2 @@
+import type { ToolRenderInput, ToolRenderResult } from "./types.js";
+export declare function applySkillReadDisplay(input: ToolRenderInput, rendered: ToolRenderResult): ToolRenderResult;

package/dist/tool-renderers/skill.js

@@ -0,0 +1,132 @@
+import { argsRecord, compactCommand, expandedTextFromParts, lineCount, resultText, stringArg } from "./utils.js";
+const SKILL_TOOL_NAME = "skill";
+const SKILL_FILE_RE = /(?:^|[\\/])SKILL\.md$/i;
+const SHELL_SKILL_FILE_RE = /(?:^|[\s'"`=:[\\/])SKILL\.md(?:$|[\s'"`;|&)>),:])/i;
+const SHELL_SKILL_PATH_RE = /(?:^|[\s'"`=:[(])([^\s'"`;|&)>),]+SKILL\.md)(?=$|[\s'"`;|&)>),:])/i;
+const READ_COMMAND_RE = /(?:^|[;&|()\s])(?:cat|bat|batcat|less|more|head|tail|sed|awk|grep|rg|ripgrep|nl|wc|file)\b/i;
+const MUTATING_SKILL_COMMAND_RE = /(?:>\s*|>>\s*|tee\b[^\n;&|]*|sed\b[^\n;&|]*\s-i(?:\b|[A-Za-z]))[^\n;&|]*SKILL\.md/i;
+export function applySkillReadDisplay(input, rendered) {
+    const skill = skillReadInfo(input);
+    if (!skill)
+        return rendered;
+    const pathText = skill.path ?? "";
+    const expanded = expandedTextFromParts({ text: pathText, color: "muted" }, { text: resultText(input, { empty: !pathText }) });
+    const resultStartLine = pathText ? lineCount(pathText) + 1 : 0;
+    return {
+        ...rendered,
+        toolName: SKILL_TOOL_NAME,
+        headerArgs: skill.name,
+        syntaxHighlight: input.output && !input.isError ? skillSyntaxHighlight(input.output, resultStartLine) : undefined,
+        ...expanded,
+    };
+}
+function skillSyntaxHighlight(output, resultStartLine) {
+    const frontmatterLineCount = yamlFrontmatterLineCount(output);
+    if (frontmatterLineCount === 0)
+        return { language: "markdown", startLine: resultStartLine, startColumn: 0 };
+    const yamlHighlight = {
+        language: "yaml",
+        startLine: resultStartLine,
+        endLine: resultStartLine + frontmatterLineCount,
+        startColumn: 0,
+    };
+    const markdownHighlight = {
+        language: "markdown",
+        startLine: resultStartLine + frontmatterLineCount,
+        startColumn: 0,
+    };
+    return [yamlHighlight, markdownHighlight];
+}
+function yamlFrontmatterLineCount(output) {
+    const lines = output.split("\n");
+    if (lines[0]?.trim() !== "---")
+        return 0;
+    for (let index = 1; index < lines.length; index += 1) {
+        if (lines[index]?.trim() === "---")
+            return index + 1;
+    }
+    return 0;
+}
+function skillReadInfo(input) {
+    let path;
+    if (isShellTool(input.toolName)) {
+        path = shellSkillPath(input);
+    }
+    else if (isReadTool(input.toolName)) {
+        path = skillPathArgument(input);
+    }
+    if (!path)
+        return undefined;
+    return {
+        path,
+        name: skillNameFromPath(path, shellWorkingDirectory(input)),
+    };
+}
+function isShellTool(toolName) {
+    const normalized = toolName.split(/[.:/]/).filter(Boolean).at(-1) ?? toolName;
+    return ["bash", "Bash", "shell", "shell_command"].includes(normalized);
+}
+function isReadTool(toolName) {
+    const normalized = toolName.split(/[.:/]/).filter(Boolean).at(-1) ?? toolName;
+    return normalized.toLowerCase() === "read";
+}
+function shellSkillPath(input) {
+    const command = compactCommand(stringArg(input, ["command", "cmd", "script"]));
+    if (!command || !SHELL_SKILL_FILE_RE.test(command) || !READ_COMMAND_RE.test(command))
+        return undefined;
+    if (MUTATING_SKILL_COMMAND_RE.test(command))
+        return undefined;
+    return SHELL_SKILL_PATH_RE.exec(command)?.[1] ?? "SKILL.md";
+}
+function skillPathArgument(input) {
+    const record = argsRecord(input);
+    if (!record)
+        return undefined;
+    for (const [key, value] of Object.entries(record)) {
+        if (!isPathLikeKey(key))
+            continue;
+        const path = findSkillPath(value);
+        if (path)
+            return path;
+    }
+    return undefined;
+}
+function isPathLikeKey(key) {
+    return /(?:path|file|target|url|uri|glob|cwd|workdir|directory|dir)s?$/i.test(key);
+}
+function findSkillPath(value) {
+    if (typeof value === "string") {
+        const path = value.trim();
+        return SKILL_FILE_RE.test(path) ? path : undefined;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const path = findSkillPath(item);
+            if (path)
+                return path;
+        }
+        return undefined;
+    }
+    if (typeof value === "object" && value !== null) {
+        for (const nested of Object.values(value)) {
+            const path = findSkillPath(nested);
+            if (path)
+                return path;
+        }
+    }
+    return undefined;
+}
+function skillNameFromPath(path, cwd) {
+    const normalized = path.replace(/\\/g, "/").replace(/\/+$/, "");
+    const parts = normalized.split("/").filter(Boolean);
+    const fileName = parts.at(-1);
+    const parentName = fileName?.toLowerCase() === "skill.md" ? parts.at(-2) : undefined;
+    if (parentName)
+        return parentName;
+    if (cwd)
+        return cwd.replace(/\\/g, "/").replace(/\/+$/, "").split("/").filter(Boolean).at(-1) ?? "skill";
+    return "skill";
+}
+function shellWorkingDirectory(input) {
+    return stringArg(input, ["cwd", "workdir"]);
+}

package/dist/tool-renderers/subagents.d.ts

@@ -0,0 +1,2 @@
+import type { ToolRendererMiddleware } from "./types.js";
+export declare const renderSubagentsTool: ToolRendererMiddleware;

package/dist/tool-renderers/subagents.js

@@ -0,0 +1,51 @@
+import { argsRecord, renderWithArgsAndResult, stringArg } from "./utils.js";
+export const renderSubagentsTool = (input) => {
+    const action = stringArg(input, ["action"]);
+    const args = argsRecord(input);
+    const taskCount = Array.isArray(args?.tasks) ? args.tasks.length : undefined;
+    const headerArgs = [action, taskCount != null ? `${taskCount} task${taskCount === 1 ? "" : "s"}` : undefined].filter(Boolean).join(" · ");
+    const collapsedBody = taskCount != null
+        ? `${input.status === "running" ? "starting" : "started"} ${taskCount} subagent${taskCount === 1 ? "" : "s"}`
+        : oneLineSummary(action, input);
+    return renderWithArgsAndResult(input, { headerArgs, collapsedBody });
+};
+function oneLineSummary(action, input) {
+    if (!input.output)
+        return input.status === "running" ? "running…" : "done";
+    if (input.isError)
+        return firstLine(input.output);
+    switch (action) {
+        case "status": return compactStatus(input.output);
+        case "result": return compactResult(input.output);
+        case "wait": return compactStatus(input.output);
+        case "stop": return firstLine(input.output);
+        case "cleanup": return firstLine(input.output);
+        default: return firstLine(input.output);
+    }
+}
+function compactStatus(output) {
+    // Extract agent status lines into a compact one-liner
+    const lines = output.split("\n").map((l) => l.trim()).filter(Boolean);
+    if (lines.length === 0)
+        return "done";
+    const running = lines.filter((l) => /running/i.test(l)).length;
+    const completed = lines.filter((l) => /completed|done/i.test(l)).length;
+    const failed = lines.filter((l) => /failed|error/i.test(l)).length;
+    const parts = [];
+    if (running > 0)
+        parts.push(`${running} running`);
+    if (completed > 0)
+        parts.push(`${completed} completed`);
+    if (failed > 0)
+        parts.push(`${failed} failed`);
+    return parts.length > 0 ? parts.join(", ") : `${lines.length} agent${lines.length === 1 ? "" : "s"}`;
+}
+function compactResult(output) {
+    // Summarize: show first meaningful line
+    const first = firstLine(output);
+    // Truncate very long lines
+    return first.length > 200 ? first.slice(0, 197) + "…" : first;
+}
+function firstLine(text) {
+    return text.split("\n").map((l) => l.trim()).find(Boolean) ?? "";
+}

package/dist/tool-renderers/todo.d.ts

@@ -0,0 +1,2 @@
+import type { ToolRendererMiddleware } from "./types.js";
+export declare const renderTodoTool: ToolRendererMiddleware;

package/dist/tool-renderers/todo.js

@@ -0,0 +1,9 @@
+import { renderWithArgsAndResult, stringArg } from "./utils.js";
+export const renderTodoTool = (input) => {
+    const action = stringArg(input, ["action"]);
+    const subject = stringArg(input, ["subject"]);
+    return renderWithArgsAndResult(input, {
+        headerArgs: [action, subject].filter(Boolean).join(" · "),
+        collapsedBody: input.output,
+    });
+};

package/dist/tool-renderers/types.d.ts

@@ -0,0 +1,42 @@
+import type { Theme } from "../theme.js";
+import type { ToolBodySyntaxHighlights } from "../syntax-highlight.js";
+export type ToolHeaderSegment = {
+    start: number;
+    end: number;
+    foreground?: string;
+    background?: string;
+    bold?: boolean;
+    strikethrough?: boolean;
+};
+export type ToolBodyLineStyle = {
+    startLine: number;
+    endLine?: number;
+    foreground?: string;
+    color?: keyof Theme["colors"];
+    bold?: boolean;
+    underline?: boolean;
+    strikethrough?: boolean;
+};
+export type ToolRenderInput = {
+    toolName: string;
+    argsText: string;
+    output: string;
+    details?: unknown;
+    isError: boolean;
+    status: "running" | "done";
+    cwd?: string;
+    colors?: Theme["colors"];
+    toolColor?: string;
+};
+export type ToolRenderResult = {
+    toolName?: string;
+    headerArgs?: string;
+    headerArgsSegments?: readonly ToolHeaderSegment[];
+    bodyLineStyles?: readonly ToolBodyLineStyle[];
+    bodyStyle?: "diff";
+    preserveAnsi?: boolean;
+    syntaxHighlight?: ToolBodySyntaxHighlights | undefined;
+    collapsedBody: string;
+    expandedText: string;
+};
+export type ToolRendererMiddleware = (input: ToolRenderInput) => ToolRenderResult | undefined;

package/dist/tool-renderers/types.js

@@ -0,0 +1 @@
+export {};

package/dist/tool-renderers/utils.d.ts

@@ -0,0 +1,31 @@
+import type { ToolBodyLineStyle, ToolRenderInput, ToolRenderResult } from "./types.js";
+type PlainRecord = Record<string, unknown>;
+export declare function normalizeToolName(toolName: string): string;
+export declare function parseArgsText(argsText: string): unknown;
+export declare function argsRecord(input: ToolRenderInput): PlainRecord | undefined;
+export declare function stringArg(input: ToolRenderInput, keys: readonly string[]): string | undefined;
+export declare function numberArg(input: ToolRenderInput, keys: readonly string[]): number | undefined;
+export declare function defaultToolRender(input: ToolRenderInput): ToolRenderResult;
+export declare function renderWithArgsAndResult(input: ToolRenderInput, options?: {
+    headerArgs?: string | undefined;
+    argumentsBody?: string | undefined;
+    collapsedBody?: string | undefined;
+}): ToolRenderResult;
+export declare function resultSection(input: ToolRenderInput): string;
+export declare function argsAndResultExpandedText(input: ToolRenderInput, argsBlock: string): Pick<ToolRenderResult, "expandedText" | "bodyLineStyles">;
+export declare function resultText(input: ToolRenderInput, options?: {
+    empty?: boolean;
+}): string;
+export declare function expandedTextFromParts(...parts: readonly ExpandedTextPart[]): Pick<ToolRenderResult, "expandedText" | "bodyLineStyles">;
+export declare function labeledBlock(title: string, body: string | undefined): string;
+export declare function joinSections(...parts: readonly string[]): string;
+export declare function indent(text: string, spaces?: number): string;
+export declare function lineCount(text: string): number;
+type ExpandedTextPart = {
+    text?: string | undefined;
+} & Omit<ToolBodyLineStyle, "startLine" | "endLine">;
+export declare function formatArgsInline(args: unknown, preferredKeys?: readonly string[]): string;
+export declare function formatArgsBlock(args: unknown, preferredKeys?: readonly string[]): string;
+export declare function summarizePatch(text: string | undefined): string | undefined;
+export declare function compactCommand(command: string | undefined): string | undefined;
+export {};