shortcutxl 0.2.0

package/dist/custom/tools/llm-analysis.js

@@ -0,0 +1,265 @@
+/**
+ * LLM Analysis tool — sends local files (images, PDFs, text) to a vision LLM
+ * via the backend proxy for analysis/extraction.
+ *
+ * Output is always written to the agent temp directory.
+ */
+import { readFile, mkdir, writeFile, readdir, stat, unlink } from 'fs/promises';
+import { join, extname, basename } from 'path';
+import { Type } from '@sinclair/typebox';
+import { LLM_ANALYSIS } from '../../tool-names.js';
+import { SHORTCUT_PROVIDER_ID } from '../providers/provider-ids.js';
+import { APP_NAME, getAgentDir } from '../../config.js';
+import { Text } from '../../tui/index.js';
+const TOOL_NAME = LLM_ANALYSIS;
+const OUTPUT_DIR_NAME = 'llm_analysis';
+const CLEANUP_MAX_AGE_MS = 60 * 60 * 1000; // 1 hour
+/** MIME types for binary files sent as base64 image blocks. */
+const IMAGE_EXTENSIONS = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+};
+/** Extensions treated as readable text (sent as text blocks). */
+const TEXT_EXTENSIONS = new Set([
+    '.txt', '.csv', '.tsv', '.json', '.jsonl', '.md', '.xml', '.yaml', '.yml',
+    '.html', '.css', '.js', '.ts', '.py', '.sql', '.log', '.sh', '.cfg', '.ini',
+    '.toml', '.env', '.bat', '.ps1', '.r', '.sas', '.do', '.vba', '.bas',
+]);
+const MODELS = {
+    'gemini-3-flash-preview': 'gemini-3-flash-preview',
+    'claude-haiku-4-5-20251001': 'claude-haiku-4-5-20251001',
+};
+const DEFAULT_MODEL = 'gemini-3-flash-preview';
+const SYSTEM_PROMPT = `You are a document extraction assistant.
+
+Extraction rules:
+- Preserve data exactly: extracted numbers, formulas, formatting, and text must match the source precisely
+- For structured data extractions such as tables
+    - The delimiter used must be unambiguous and not included in the data itself. Use pipes \`|\` by default.
+    - Make sure to handle empty values appropriately (e.g., "| |"). Skipping empty values will cause errors when programmatic extraction is done
+
+Referencing:
+- Ensure that extracted data is cited. For example, [Page X, Table "Name"] or [Page X, Section "Name"] before a dump of data blocks.
+- IMPORTANT: Always cite using page numbers from the source document (on the bottom right of the page)`;
+const TOOL_DESCRIPTION = `\
+Analyzes files using a vision LLM (Gemini Flash or Claude Haiku). Sends files to the LLM and saves the analysis output to a temp file.
+
+Supported image types: ${Object.keys(IMAGE_EXTENSIONS).join(', ')}
+Supported text types: ${[...TEXT_EXTENSIONS].join(', ')}
+Also supports: .pdf
+
+MODEL SELECTION:
+- "gemini-3-flash-preview" (default): Best for careful extraction, tables, and especially images
+- "claude-haiku-4-5-20251001": Quick scanning, structure discovery
+
+FOR EXTRACTION TASKS:
+- Pay close attention to edge cases, such as commas, spaces, signs and null values.
+- For financial data, parentheses are used to indicate negative values.
+
+Output is saved to a temp file and the path is returned. Read the file to see the full output.`;
+const schema = Type.Object({
+    description: Type.String({
+        description: "Brief human-readable description of what this analysis will do (e.g., 'Extracting sales data from Q4 report')",
+    }),
+    file_paths: Type.Array(Type.String(), {
+        description: 'List of local file paths to analyze (e.g., ["C:/Users/me/report.pdf"]). Max 20.',
+        maxItems: 20,
+    }),
+    query: Type.String({
+        description: 'The question/instruction for the LLM about the file content.',
+    }),
+    model: Type.Optional(Type.String({
+        description: `Model to use: '${DEFAULT_MODEL}' (default, best for images/tables) or 'claude-haiku-4-5-20251001' (fallback/verifier)`,
+    })),
+    output_filename: Type.Optional(Type.String({
+        description: "Optional output filename (e.g., 'analysis.md'). Auto-generated if omitted.",
+    })),
+});
+/** Get (and create) the output directory for analysis results. */
+async function getOutputDir() {
+    const dir = join(getAgentDir(), 'temp', OUTPUT_DIR_NAME);
+    await mkdir(dir, { recursive: true });
+    return dir;
+}
+/** Clean up files older than CLEANUP_MAX_AGE_MS. Best-effort, never throws. */
+async function cleanupOldFiles(dir) {
+    try {
+        const entries = await readdir(dir);
+        const now = Date.now();
+        for (const entry of entries) {
+            try {
+                const filePath = join(dir, entry);
+                const fileStat = await stat(filePath);
+                if (fileStat.isFile() && now - fileStat.mtimeMs > CLEANUP_MAX_AGE_MS) {
+                    await unlink(filePath);
+                }
+            }
+            catch {
+                // skip individual file errors
+            }
+        }
+    }
+    catch {
+        // directory might not exist yet
+    }
+}
+/** Build the content blocks for the LLM request. */
+async function buildContent(filePaths, query) {
+    const contentBlocks = [];
+    for (const filePath of filePaths) {
+        const ext = extname(filePath).toLowerCase();
+        if (ext === '.pdf') {
+            // PDF: send as base64 document source
+            const buffer = await readFile(filePath);
+            const base64 = buffer.toString('base64');
+            contentBlocks.push({
+                type: 'image_url',
+                image_url: { url: `data:application/pdf;base64,${base64}` },
+            });
+        }
+        else if (IMAGE_EXTENSIONS[ext]) {
+            // Image: send as base64 image
+            const buffer = await readFile(filePath);
+            const base64 = buffer.toString('base64');
+            contentBlocks.push({
+                type: 'image_url',
+                image_url: { url: `data:${IMAGE_EXTENSIONS[ext]};base64,${base64}` },
+            });
+        }
+        else if (TEXT_EXTENSIONS.has(ext)) {
+            // Text: read and include as text block
+            const buffer = await readFile(filePath);
+            const text = buffer.toString('utf-8');
+            contentBlocks.push({
+                type: 'text',
+                text: `--- File: ${basename(filePath)} ---\n${text}`,
+            });
+        }
+        else {
+            // Unknown extension: try as text
+            const buffer = await readFile(filePath);
+            const text = buffer.toString('utf-8');
+            contentBlocks.push({
+                type: 'text',
+                text: `--- File: ${basename(filePath)} ---\n${text}`,
+            });
+        }
+    }
+    // Add the query
+    if (filePaths.length > 0) {
+        const filesList = filePaths.map((fp) => `- ${basename(fp)}`).join('\n');
+        contentBlocks.push({
+            type: 'text',
+            text: `Query: ${query}\n\nFiles:\n${filesList}`,
+        });
+    }
+    else {
+        contentBlocks.push({ type: 'text', text: query });
+    }
+    return [
+        { role: 'system', content: SYSTEM_PROMPT },
+        { role: 'human', content: contentBlocks },
+    ];
+}
+export function createLlmAnalysisTool(baseUrl) {
+    return {
+        name: TOOL_NAME,
+        label: 'LLM Analysis',
+        description: TOOL_DESCRIPTION,
+        parameters: schema,
+        renderCall(args, options, theme) {
+            const desc = typeof args?.description === 'string' ? args.description : '';
+            const label = desc || 'llm_analysis';
+            const title = theme.fg('toolTitle', theme.bold(`🔍 ${label}`));
+            if (!options.expanded) {
+                return new Text(title, 0, 0);
+            }
+            const files = Array.isArray(args?.file_paths)
+                ? args.file_paths.map((fp) => `  ${basename(fp)}`).join('\n')
+                : '';
+            const model = args?.model || DEFAULT_MODEL;
+            const details = [
+                files ? `Files:\n${files}` : '',
+                `Model: ${model}`,
+                args?.query ? `Query: ${args.query}` : '',
+            ]
+                .filter(Boolean)
+                .join('\n');
+            return new Text(`${title}\n\n${theme.fg('toolOutput', details)}`, 0, 0);
+        },
+        renderResult(result, options, theme) {
+            if (!options.expanded)
+                return undefined;
+            const textBlocks = result.content?.filter((c) => c.type === 'text') || [];
+            const output = textBlocks.map((c) => ('text' in c ? c.text : '') || '').join('\n');
+            if (!output)
+                return undefined;
+            return new Text(theme.fg('toolOutput', output), 0, 0);
+        },
+        async execute(toolCallId, { description: _description, file_paths, query, model, output_filename }, signal, _onUpdate, ctx) {
+            const selectedModel = (model && model in MODELS ? model : DEFAULT_MODEL);
+            // Get output dir and clean old files
+            const outputDir = await getOutputDir();
+            await cleanupOldFiles(outputDir);
+            // Get API key from model registry
+            const apiKey = ctx?.modelRegistry
+                ? await ctx.modelRegistry.getApiKeyForProvider(SHORTCUT_PROVIDER_ID)
+                : undefined;
+            if (!apiKey) {
+                throw new Error('Not authenticated. Please log in first.');
+            }
+            // Build LLM messages
+            const messages = await buildContent(file_paths, query);
+            // Call the backend /api/llm/invoke endpoint
+            const body = {
+                model: MODELS[selectedModel],
+                messages,
+                effort_level: 'low',
+                thinking_type: 'off',
+            };
+            let response;
+            try {
+                response = await fetch(`${baseUrl}/api/llm/invoke`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Authorization: `Bearer ${apiKey}`,
+                        'User-Agent': `Mozilla/5.0 (compatible; ${APP_NAME}-coding-agent/1.0)`,
+                    },
+                    body: JSON.stringify(body),
+                    signal,
+                });
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                throw new Error(`Failed to connect to LLM proxy: ${msg}`);
+            }
+            if (!response.ok) {
+                const raw = await response.text();
+                const text = raw.split('\n').slice(0, 10).join('\n');
+                throw new Error(`LLM proxy error ${response.status}: ${text}`);
+            }
+            const data = (await response.json());
+            if (!data.text) {
+                throw new Error('LLM returned empty response');
+            }
+            // Write output to temp file
+            const filename = output_filename || `analysis_${toolCallId.slice(-8)}_${Date.now()}.md`;
+            const outputPath = join(outputDir, filename);
+            await writeFile(outputPath, data.text, 'utf-8');
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Analysis complete. Output saved to: ${outputPath}\n\nUse the read tool to view the full output.`,
+                    },
+                ],
+                details: undefined,
+            };
+        },
+    };
+}
+//# sourceMappingURL=llm-analysis.js.map

package/dist/custom/tools/render-helpers.js

@@ -0,0 +1,38 @@
+/**
+ * Rendering utilities for custom tool renderCall/renderResult.
+ *
+ * These exist here (not in modes/) so that custom/ doesn't violate
+ * the import boundary. They only depend on core/ and external packages.
+ */
+import { highlight, supportsLanguage } from 'cli-highlight';
+import { theme } from '../../core/theme.js';
+/**
+ * Highlight code with syntax coloring. Returns array of lines.
+ */
+export function highlightCode(code, lang) {
+    const validLang = lang && supportsLanguage(lang) ? lang : undefined;
+    const cliTheme = {
+        keyword: (s) => theme.fg('syntaxKeyword', s),
+        built_in: (s) => theme.fg('syntaxType', s),
+        literal: (s) => theme.fg('syntaxNumber', s),
+        number: (s) => theme.fg('syntaxNumber', s),
+        string: (s) => theme.fg('syntaxString', s),
+        comment: (s) => theme.fg('syntaxComment', s),
+        function: (s) => theme.fg('syntaxFunction', s),
+        title: (s) => theme.fg('syntaxFunction', s),
+        class: (s) => theme.fg('syntaxType', s),
+        type: (s) => theme.fg('syntaxType', s),
+        attr: (s) => theme.fg('syntaxVariable', s),
+        variable: (s) => theme.fg('syntaxVariable', s),
+        params: (s) => theme.fg('syntaxVariable', s),
+        operator: (s) => theme.fg('syntaxOperator', s),
+        punctuation: (s) => theme.fg('syntaxPunctuation', s)
+    };
+    try {
+        return highlight(code, { language: validLang, ignoreIllegals: true, theme: cliTheme }).split('\n');
+    }
+    catch {
+        return code.split('\n');
+    }
+}
+//# sourceMappingURL=render-helpers.js.map

package/dist/custom/tools/switch-mode.js

@@ -0,0 +1,94 @@
+/**
+ * switch_mode tool — swap agent definition mid-session.
+ *
+ * Each agent definition bundles a system prompt and tool set.
+ * This tool transitions between them (e.g. installation → action)
+ * while keeping message history.
+ *
+ * Each agent declares which modes it can switch to via `switchTo`.
+ */
+import { Type } from '@sinclair/typebox';
+import { SWITCH_MODE } from '../../tool-names.js';
+import { actionAgent } from '../agents/action.js';
+import { installationAgent } from '../agents/installation.js';
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const TOOL_NAME = SWITCH_MODE;
+const TOOL_LABEL = 'Switch Mode';
+const MODES = [installationAgent(), actionAgent()];
+const MODE_LIST = MODES.map((a) => {
+    const targets = (a.switchTo ?? []).join(', ');
+    return `- ${a.name}: ${a.description} (can switch to: ${targets || 'none'})`;
+}).join('\n');
+const MODE_NAMES = MODES.map((a) => a.name);
+const TOOL_DESCRIPTION = `\
+Switch the agent to a different mode. This swaps the system prompt and active tools while keeping message history.
+
+Available modes:
+${MODE_LIST}
+
+You can only switch to modes allowed by your current mode.`;
+const PROMPT_SNIPPET = `\
+Switch between agent modes.
+
+Modes:
+${MODE_LIST}
+
+You can only switch to modes allowed by your current mode.`;
+const schema = Type.Object({
+    mode: Type.Union(MODE_NAMES.map((n) => Type.Literal(n)), { description: 'The name of the agent mode to switch to' })
+});
+export function createSwitchModeTool(session) {
+    return {
+        name: TOOL_NAME,
+        label: TOOL_LABEL,
+        description: TOOL_DESCRIPTION,
+        promptSnippet: PROMPT_SNIPPET,
+        parameters: schema,
+        async execute(_toolCallId, params) {
+            const currentMode = currentModeRef;
+            const current = MODES.find((a) => a.name === currentMode);
+            // Only allow switching to modes declared in current agent's switchTo
+            const allowedNames = current?.switchTo ?? [];
+            const allowed = MODES.filter((a) => allowedNames.includes(a.name));
+            const target = allowed.find((a) => a.name === params.mode);
+            if (!target) {
+                const available = allowed.length > 0
+                    ? allowed.map((a) => `${a.name}: ${a.description}`).join('\n')
+                    : '(none)';
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Cannot switch to "${params.mode}" from ${currentMode} mode. Available:\n${available}`
+                        }
+                    ],
+                    details: null
+                };
+            }
+            const s = session();
+            s.setBaseSystemPrompt(target.systemPrompt);
+            s.setActiveToolsByName([...target.tools]);
+            currentModeRef = target.name;
+            // Snapshot the new system prompt + tools into the session trace so the
+            // JSONL reflects the mode switch (otherwise only the initial prompt is recorded).
+            s.sessionManager.appendSystemPrompt(s.systemPrompt);
+            s.sessionManager.appendToolDefinitions(s.agent.state.tools.map((t) => ({
+                name: t.name,
+                description: t.description,
+                parameters: t.parameters
+            })));
+            return {
+                content: [{ type: 'text', text: `Switched to ${target.name} mode.` }],
+                details: null
+            };
+        }
+    };
+}
+/** Mutable ref updated on switch — read by getCurrentMode closure */
+let currentModeRef = '';
+export function setCurrentMode(mode) {
+    currentModeRef = mode;
+}
+//# sourceMappingURL=switch-mode.js.map

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

@@ -0,0 +1,6 @@
+/**
+ * Re-exports — agent definitions now live in custom/agents/.
+ */
+export { buildTaskToolDescription, getSubagent, getSubagentNames } from '../../agents/index.js';
+export { buildAgentArgs } from './subprocess.js';
+//# sourceMappingURL=agents.js.map

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

@@ -0,0 +1,8 @@
+/**
+ * Task tool — public API.
+ *
+ * Re-exports the factory needed by main.ts.
+ * Agent definitions now live in custom/agents/.
+ */
+export { createTaskTool } from './task.js';
+//# sourceMappingURL=index.js.map