shortcutxl 0.2.0

package/dist/core/extensions/wrapper.js

@@ -0,0 +1,102 @@
+/**
+ * Tool wrappers for extensions.
+ */
+/**
+ * Wrap a RegisteredTool into an AgentTool.
+ * Uses the runner's createContext() for consistent context across tools and event handlers.
+ */
+export function wrapRegisteredTool(registeredTool, runner) {
+    const { definition } = registeredTool;
+    return {
+        name: definition.name,
+        label: definition.label,
+        description: definition.description,
+        parameters: definition.parameters,
+        execute: (toolCallId, params, signal, onUpdate) => definition.execute(toolCallId, params, signal, onUpdate, runner.createContext())
+    };
+}
+/**
+ * Wrap all registered tools into AgentTools.
+ * Uses the runner's createContext() for consistent context across tools and event handlers.
+ */
+export function wrapRegisteredTools(registeredTools, runner) {
+    return registeredTools.map((rt) => wrapRegisteredTool(rt, runner));
+}
+/**
+ * Wrap a tool with extension callbacks for interception.
+ * - Emits tool_call event before execution (can block)
+ * - Emits tool_result event after execution (can modify result)
+ */
+export function wrapToolWithExtensions(tool, runner) {
+    return {
+        ...tool,
+        execute: async (toolCallId, params, signal, onUpdate) => {
+            // Emit tool_call event - extensions can block execution
+            if (runner.hasHandlers('tool_call')) {
+                try {
+                    const callResult = (await runner.emitToolCall({
+                        type: 'tool_call',
+                        toolName: tool.name,
+                        toolCallId,
+                        input: params
+                    }));
+                    if (callResult?.block) {
+                        const reason = callResult.reason || 'Tool execution was blocked by an extension';
+                        throw new Error(reason);
+                    }
+                }
+                catch (err) {
+                    if (err instanceof Error) {
+                        throw err;
+                    }
+                    throw new Error(`Extension failed, blocking execution: ${String(err)}`);
+                }
+            }
+            // Execute the actual tool
+            try {
+                const result = await tool.execute(toolCallId, params, signal, onUpdate);
+                // Emit tool_result event - extensions can modify the result
+                if (runner.hasHandlers('tool_result')) {
+                    const resultResult = await runner.emitToolResult({
+                        type: 'tool_result',
+                        toolName: tool.name,
+                        toolCallId,
+                        input: params,
+                        content: result.content,
+                        details: result.details,
+                        isError: false
+                    });
+                    if (resultResult) {
+                        return {
+                            content: resultResult.content ?? result.content,
+                            details: (resultResult.details ?? result.details)
+                        };
+                    }
+                }
+                return result;
+            }
+            catch (err) {
+                // Emit tool_result event for errors
+                if (runner.hasHandlers('tool_result')) {
+                    await runner.emitToolResult({
+                        type: 'tool_result',
+                        toolName: tool.name,
+                        toolCallId,
+                        input: params,
+                        content: [{ type: 'text', text: err instanceof Error ? err.message : String(err) }],
+                        details: undefined,
+                        isError: true
+                    });
+                }
+                throw err;
+            }
+        }
+    };
+}
+/**
+ * Wrap all tools with extension callbacks.
+ */
+export function wrapToolsWithExtensions(tools, runner) {
+    return tools.map((tool) => wrapToolWithExtensions(tool, runner));
+}
+//# sourceMappingURL=wrapper.js.map

package/dist/core/footer-data-provider.js

