@jancellor/ask 1.0.0

package/dist/batch/index.js

@@ -0,0 +1,101 @@
+import { Agent, } from '../agent/index.js';
+import { ShutdownManager } from '../shutdown-manager.js';
+export async function runBatch(argument, options) {
+    const stdin = !process.stdin.isTTY ? await readStdin() : undefined;
+    const message = [stdin, argument].filter(Boolean).join('\n\n');
+    if (!message)
+        throw new Error('no message provided (pass [message] or pipe stdin)');
+    const agent = await Agent.create(options);
+    // console.error(`[Session: ${agent.sessionId}]`);
+    const shutdownManager = new ShutdownManager(async () => {
+        await agent.cancelAll();
+    });
+    shutdownManager.installSignalHandlers();
+    // Log tool calls to stderr as they happen
+    agent.addListener({
+        onMessages(newMessages) {
+            for (const msg of newMessages) {
+                if (msg.role !== 'assistant' || !Array.isArray(msg.content))
+                    continue;
+                for (const part of msg.content) {
+                    if (part?.type === 'tool-call') {
+                        const line = formatToolCall(part.toolName, part.input);
+                        console.error(truncate(line, 80));
+                    }
+                }
+            }
+        },
+    });
+    await agent.ask(message);
+    // Extract and output the final assistant response
+    const response = extractFinalResponse(agent.messages);
+    console.log(response);
+}
+async function readStdin() {
+    let data = '';
+    for await (const chunk of process.stdin) {
+        data += String(chunk);
+    }
+    return data;
+}
+function formatToolCall(toolName, input) {
+    if (toolName === 'execute') {
+        const command = extractCommand(input);
+        if (command) {
+            return `$ ${command}`;
+        }
+    }
+    // Generic format for other tools
+    const inputStr = formatToolInput(input);
+    return inputStr ? `${toolName} ${inputStr}` : toolName;
+}
+function extractCommand(input) {
+    if (typeof input === 'string')
+        return input;
+    if (input && typeof input === 'object') {
+        const obj = input;
+        if (typeof obj.command === 'string')
+            return obj.command;
+    }
+    return null;
+}
+function formatToolInput(input) {
+    if (input === undefined || input === null)
+        return '';
+    if (typeof input === 'string')
+        return input;
+    return JSON.stringify(input);
+}
+function truncate(str, maxLen) {
+    const hasMultipleLines = str.includes('\n');
+    const firstLine = str.split('\n')[0] ?? '';
+    // Needs truncation (either multiple lines or too long)
+    const needsTruncation = hasMultipleLines || firstLine.length > maxLen;
+    if (!needsTruncation) {
+        return firstLine;
+    }
+    // Always reserve 3 chars for "...", so max content is maxLen - 3
+    const contentMax = maxLen - 3;
+    const truncated = firstLine.slice(0, contentMax);
+    return truncated + '...';
+}
+function extractFinalResponse(messages) {
+    // Find the last non-hidden assistant message
+    const assistantMessages = messages.filter((m) => !m._meta?.uiHidden && m.role === 'assistant');
+    const lastMessage = assistantMessages.at(-1);
+    if (!lastMessage)
+        return '';
+    const { content } = lastMessage;
+    // Handle string content
+    if (typeof content === 'string') {
+        return content;
+    }
+    // Handle array content - extract text parts
+    if (Array.isArray(content)) {
+        return content
+            .filter((p) => p?.type === 'text')
+            .map((p) => p.text)
+            .join('');
+    }
+    return '';
+}

package/dist/index.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { runTui } from './tui/index.js';
+import { runBatch } from './batch/index.js';
+async function main() {
+    const program = new Command()
+        .name('ask')
+        .allowExcessArguments(false)
+        .option('-r, --resume [id]', 'read from given (or last) session')
+        .option('-f, --fork [id]', 'write to given (or random) session')
+        .option('-i, --interactive', 'force interactive mode')
+        .option('-b, --batch', 'force batch mode')
+        .addHelpText('after', '\nUse -- before message if ambiguous (eg ask -r -- "follow up question")')
+        .argument('[message]');
+    program.parse(process.argv);
+    const opts = program.opts();
+    const message = program.args[0];
+    const mode = opts.interactive && opts.batch
+        ? 'auto'
+        : opts.interactive
+            ? 'interactive'
+            : opts.batch
+                ? 'batch'
+                : 'auto';
+    const useInteractive = mode == 'interactive' ||
+        (mode == 'auto' && process.stdin.isTTY && message === undefined);
+    useInteractive ? await runTui(opts) : await runBatch(message, opts);
+}
+main().catch((error) => {
+    console.error(String(error));
+    process.exit(1);
+});

