shortcutxl 0.2.0

package/dist/custom/tools/task/task.js

@@ -0,0 +1,205 @@
+/**
+ * Task tool — spawn a subagent to handle complex tasks autonomously.
+ *
+ * The LLM calls `task(subagent_type, name, query)` to delegate work
+ * to a child process running THIS binary. The child inherits all custom
+ * tools (excel_exec), providers, and auth.
+ *
+ * Multiple task() calls execute in parallel (our forked agent loop does
+ * Promise.all on tool calls).
+ */
+import { StringEnum } from '@mariozechner/pi-ai';
+import { Type } from '@sinclair/typebox';
+import { ABORT_AGENT_MESSAGE, ABORT_UI_LABEL_INLINE } from '../../../core/abort.js';
+import { resolveOwnBinary } from '../../../config.js';
+import { TASK } from '../../../tool-names.js';
+import { buildTaskToolDescription, getSubagent, getSubagentNames } from '../../agents/index.js';
+import { buildAgentArgs } from './subprocess.js';
+import { renderTaskCall, renderTaskGroup, renderTaskResult } from './render.js';
+import { truncateOutput } from '../../../core/tools/truncate.js';
+import { cleanupTempFile, spawnSubagent } from './subprocess.js';
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const TOOL_NAME = TASK;
+const TOOL_LABEL = 'Task';
+const TOOL_DESCRIPTION = buildTaskToolDescription();
+const SUBAGENT_MODELS = ['shortcut/claude-opus-4-6', 'shortcut/gpt-5.4-2026-03-05'];
+function buildSchema() {
+    const names = getSubagentNames();
+    return Type.Object({
+        subagent_type: StringEnum(names, {
+            description: 'The type of specialized agent to use for this task'
+        }),
+        name: Type.String({
+            description: "Descriptive name for the task (max 3 words). Use the target being analyzed, e.g. 'Revenue Sheet', 'Income Statement', 'Format Summary'. NEVER use generic names like 'Task 1' or 'Analysis'. Shown in the UI."
+        }),
+        query: Type.String({
+            description: 'The task for the subagent. Be specific: include file paths, sheet names, cell ranges, and concrete instructions. The subagent has its own context window and cannot see your conversation history. ' +
+                'Can also be a file path ending in .txt (e.g., "/tmp/query.txt") — the file contents will be used as the query. Useful for batch/parallel calls to programmatically write .txt query files with variables.'
+        }),
+        model: Type.Optional(StringEnum(SUBAGENT_MODELS, {
+            description: 'shortcut/claude-opus-4-6 (default): best all-around choice. shortcut/gpt-5.4-2026-03-05: stronger reasoning but weaker formatting — best for auditing, reviewing, and verification tasks, especially when run concurrently with Opus tasks for diverse perspectives.'
+        }))
+    });
+}
+export function createTaskTool(options = {}) {
+    const { cwd: cwdOverride, extraArgs = [] } = options;
+    const schema = buildSchema();
+    return {
+        name: TOOL_NAME,
+        label: TOOL_LABEL,
+        description: TOOL_DESCRIPTION,
+        parameters: schema,
+        async execute(_toolCallId, params, signal, onUpdate, ctx) {
+            const { subagent_type, query, model: modelOverride } = params;
+            // Look up agent config
+            const agentConfig = getSubagent(subagent_type);
+            if (!agentConfig) {
+                const available = getSubagentNames().join(', ');
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Unknown subagent_type '${subagent_type}'. Available: ${available}`
+                        }
+                    ],
+                    details: undefined,
+                    isError: true
+                };
+            }
+            const taskCwd = cwdOverride ?? process.cwd();
+            const command = resolveOwnBinary();
+            // Apply model override if provided
+            const effectiveConfig = modelOverride
+                ? { ...agentConfig, model: modelOverride }
+                : agentConfig;
+            const effectiveModel = effectiveConfig.model ?? 'shortcut/claude-opus-4-6';
+            // Resolve model info for context window display and API key
+            const [modelProvider, ...modelIdParts] = effectiveModel.split('/');
+            const modelId = modelIdParts.join('/');
+            const modelInfo = ctx.modelRegistry.find(modelProvider, modelId);
+            const contextWindow = modelInfo?.contextWindow ?? 0;
+            // Build args from agent config (typed config → CLI args + temp file)
+            const { args: agentArgs, promptFile } = buildAgentArgs(effectiveConfig);
+            // Subagent reads auth.json directly (kept fresh by parent's proactive
+            // refresh timer). No --api-key needed — avoids stale tokens on long runs.
+            const timeoutMs = (agentConfig.timeoutSeconds ?? 900) * 1000;
+            const abortController = new AbortController();
+            // Compose signals: external abort + timeout
+            const timeoutId = setTimeout(() => abortController.abort(), timeoutMs);
+            if (signal) {
+                signal.addEventListener('abort', () => abortController.abort(), { once: true });
+            }
+            let result;
+            try {
+                result = await spawnSubagent({
+                    task: query,
+                    cwd: taskCwd,
+                    command,
+                    agentArgs: [...extraArgs, ...agentArgs],
+                    signal: abortController.signal,
+                    onProgress: (progress) => {
+                        const details = {
+                            text: progress.text,
+                            toolCalls: progress.toolCalls,
+                            usage: progress.usage,
+                            model: progress.model,
+                            contextWindow,
+                            isRunning: true,
+                            isError: false
+                        };
+                        onUpdate?.({
+                            content: [{ type: 'text', text: progress.text || '(running...)' }],
+                            details
+                        });
+                    }
+                });
+            }
+            finally {
+                clearTimeout(timeoutId);
+                if (promptFile)
+                    cleanupTempFile(promptFile);
+            }
+            // User cancel (or timeout) — surface a clean cancelled message, not a generic error
+            if (result.aborted) {
+                const details = {
+                    text: ABORT_UI_LABEL_INLINE,
+                    toolCalls: result.toolCalls,
+                    usage: result.usage,
+                    model: result.model,
+                    contextWindow,
+                    isRunning: false,
+                    isError: false,
+                    isAborted: true,
+                    sessionId: result.sessionId,
+                    sessionFile: result.sessionFile
+                };
+                return {
+                    content: [{ type: 'text', text: ABORT_AGENT_MESSAGE }],
+                    details
+                };
+            }
+            const isError = result.exitCode !== 0 || result.stopReason === 'error' || result.stopReason === 'aborted';
+            const details = {
+                text: result.text,
+                toolCalls: result.toolCalls,
+                usage: result.usage,
+                model: result.model,
+                contextWindow,
+                isRunning: false,
+                isError,
+                errorMessage: result.errorMessage,
+                sessionId: result.sessionId,
+                sessionFile: result.sessionFile
+            };
+            if (isError) {
+                const errorText = result.errorMessage || result.stderr || result.text || '(subagent failed with no output)';
+                return {
+                    content: [{ type: 'text', text: `Error: ${truncateOutput(errorText)}` }],
+                    details,
+                    isError: true
+                };
+            }
+            return {
+                content: [{ type: 'text', text: truncateOutput(result.text || '(no output)') }],
+                details
+            };
+        },
+        renderCall(args, options, theme) {
+            const a = args;
+            const name = a.name ?? 'task';
+            const agentType = a.subagent_type;
+            const query = a.query;
+            const label = agentType ? `${name} [${agentType}]` : name;
+            return renderTaskCall({ name: label, query }, options.expanded, theme);
+        },
+        renderResult(result, options, theme) {
+            const details = result.details;
+            if (!details) {
+                const textBlock = result.content?.[0];
+                const fallback = textBlock?.type === 'text' ? textBlock.text : '(no output)';
+                return renderTaskResult({
+                    text: fallback,
+                    toolCalls: [],
+                    usage: {
+                        input: 0,
+                        output: 0,
+                        cacheRead: 0,
+                        cacheWrite: 0,
+                        cost: 0,
+                        turns: 0,
+                        lastTurnInput: 0
+                    },
+                    isRunning: false,
+                    isError: false
+                }, options.expanded, theme);
+            }
+            return renderTaskResult(details, options.expanded, theme);
+        },
+        renderGroup(members, options, theme) {
+            return renderTaskGroup(members, options, theme);
+        }
+    };
+}
+//# sourceMappingURL=task.js.map

package/dist/custom/tools/todo-list.js

@@ -0,0 +1,195 @@
+/**
+ * Todo list tool — in-memory task tracker for complex multi-step workflows.
+ *
+ * Renders as a persistent widget above the editor (aboveEditor placement)
+ * that survives interrupts and stays visible throughout the session.
+ * State is persisted in tool result details (written to session JSONL on each call).
+ */
+import { Type } from '@sinclair/typebox';
+import { theme } from '../../core/theme.js';
+import { TODO_LIST } from '../../tool-names.js';
+// ---------------------------------------------------------------------------
+// Schema
+// ---------------------------------------------------------------------------
+const TodoItemSchema = Type.Object({
+    id: Type.String({ description: 'A short id to reference the task, like update-1' }),
+    content: Type.Optional(Type.String({
+        description: 'Clear description of the task (1-2 sentences). Include the cells/ranges you will read from and write to. When merge=true, omit to keep existing value.'
+    })),
+    status: Type.Optional(Type.Union([Type.Literal('todo'), Type.Literal('in_progress'), Type.Literal('done')], {
+        description: "Task status: 'todo', 'in_progress', or 'done'. When merge=true, omit to keep existing value."
+    }))
+});
+const schema = Type.Object({
+    merge: Type.Boolean({
+        description: 'If false, completely replace existing items. If true, merge by id — only id is required per item, content/status keep existing values when omitted.'
+    }),
+    items: Type.Array(TodoItemSchema, {
+        description: 'The list of tasks to create or update.'
+    })
+});
+// ---------------------------------------------------------------------------
+// Tool description (what the LLM sees)
+// ---------------------------------------------------------------------------
+const TOOL_DESCRIPTION = `\
+Update your task list. Use merge=false to replace all tasks, or merge=true to patch specific tasks by id.
+When handling complex Excel workflows, use this tool to ensure all operations complete successfully and in the correct order.
+
+Use ONLY when creating NEW complex models/spreadsheets from scratch. NOT for editing or iterative updates.
+For model creation: understand data, styles, and formats before planning. Include references, ranges, and formatting details in tasks.
+
+Each task has:
+- id: a short id to reference the task, like update-1
+- content: what needs to be done
+- status: 'todo', 'in_progress', or 'done'
+
+IMPORTANT: Call this frequently to update and ensure only one task is in progress at a time.`;
+// ---------------------------------------------------------------------------
+// State (singleton — one session per process)
+// ---------------------------------------------------------------------------
+let items = [];
+let widgetFn = null;
+const WIDGET_KEY = 'todo';
+const DISMISS_DELAY_MS = 3_000;
+const ANSI_BLINK = '\x1b[5m';
+const ANSI_RESET = '\x1b[0m';
+const VALID_STATUSES = new Set(['todo', 'in_progress', 'done']);
+let dismissTimer = null;
+/** Validate and coerce a raw status string, falling back to `fallback`. */
+function coerceStatus(raw, fallback) {
+    if (raw !== undefined && VALID_STATUSES.has(raw))
+        return raw;
+    return fallback;
+}
+/** Build a TodoItem from raw input, optionally merging with an existing item. */
+function buildItem(raw, existing) {
+    return {
+        id: raw.id,
+        content: raw.content ?? existing?.content ?? 'Task not specified',
+        status: coerceStatus(raw.status, existing?.status ?? 'todo')
+    };
+}
+/**
+ * Called from main.ts onReady to wire up the persistent widget.
+ */
+export function setTodoWidget(setWidget) {
+    widgetFn = setWidget;
+    if (items.length > 0) {
+        updateWidget();
+    }
+}
+// ---------------------------------------------------------------------------
+// Core logic
+// ---------------------------------------------------------------------------
+function applyUpdate(merge, incoming) {
+    // Deduplicate — last entry per id wins (handles LLM sending duplicate ids)
+    const deduped = [...new Map(incoming.map((it) => [it.id, it])).values()];
+    if (!merge) {
+        const newItems = deduped.map((raw) => buildItem(raw));
+        items = newItems;
+        return { updatedItems: newItems, allItems: newItems };
+    }
+    // Merge mode — patch existing items, append new ones
+    const currentById = new Map(items.map((it, idx) => [it.id, idx]));
+    const result = [...items];
+    for (const raw of deduped) {
+        const idx = currentById.get(raw.id);
+        if (idx !== undefined) {
+            result[idx] = buildItem(raw, result[idx]);
+        }
+        else {
+            result.push(buildItem(raw));
+        }
+    }
+    items = result;
+    const touchedIds = new Set(deduped.map((it) => it.id));
+    const updatedItems = result.filter((it) => touchedIds.has(it.id));
+    return { updatedItems, allItems: result };
+}
+// ---------------------------------------------------------------------------
+// Widget rendering
+// ---------------------------------------------------------------------------
+function renderItem(t, isLast) {
+    const glyph = isLast ? '└─' : '├─';
+    const glyphStr = theme.fg('dim', glyph);
+    switch (t.status) {
+        case 'done': {
+            const icon = theme.fg('success', '✔');
+            const text = theme.strikethrough(theme.fg('dim', t.content));
+            return `  ${glyphStr} ${icon} ${text}`;
+        }
+        case 'in_progress': {
+            const icon = `${ANSI_BLINK}${theme.fg('warning', '●')}${ANSI_RESET}`;
+            const text = theme.fg('muted', t.content);
+            return `  ${glyphStr} ${icon} ${text}`;
+        }
+        case 'todo': {
+            const icon = theme.fg('dim', '○');
+            const text = theme.fg('muted', t.content);
+            return `  ${glyphStr} ${icon} ${text}`;
+        }
+        default: {
+            const _exhaustive = t.status;
+            return _exhaustive;
+        }
+    }
+}
+function updateWidget() {
+    if (!widgetFn)
+        return;
+    if (items.length === 0) {
+        widgetFn(WIDGET_KEY, undefined);
+        return;
+    }
+    const done = items.filter((t) => t.status === 'done').length;
+    const lines = [];
+    // Header with progress summary
+    const header = theme.fg('accent', `Tasks ${done}/${items.length}`);
+    lines.push(header);
+    // Each item as a tree branch
+    for (let i = 0; i < items.length; i++) {
+        lines.push(renderItem(items[i], i === items.length - 1));
+    }
+    widgetFn(WIDGET_KEY, lines, { placement: 'aboveEditor' });
+    // Auto-dismiss after all tasks are done
+    if (dismissTimer) {
+        clearTimeout(dismissTimer);
+        dismissTimer = null;
+    }
+    if (done === items.length) {
+        dismissTimer = setTimeout(() => {
+            widgetFn?.(WIDGET_KEY, undefined);
+            dismissTimer = null;
+        }, DISMISS_DELAY_MS);
+        dismissTimer.unref?.();
+    }
+}
+// ---------------------------------------------------------------------------
+// Tool factory
+// ---------------------------------------------------------------------------
+export function createTodoListTool() {
+    return {
+        name: TODO_LIST,
+        label: 'Todo list',
+        description: TOOL_DESCRIPTION,
+        parameters: schema,
+        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+            const { updatedItems, allItems } = applyUpdate(params.merge, params.items);
+            // Update the persistent widget
+            updateWidget();
+            const summary = (updatedItems.length > 0 ? updatedItems : allItems).map((t) => `[${t.status === 'done' ? 'x' : t.status === 'in_progress' ? '>' : ' '}] ${t.id}: ${t.content}`);
+            return {
+                content: [{ type: 'text', text: summary.join('\n') || 'No tasks' }],
+                details: { items: allItems }
+            };
+        },
+        renderCall() {
+            // Suppressed — the persistent widget above the editor shows the state
+            return undefined;
+        },
+        renderResult() {
+            return undefined;
+        }
+    };
+}
+//# sourceMappingURL=todo-list.js.map

package/dist/custom/tracing/session-upload.js

@@ -0,0 +1,93 @@
+/**
+ * Session trace uploader.
+ *
+ * Listens for agent_end events and uploads the session JSONL (and any
+ * subagent JONLs) to the Shortcut backend for centralized trace storage.
+ *
+ * Subagent linking: when the parent session contains task tool results
+ * with sessionFile paths, those subagent JONLs are uploaded too. The
+ * parent's JSONL references subagent session IDs via details.sessionId,
+ * forming a tree queryable in ClickHouse.
+ */
+import { existsSync, readFileSync, rmdirSync, unlinkSync } from 'fs';
+import { dirname } from 'path';
+import { SHORTCUT_API_URL } from '../constants.js';
+/**
+ * Upload JSONL content to the trace endpoint.
+ * Pure HTTP — no file I/O, no constants. Exported for testing.
+ */
+export async function uploadTrace(content, baseUrl, accessToken) {
+    const response = await fetch(`${baseUrl}/api/v1/agent-traces`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/x-ndjson',
+            Authorization: `Bearer ${accessToken}`
+        },
+        body: content
+    });
+    const body = await response.text().catch(() => '');
+    return { ok: response.ok, status: response.status, body };
+}
+export function attachSessionUpload(session, options) {
+    if (options.enabled === false) {
+        return () => { };
+    }
+    const listener = (event) => {
+        if (event.type === 'agent_end') {
+            void uploadAll(session, options).catch(() => { });
+        }
+    };
+    return session.subscribe(listener);
+}
+async function uploadAll(session, options) {
+    const accessToken = options.getAccessToken();
+    if (!accessToken)
+        return;
+    const sessionFile = session.sessionManager.getSessionFile();
+    if (!sessionFile)
+        return;
+    // Upload the parent session
+    await uploadFileFromDisk(sessionFile, accessToken);
+    // Find and upload subagent session files from tool result details
+    const entries = session.sessionManager.getEntries();
+    for (const entry of entries) {
+        if (entry.type !== 'message')
+            continue;
+        const msg = entry.message;
+        if (msg?.role !== 'toolResult')
+            continue;
+        const subFile = msg?.details?.sessionFile;
+        if (typeof subFile === 'string' && existsSync(subFile)) {
+            await uploadFileFromDisk(subFile, accessToken);
+            try {
+                unlinkSync(subFile);
+            }
+            catch {
+                /* ignore */
+            }
+            try {
+                rmdirSync(dirname(subFile));
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    }
+}
+async function uploadFileFromDisk(filePath, accessToken) {
+    let content;
+    try {
+        content = readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        return;
+    }
+    if (!content.trim())
+        return;
+    const result = await uploadTrace(content, SHORTCUT_API_URL, accessToken);
+    if (!result.ok) {
+        // Silenced: staging/local API may not have trace endpoint
+        // console.warn(`[trace-upload] Failed: ${result.status} ${result.body}`);
+    }
+}
+//# sourceMappingURL=session-upload.js.map

package/dist/index.js

@@ -0,0 +1,45 @@
+// Core session management
+// Config paths
+export { VERSION, getAgentDir } from './config.js';
+export { AgentSession, parseSkillBlock } from './core/agent-session.js';
+// Auth and model registry
+export { AuthStorage, FileAuthStorageBackend, InMemoryAuthStorageBackend } from './core/auth-storage.js';
+// Compaction
+export { DEFAULT_COMPACTION_SETTINGS, calculateContextTokens, collectEntriesForBranchSummary, compact, estimateTokens, findCutPoint, findTurnStartIndex, generateBranchSummary, generateSummary, getLastAssistantUsage, prepareBranchEntries, serializeConversation, shouldCompact } from './core/compaction/index.js';
+export { createEventBus } from './core/event-bus.js';
+// Extension system
+export { ExtensionRunner, createExtensionRuntime, discoverAndLoadExtensions, isBashToolResult, isEditToolResult, isFindToolResult, isGrepToolResult, isLsToolResult, isReadToolResult, isToolCallEventType, isWriteToolResult, wrapRegisteredTool, wrapRegisteredTools, wrapToolWithExtensions, wrapToolsWithExtensions } from './core/extensions/index.js';
+export { convertToLlm } from './core/messages.js';
+export { ModelRegistry } from './core/model-registry.js';
+export { DefaultPackageManager } from './core/package-manager.js';
+export { DefaultResourceLoader } from './core/resource-loader.js';
+// SDK for programmatic usage
+export { 
+// Factory
+createAgentSession, createBashTool, 
+// Tool factories (for custom cwd)
+createCodingTools, createEditTool, createFindTool, createGrepTool, createLsTool, createReadOnlyTools, createReadTool, createWriteTool, 
+// Pre-built tools (use process.cwd())
+readOnlyTools } from './core/sdk.js';
+export { CURRENT_SESSION_VERSION, SessionManager, buildSessionContext, getLatestCompactionEntry, migrateSessionEntries, parseSessionEntries } from './core/session-manager.js';
+export { SettingsManager } from './core/settings-manager.js';
+// Skills
+export { formatSkillsForPrompt, loadSkills, loadSkillsFromDir } from './core/skills.js';
+// Tools
+export { DEFAULT_MAX_CHARS, bashTool, codingTools, editTool, findTool, formatSize, grepTool, lsTool, readTool, truncateHead, truncateLine, truncateOutput, writeTool } from './core/tools/index.js';
+// Main entry point
+export { main } from './main.js';
+// Run modes for programmatic SDK usage
+export { InteractiveMode, runPrintMode, runRpcMode } from './modes/index.js';
+// UI components for extensions
+export { ArminComponent, AssistantMessageComponent, BashExecutionComponent, BorderedLoader, BranchSummaryMessageComponent, CompactionSummaryMessageComponent, CustomEditor, CustomMessageComponent, DynamicBorder, ExtensionEditorComponent, ExtensionInputComponent, ExtensionSelectorComponent, FooterComponent, LoginDialogComponent, ModelSelectorComponent, OAuthSelectorComponent, SessionSelectorComponent, SettingsSelectorComponent, ShowImagesSelectorComponent, SkillInvocationMessageComponent, ThemeSelectorComponent, ThinkingSelectorComponent, ToolExecutionComponent, TreeSelectorComponent, UserMessageComponent, UserMessageSelectorComponent, appKey, appKeyHint, editorKey, keyHint, rawKeyHint, renderDiff, truncateToVisualLines } from './modes/interactive/components/index.js';
+// Theme core
+export { Theme, initTheme } from './core/theme.js';
+// Theme TUI utilities for custom tools and extensions
+export { getLanguageFromPath, getMarkdownTheme, getSelectListTheme, getSettingsListTheme, highlightCode } from './modes/interactive/theme/theme.js';
+// Clipboard utilities
+export { copyToClipboard } from './utils/clipboard.js';
+export { parseFrontmatter, stripFrontmatter } from './utils/frontmatter.js';
+// Shell utilities
+export { getShellConfig, resetShellConfig } from './utils/shell.js';
+//# sourceMappingURL=index.js.map