@@ -0,0 +1,162 @@
+import { existsSync, readFileSync, statSync, watch } from 'fs';
+import { dirname, join, resolve } from 'path';
+/**
+ * Find the git HEAD path by walking up from cwd.
+ * Handles both regular git repos (.git is a directory) and worktrees (.git is a file).
+ */
+function findGitHeadPath() {
+    let dir = process.cwd();
+    while (true) {
+        const gitPath = join(dir, '.git');
+        if (existsSync(gitPath)) {
+            try {
+                const stat = statSync(gitPath);
+                if (stat.isFile()) {
+                    const content = readFileSync(gitPath, 'utf8').trim();
+                    if (content.startsWith('gitdir: ')) {
+                        const gitDir = content.slice(8);
+                        const headPath = resolve(dir, gitDir, 'HEAD');
+                        if (existsSync(headPath))
+                            return headPath;
+                    }
+                }
+                else if (stat.isDirectory()) {
+                    const headPath = join(gitPath, 'HEAD');
+                    if (existsSync(headPath))
+                        return headPath;
+                }
+            }
+            catch {
+                return null;
+            }
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+/**
+ * Provides git branch and extension statuses - data not otherwise accessible to extensions.
+ * Token stats, model info available via ctx.sessionManager and ctx.model.
+ */
+export class FooterDataProvider {
+    extensionStatuses = new Map();
+    cachedBranch = undefined;
+    gitWatcher = null;
+    branchChangeCallbacks = new Set();
+    availableProviderCount = 0;
+    constructor() {
+        this.setupGitWatcher();
+    }
+    /** Current git branch, null if not in repo, "detached" if detached HEAD */
+    getGitBranch() {
+        if (this.cachedBranch !== undefined)
+            return this.cachedBranch;
+        try {
+            const gitHeadPath = findGitHeadPath();
+            if (!gitHeadPath) {
+                this.cachedBranch = null;
+                return null;
+            }
+            const content = readFileSync(gitHeadPath, 'utf8').trim();
+            this.cachedBranch = content.startsWith('ref: refs/heads/') ? content.slice(16) : 'detached';
+        }
+        catch {
+            this.cachedBranch = null;
+        }
+        return this.cachedBranch;
+    }
+    /** Extension status texts set via ctx.ui.setStatus() */
+    getExtensionStatuses() {
+        return this.extensionStatuses;
+    }
+    /** Subscribe to git branch changes. Returns unsubscribe function. */
+    onBranchChange(callback) {
+        this.branchChangeCallbacks.add(callback);
+        return () => this.branchChangeCallbacks.delete(callback);
+    }
+    /** Internal: set extension status */
+    setExtensionStatus(key, text) {
+        if (text === undefined) {
+            this.extensionStatuses.delete(key);
+        }
+        else {
+            this.extensionStatuses.set(key, text);
+        }
+    }
+    /** Internal: clear extension statuses */
+    clearExtensionStatuses() {
+        this.extensionStatuses.clear();
+    }
+    /** Number of unique providers with available models (for footer display) */
+    getAvailableProviderCount() {
+        return this.availableProviderCount;
+    }
+    /** Internal: update available provider count */
+    setAvailableProviderCount(count) {
+        this.availableProviderCount = count;
+    }
+    /** Shortcut credit balance (null = not fetched or not using shortcut) */
+    creditBalance = null;
+    /** Initial credit balance captured at session start, used to compute credits used */
+    initialCreditBalance = null;
+    /** True when the active model uses credits (suppresses $cost even when balance fetch fails) */
+    _usesCredits = false;
+    getCreditBalance() {
+        return this.creditBalance;
+    }
+    /** Credits consumed this session (initial - current). Returns 0 if not yet known. */
+    getCreditsUsed() {
+        if (this.initialCreditBalance === null || !this.creditBalance)
+            return 0;
+        return Math.max(0, this.initialCreditBalance - this.creditBalance.creditsRemaining);
+    }
+    setCreditBalance(balance) {
+        // Capture the first non-null balance as the session baseline
+        if (balance && this.initialCreditBalance === null) {
+            this.initialCreditBalance = balance.creditsRemaining;
+        }
+        this.creditBalance = balance;
+    }
+    get usesCredits() {
+        return this._usesCredits;
+    }
+    setUsesCredits(value) {
+        this._usesCredits = value;
+    }
+    /** Internal: cleanup */
+    dispose() {
+        if (this.gitWatcher) {
+            this.gitWatcher.close();
+            this.gitWatcher = null;
+        }
+        this.branchChangeCallbacks.clear();
+    }
+    setupGitWatcher() {
+        if (this.gitWatcher) {
+            this.gitWatcher.close();
+            this.gitWatcher = null;
+        }
+        const gitHeadPath = findGitHeadPath();
+        if (!gitHeadPath)
+            return;
+        // Watch the directory containing HEAD, not HEAD itself.
+        // Git uses atomic writes (write temp, rename over HEAD), which changes the inode.
+        // fs.watch on a file stops working after the inode changes.
+        const gitDir = dirname(gitHeadPath);
+        try {
+            this.gitWatcher = watch(gitDir, (_eventType, filename) => {
+                if (filename === 'HEAD') {
+                    this.cachedBranch = undefined;
+                    for (const cb of this.branchChangeCallbacks)
+                        cb();
+                }
+            });
+        }
+        catch {
+            // Silently fail if we can't watch
+        }
+    }
+}
+//# sourceMappingURL=footer-data-provider.js.map

package/dist/core/index.js

@@ -0,0 +1,9 @@
+/**
+ * Core modules shared between all run modes.
+ */
+export { AgentSession } from './agent-session.js';
+export { executeBash, executeBashWithOperations } from './bash-executor.js';
+export { createEventBus } from './event-bus.js';
+// Extensions system
+export { ExtensionRunner, discoverAndLoadExtensions, wrapToolsWithExtensions } from './extensions/index.js';
+//# sourceMappingURL=index.js.map

package/dist/core/keybindings.js

@@ -0,0 +1,153 @@
+import { DEFAULT_EDITOR_KEYBINDINGS, EditorKeybindingsManager, matchesKey, setEditorKeybindings } from '../tui/index.js';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { getAgentDir } from '../config.js';
+/**
+ * Default application keybindings.
+ */
+export const DEFAULT_APP_KEYBINDINGS = {
+    interrupt: 'escape',
+    clear: 'ctrl+c',
+    exit: 'ctrl+d',
+    suspend: 'ctrl+z',
+    cycleThinkingLevel: 'shift+tab',
+    cycleModelForward: 'ctrl+p',
+    cycleModelBackward: 'shift+ctrl+p',
+    selectModel: 'ctrl+l',
+    expandTools: 'ctrl+o',
+    toggleThinking: 'ctrl+t',
+    toggleSessionNamedFilter: 'ctrl+n',
+    externalEditor: 'ctrl+g',
+    followUp: 'alt+enter',
+    dequeue: 'alt+up',
+    pasteImage: process.platform === 'win32' ? 'alt+v' : 'ctrl+v',
+    newSession: [],
+    tree: [],
+    fork: [],
+    resume: []
+};
+/**
+ * All default keybindings (app + editor).
+ */
+export const DEFAULT_KEYBINDINGS = {
+    ...DEFAULT_EDITOR_KEYBINDINGS,
+    ...DEFAULT_APP_KEYBINDINGS
+};
+// App actions list for type checking
+const APP_ACTIONS = [
+    'interrupt',
+    'clear',
+    'exit',
+    'suspend',
+    'cycleThinkingLevel',
+    'cycleModelForward',
+    'cycleModelBackward',
+    'selectModel',
+    'expandTools',
+    'toggleThinking',
+    'toggleSessionNamedFilter',
+    'externalEditor',
+    'followUp',
+    'dequeue',
+    'pasteImage',
+    'newSession',
+    'tree',
+    'fork',
+    'resume'
+];
+function isAppAction(action) {
+    return APP_ACTIONS.includes(action);
+}
+/**
+ * Manages all keybindings (app + editor).
+ */
+export class KeybindingsManager {
+    config;
+    appActionToKeys;
+    constructor(config) {
+        this.config = config;
+        this.appActionToKeys = new Map();
+        this.buildMaps();
+    }
+    /**
+     * Create from config file and set up editor keybindings.
+     */
+    static create(agentDir = getAgentDir()) {
+        const configPath = join(agentDir, 'keybindings.json');
+        const config = KeybindingsManager.loadFromFile(configPath);
+        const manager = new KeybindingsManager(config);
+        // Set up editor keybindings globally
+        // Include both editor actions and expandTools (shared between app and editor)
+        const editorConfig = {};
+        for (const [action, keys] of Object.entries(config)) {
+            if (!isAppAction(action) || action === 'expandTools') {
+                editorConfig[action] = keys;
+            }
+        }
+        setEditorKeybindings(new EditorKeybindingsManager(editorConfig));
+        return manager;
+    }
+    /**
+     * Create in-memory.
+     */
+    static inMemory(config = {}) {
+        return new KeybindingsManager(config);
+    }
+    static loadFromFile(path) {
+        if (!existsSync(path))
+            return {};
+        try {
+            return JSON.parse(readFileSync(path, 'utf-8'));
+        }
+        catch {
+            return {};
+        }
+    }
+    buildMaps() {
+        this.appActionToKeys.clear();
+        // Set defaults for app actions
+        for (const [action, keys] of Object.entries(DEFAULT_APP_KEYBINDINGS)) {
+            const keyArray = Array.isArray(keys) ? keys : [keys];
+            this.appActionToKeys.set(action, [...keyArray]);
+        }
+        // Override with user config (app actions only)
+        for (const [action, keys] of Object.entries(this.config)) {
+            if (keys === undefined || !isAppAction(action))
+                continue;
+            const keyArray = Array.isArray(keys) ? keys : [keys];
+            this.appActionToKeys.set(action, keyArray);
+        }
+    }
+    /**
+     * Check if input matches an app action.
+     */
+    matches(data, action) {
+        const keys = this.appActionToKeys.get(action);
+        if (!keys)
+            return false;
+        for (const key of keys) {
+            if (matchesKey(data, key))
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Get keys bound to an app action.
+     */
+    getKeys(action) {
+        return this.appActionToKeys.get(action) ?? [];
+    }
+    /**
+     * Get the full effective config.
+     */
+    getEffectiveConfig() {
+        const result = { ...DEFAULT_KEYBINDINGS };
+        for (const [action, keys] of Object.entries(this.config)) {
+            if (keys !== undefined) {
+                result[action] = keys;
+            }
+        }
+        return result;
+    }
+}
+//# sourceMappingURL=keybindings.js.map

package/dist/core/messages.js

@@ -0,0 +1,133 @@
+/**
+ * Custom message types and transformers for the coding agent.
+ *
+ * Extends the base AgentMessage type with coding-agent specific message types,
+ * and provides a transformer to convert them to LLM-compatible messages.
+ */
+export const COMPACTION_SUMMARY_PREFIX = `The conversation history before this point was compacted into the following summary:
+
+<summary>
+`;
+export const COMPACTION_SUMMARY_SUFFIX = `
+</summary>`;
+export const BRANCH_SUMMARY_PREFIX = `The following is a summary of a branch that this conversation came back from:
+
+<summary>
+`;
+export const BRANCH_SUMMARY_SUFFIX = `</summary>`;
+/**
+ * Convert a BashExecutionMessage to user message text for LLM context.
+ */
+export function bashExecutionToText(msg) {
+    let text = `Ran \`${msg.command}\`\n`;
+    if (msg.output) {
+        text += `\`\`\`\n${msg.output}\n\`\`\``;
+    }
+    else {
+        text += '(no output)';
+    }
+    if (msg.cancelled) {
+        text += '\n\n(command cancelled)';
+    }
+    else if (msg.exitCode !== null && msg.exitCode !== undefined && msg.exitCode !== 0) {
+        text += `\n\nCommand exited with code ${msg.exitCode}`;
+    }
+    if (msg.truncated && msg.fullOutputPath) {
+        text += `\n\n[Output truncated. Full output: ${msg.fullOutputPath}]`;
+    }
+    return text;
+}
+export function createBranchSummaryMessage(summary, fromId, timestamp) {
+    return {
+        role: 'branchSummary',
+        summary,
+        fromId,
+        timestamp: new Date(timestamp).getTime()
+    };
+}
+export function createCompactionSummaryMessage(summary, tokensBefore, timestamp) {
+    return {
+        role: 'compactionSummary',
+        summary: summary,
+        tokensBefore,
+        timestamp: new Date(timestamp).getTime()
+    };
+}
+/** Convert CustomMessageEntry to AgentMessage format */
+export function createCustomMessage(customType, content, display, details, timestamp) {
+    return {
+        role: 'custom',
+        customType,
+        content,
+        display,
+        details,
+        timestamp: new Date(timestamp).getTime()
+    };
+}
+/**
+ * Transform AgentMessages (including custom types) to LLM-compatible Messages.
+ *
+ * This is used by:
+ * - Agent's transormToLlm option (for prompt calls and queued messages)
+ * - Compaction's generateSummary (for summarization)
+ * - Custom extensions and tools
+ */
+export function convertToLlm(messages) {
+    return messages
+        .map((m) => {
+        switch (m.role) {
+            case 'bashExecution':
+                // Skip messages excluded from context (!! prefix)
+                if (m.excludeFromContext) {
+                    return undefined;
+                }
+                return {
+                    role: 'user',
+                    content: [{ type: 'text', text: bashExecutionToText(m) }],
+                    timestamp: m.timestamp
+                };
+            case 'custom': {
+                const content = typeof m.content === 'string'
+                    ? [{ type: 'text', text: m.content }]
+                    : m.content;
+                return {
+                    role: 'user',
+                    content,
+                    timestamp: m.timestamp
+                };
+            }
+            case 'branchSummary':
+                return {
+                    role: 'user',
+                    content: [
+                        {
+                            type: 'text',
+                            text: BRANCH_SUMMARY_PREFIX + m.summary + BRANCH_SUMMARY_SUFFIX
+                        }
+                    ],
+                    timestamp: m.timestamp
+                };
+            case 'compactionSummary':
+                return {
+                    role: 'user',
+                    content: [
+                        {
+                            type: 'text',
+                            text: COMPACTION_SUMMARY_PREFIX + m.summary + COMPACTION_SUMMARY_SUFFIX
+                        }
+                    ],
+                    timestamp: m.timestamp
+                };
+            case 'user':
+            case 'assistant':
+            case 'toolResult':
+                return m;
+            default:
+                // biome-ignore lint/correctness/noSwitchDeclarations: fine
+                const _exhaustiveCheck = m;
+                return undefined;
+        }
+    })
+        .filter((m) => m !== undefined);
+}
+//# sourceMappingURL=messages.js.map