package/dist/shutdown-manager.js

@@ -0,0 +1,35 @@
+export class ShutdownManager {
+    cleanup;
+    shutdownPromise = null;
+    constructor(cleanup) {
+        this.cleanup = cleanup;
+    }
+    requestShutdown() {
+        void this.shutdown(() => {
+            process.exit(0);
+        });
+    }
+    installSignalHandlers() {
+        for (const signal of ['SIGHUP', 'SIGINT', 'SIGTERM']) {
+            process.once(signal, () => {
+                void this.shutdown(() => {
+                    // resignal to get proper exit/signal values
+                    process.kill(process.pid, signal);
+                });
+            });
+        }
+    }
+    shutdown(finalize) {
+        if (!this.shutdownPromise) {
+            this.shutdownPromise = (async () => {
+                try {
+                    await this.cleanup();
+                }
+                finally {
+                    finalize();
+                }
+            })();
+        }
+        return this.shutdownPromise;
+    }
+}

package/dist/tui/app.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box } from 'ink';
+import { Input } from './input.js';
+import { Messages } from './messages.js';
+import { useAgent } from './use-agent.js';
+export function App({ agent, onRequestShutdown }) {
+    const { messages, modelId, provider, sendMessage, abort, clear } = useAgent(agent);
+    const handleSubmit = (message) => {
+        void sendMessage(message);
+    };
+    return (_jsxs(Box, { flexDirection: "column", height: "100%", children: [_jsx(Messages, { messages: messages, model: modelId, provider: provider }), _jsx(Input, { onSubmit: handleSubmit, onAbort: abort, onClear: clear, onRequestShutdown: onRequestShutdown })] }));
+}

package/dist/tui/assistant-part-message.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { ABORTED_MESSAGE, ERROR_MESSAGE } from '../agent/index.js';
+import { parseMarkdown } from './markdown.js';
+export function AssistantPartMessage({ text, dim }) {
+    const error = [ABORTED_MESSAGE, ERROR_MESSAGE].some((e) => text.startsWith(e));
+    const parsed = error || dim ? text : parseMarkdown(text);
+    const color = error ? 'red' : dim ? 'gray' : undefined;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: color, dimColor: error, children: parsed }), _jsx(Text, { children: " " })] }));
+}

package/dist/tui/execute-tool-part-message.js

@@ -0,0 +1,48 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { SpinnerMessage } from './spinner-message.js';
+export function ExecuteToolPartMessage({ input, output }) {
+    const displayInput = input == null ? null : formatExecuteToolInput(input);
+    const parsed = output == null ? null : parseExecuteToolOutput(output);
+    return (_jsxs(Box, { flexDirection: "column", children: [displayInput ? (_jsxs(_Fragment, { children: [_jsx(Text, { children: displayInput }), _jsx(Text, { children: " " })] })) : null, parsed?.stdout ? (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: parsed.stdout }), _jsx(Text, { children: " " })] })) : null, parsed?.stderr ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: "red", dimColor: true, children: parsed.stderr }), _jsx(Text, { children: " " })] })) : null, parsed?.error ? (_jsxs(_Fragment, { children: [_jsxs(Text, { color: "red", children: ["error: ", parsed.error] }), _jsx(Text, { children: " " })] })) : null, parsed?.exit ? (_jsxs(_Fragment, { children: [_jsx(Text, { children: parsed.exit }), _jsx(Text, { children: " " })] })) : null, parsed?.signal ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: "red", dimColor: true, children: parsed.signal }), _jsx(Text, { children: " " })] })) : null, output == null ? _jsx(SpinnerMessage, {}) : null] }));
+}
+function parseExecuteToolOutput(output) {
+    if (!output || typeof output !== 'object')
+        return null;
+    const outer = output;
+    if (outer.type !== 'json' || !('value' in outer))
+        return null;
+    const value = outer.value;
+    if (!value || typeof value !== 'object')
+        return null;
+    const inner = value;
+    const stdout = typeof inner.stdout === 'string' && inner.stdout.trim().length > 0
+        ? inner.stdout.trimEnd()
+        : '';
+    const stderr = typeof inner.stderr === 'string' && inner.stderr.trim().length > 0
+        ? inner.stderr.trimEnd()
+        : '';
+    const error = typeof inner.error === 'string' && inner.error.trim().length > 0
+        ? inner.error.trim()
+        : '';
+    const exit = inner.exit ?? inner.exitCode;
+    const signal = inner.signal;
+    return {
+        stdout,
+        stderr,
+        error,
+        exit: exit !== undefined ? `exit ${exit}` : '',
+        signal: signal ? String(signal) : '',
+    };
+}
+function formatExecuteToolInput(input) {
+    if (typeof input === 'string')
+        return input;
+    if (input && typeof input === 'object') {
+        const obj = input;
+        if (typeof obj.command === 'string')
+            return `$ ${obj.command}`;
+        return JSON.stringify(input, null, 2);
+    }
+    return String(input);
+}

package/dist/tui/generic-tool-part-message.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { SpinnerMessage } from './spinner-message.js';
+export function GenericToolPartMessage({ toolName, input, output }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [toolName ? (_jsxs(_Fragment, { children: [_jsx(Text, { children: toolName }), _jsx(Text, { children: " " })] })) : null, input != null ? (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: formatGenericToolInput(input) }), _jsx(Text, { children: " " })] })) : null, output != null ? (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: formatGenericToolOutput(output) }), _jsx(Text, { children: " " })] })) : (_jsx(SpinnerMessage, {}))] }));
+}
+function formatGenericToolInput(input) {
+    if (typeof input === 'string')
+        return input;
+    if (input && typeof input === 'object')
+        return JSON.stringify(input, null, 2);
+    return String(input);
+}
+function formatGenericToolOutput(output) {
+    if (!output || typeof output !== 'object')
+        return String(output ?? '');
+    const o = output;
+    if ('type' in o && 'value' in o) {
+        const value = o.value;
+        if (typeof value === 'string')
+            return value;
+        if (value && typeof value === 'object') {
+            return JSON.stringify(value, null, 2);
+        }
+        return String(value);
+    }
+    return JSON.stringify(output, null, 2);
+}

package/dist/tui/index.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink';
+import { Agent } from '../agent/index.js';
+import { ShutdownManager } from '../shutdown-manager.js';
+import { App } from './app.js';
+export async function runTui(options) {
+    const agent = await Agent.create(options);
+    const shutdownManager = new ShutdownManager(async () => {
+        try {
+            app.unmount();
+        }
+        finally {
+            await agent.cancelAll();
+        }
+    });
+    shutdownManager.installSignalHandlers();
+    const app = render(_jsx(App, { agent: agent, onRequestShutdown: () => shutdownManager.requestShutdown() }), { exitOnCtrlC: false });
+}

package/dist/tui/input.js

@@ -0,0 +1,115 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { useInputState } from './use-input-state.js';
+const CLEAR_COMMAND = '/clear';
+const CURSOR_BLINK_MS = 600;
+export function Input({ onSubmit, onAbort, onClear, onRequestShutdown }) {
+    const { value, beforeCursor, atCursor, afterCursor, moveStart, moveEnd, moveLeft, moveRight, moveWordLeft, moveWordRight, deleteBackward, deleteToStart, deleteToEnd, deleteWordBackward, insertText, clear, } = useInputState();
+    const [showCursor, setShowCursor] = useState(true);
+    const [keyPulse, setKeyPulse] = useState(0);
+    useEffect(() => {
+        let intervalId;
+        const timeoutId = setTimeout(() => {
+            setShowCursor(false);
+            intervalId = setInterval(() => {
+                setShowCursor((prev) => !prev);
+            }, CURSOR_BLINK_MS);
+        }, CURSOR_BLINK_MS);
+        return () => {
+            clearTimeout(timeoutId);
+            if (intervalId) {
+                clearInterval(intervalId);
+            }
+        };
+    }, [keyPulse]);
+    useInput((input, key) => {
+        setShowCursor(true);
+        setKeyPulse((pulse) => pulse + 1);
+        if (key.escape) {
+            onAbort();
+            return;
+        }
+        if (key.ctrl && input === 'c') {
+            onRequestShutdown();
+            return;
+        }
+        if (key.ctrl && input === 'a') {
+            moveStart();
+            return;
+        }
+        if (key.ctrl && input === 'e') {
+            moveEnd();
+            return;
+        }
+        if (key.ctrl && input === 'u') {
+            deleteToStart();
+            return;
+        }
+        if (key.ctrl && input === 'k') {
+            deleteToEnd();
+            return;
+        }
+        if (key.ctrl && input === 'w') {
+            deleteWordBackward();
+            return;
+        }
+        if (key.home) {
+            moveStart();
+            return;
+        }
+        if (key.end) {
+            moveEnd();
+            return;
+        }
+        if (key.leftArrow) {
+            if (key.ctrl || key.meta) {
+                moveWordLeft();
+            }
+            else {
+                moveLeft();
+            }
+            return;
+        }
+        if (key.rightArrow) {
+            if (key.ctrl || key.meta) {
+                moveWordRight();
+            }
+            else {
+                moveRight();
+            }
+            return;
+        }
+        if (key.backspace || key.delete) {
+            deleteBackward();
+            return;
+        }
+        if (key.return) {
+            if (key.meta) {
+                insertText('\n');
+                return;
+            }
+            const message = value.trim();
+            if (!message) {
+                return;
+            }
+            clear();
+            if (message === CLEAR_COMMAND) {
+                void onClear(() => {
+                    console.log('[New session]\n');
+                });
+            }
+            else {
+                void onSubmit(message);
+            }
+            return;
+        }
+        if (!input) {
+            return;
+        }
+        insertText(input);
+    });
+    const width = Math.max(10, process.stdout.columns ?? 80);
+    const divider = '─'.repeat(width);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "gray", children: divider }), _jsxs(Text, { children: [beforeCursor, showCursor ? _jsx(Text, { inverse: true, children: atCursor }) : atCursor, afterCursor] }), _jsx(Text, { color: "gray", children: divider })] }));
+}

package/dist/tui/markdown.js

@@ -0,0 +1,31 @@
+import chalk from 'chalk';
+import { marked } from 'marked';
+import TerminalRenderer from 'marked-terminal';
+marked.setOptions({
+    renderer: new TerminalRenderer({
+        code: chalk.hex('#D8DEE9'),
+        codespan: chalk.hex('#B7A7FF'),
+        blockquote: chalk.hex('#7D85A8').italic,
+        heading: chalk.hex('#69A9FF').bold,
+        firstHeading: chalk.hex('#8DC2FF').bold,
+        strong: chalk.hex('#F0F3FF').bold,
+        em: chalk.hex('#8E96B8').italic,
+        del: chalk.hex('#6A7192').strikethrough,
+        link: chalk.hex('#7AA8FF'),
+        href: chalk.hex('#7AA8FF').underline,
+        html: chalk.hex('#7B84A7'),
+        hr: chalk.hex('#4A5070'),
+        listitem: chalk.hex('#C5CCE1'),
+        table: chalk.hex('#C5CCE1'),
+        paragraph: chalk.reset,
+        emoji: true,
+        showSectionPrefix: true,
+        reflowText: false,
+        width: 80,
+        tab: 2,
+    }),
+});
+export function parseMarkdown(text) {
+    const rendered = marked.parse(text);
+    return rendered.replace(/(?:\r?\n){1,2}$/, '');
+}

package/dist/tui/messages.js

@@ -0,0 +1,86 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Static } from 'ink';
+import { AssistantPartMessage } from './assistant-part-message.js';
+import { SpinnerMessage } from './spinner-message.js';
+import { ToolPartMessage } from './tool-part-message.js';
+import { UserPartMessage } from './user-part-message.js';
+import { Welcome } from './welcome.js';
+export function Messages({ messages: rawMessages, model, provider }) {
+    const messages = rawMessages.filter((m) => !m._meta?.uiHidden);
+    const toolResults = buildToolResultsMap(messages);
+    const parts = messages.flatMap((message, i) => getContentParts(message.content).map((part, j) => ({
+        ...part,
+        role: message.role,
+        i,
+        j,
+        id: `${message.role}-${i}-${j}`,
+    })));
+    const splitIdx = parts.findIndex((p) => p.type === 'tool-call' && !toolResults.has(p.toolCallId));
+    const staticParts = splitIdx === -1 ? parts : parts.slice(0, splitIdx);
+    const activeParts = splitIdx === -1 ? [] : parts.slice(splitIdx);
+    const allStaticItems = [
+        { id: 'welcome', type: 'welcome' },
+        ...staticParts,
+    ];
+    const renderPart = (p) => {
+        if (p.role === 'assistant' && p.type === 'text') {
+            return _jsx(AssistantPartMessage, { text: p.text, dim: false }, p.id);
+        }
+        if (p.role === 'user') {
+            if (p.type === 'text') {
+                return _jsx(UserPartMessage, { text: p.text }, p.id);
+            }
+        }
+        if (p.type === 'tool-call') {
+            return (_jsx(ToolPartMessage, { toolName: p.toolName ?? toolResults.get(p.toolCallId)?.toolName, input: p.input, output: toolResults.get(p.toolCallId)?.output }, p.id));
+        }
+        return null;
+    };
+    const showSpinner = messages.length > 0 && messages.at(-1).role !== 'assistant';
+    return (_jsxs(Box, { flexGrow: 1, flexDirection: "column", children: [_jsx(Static, { items: allStaticItems, children: (item) => {
+                    if (item.type === 'welcome')
+                        return _jsx(Welcome, { model: model, provider: provider }, "welcome");
+                    return renderPart(item);
+                } }), activeParts.map(renderPart), showSpinner && _jsx(SpinnerMessage, {})] }));
+}
+function getContentParts(content) {
+    if (typeof content === 'string')
+        return [{ type: 'text', text: content }];
+    if (!Array.isArray(content))
+        return [];
+    const parts = [];
+    for (const p of content) {
+        if (!p || typeof p !== 'object')
+            continue;
+        if (p.type === 'text' && typeof p.text === 'string') {
+            parts.push({ type: 'text', text: p.text });
+        }
+        else if (p.type === 'tool-call' && typeof p.toolCallId === 'string') {
+            parts.push({
+                type: 'tool-call',
+                toolCallId: p.toolCallId,
+                toolName: typeof p.toolName === 'string' ? p.toolName : null,
+                input: p.input,
+            });
+        }
+    }
+    return parts;
+}
+function buildToolResultsMap(messages) {
+    const map = new Map();
+    for (const message of messages) {
+        if (message.role !== 'tool' || !Array.isArray(message.content))
+            continue;
+        for (const part of message.content) {
+            if (!part || typeof part !== 'object')
+                continue;
+            if (part.type === 'tool-result' && 'output' in part) {
+                map.set(part.toolCallId, {
+                    toolName: typeof part.toolName === 'string' ? part.toolName : null,
+                    output: part.output,
+                });
+            }
+        }
+    }
+    return map;
+}

package/dist/tui/spinner-message.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text } from 'ink';
+const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+export function SpinnerMessage() {
+    const [frameIndex, setFrameIndex] = React.useState(0);
+    React.useEffect(() => {
+        const timer = setInterval(() => {
+            setFrameIndex((idx) => (idx + 1) % frames.length);
+        }, 80);
+        return () => clearInterval(timer);
+    }, []);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "white", children: frames[frameIndex] }), _jsx(Text, { children: " " })] }));
+}

package/dist/tui/tool-part-message.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ExecuteToolPartMessage } from './execute-tool-part-message.js';
+import { GenericToolPartMessage } from './generic-tool-part-message.js';
+export function ToolPartMessage({ toolName, input, output }) {
+    if (toolName === 'execute') {
+        return _jsx(ExecuteToolPartMessage, { toolName: toolName, input: input, output: output });
+    }
+    return _jsx(GenericToolPartMessage, { toolName: toolName, input: input, output: output });
+}

package/dist/tui/use-agent.js

@@ -0,0 +1,27 @@
+import { useCallback, useEffect, useState } from 'react';
+export function useAgent(agent) {
+    const [messages, setMessages] = useState([]);
+    useEffect(() => {
+        setMessages([...agent.messages]);
+        const listener = {
+            onMessages: () => setMessages([...agent.messages]),
+            onClear: () => setMessages([]),
+        };
+        agent.addListener(listener);
+        return () => {
+            agent.removeListener(listener);
+        };
+    }, [agent]);
+    const sendMessage = useCallback((message) => agent.ask(message), [agent]);
+    const abort = useCallback(() => agent.abort(), [agent]);
+    const clear = useCallback((beforeClear) => agent.clear(beforeClear), [agent]);
+    const provider = new URL(agent.baseUrl).hostname.split('.').at(-2) ?? agent.baseUrl;
+    return {
+        messages,
+        modelId: agent.modelId,
+        provider,
+        sendMessage,
+        abort,
+        clear,
+    };
+}