shortcutxl 0.2.0

package/dist/core/sdk.js

@@ -0,0 +1,197 @@
+import { join } from 'node:path';
+import { getAgentDir, getDocsPath } from '../config.js';
+import { AgentSession, LoginRequiredError } from './agent-session.js';
+import { Agent } from './agent.js';
+import { AuthStorage } from './auth-storage.js';
+import { DEFAULT_THINKING_LEVEL } from './defaults.js';
+import { convertToLlm } from './messages.js';
+import { ModelRegistry } from './model-registry.js';
+import { findInitialModel } from './model-resolver.js';
+import { DefaultResourceLoader } from './resource-loader.js';
+import { SessionManager } from './session-manager.js';
+import { SettingsManager } from './settings-manager.js';
+import { time } from './timings.js';
+import { allTools, bashTool, codingTools, createBashTool, createCodingTools, createEditTool, createFindTool, createGrepTool, createLsTool, createReadOnlyTools, createReadTool, createWriteTool, editTool, findTool, grepTool, lsTool, readOnlyTools, readTool, writeTool } from './tools/index.js';
+export { allTools as allBuiltInTools, bashTool, codingTools, createBashTool, 
+// Tool factories (for custom cwd)
+createCodingTools, createEditTool, createFindTool, createGrepTool, createLsTool, createReadOnlyTools, createReadTool, createWriteTool, editTool, findTool, grepTool, lsTool, readOnlyTools, 
+// Pre-built tools (use process.cwd())
+readTool, writeTool };
+// Helper Functions
+function getDefaultAgentDir() {
+    return getAgentDir();
+}
+/**
+ * Create an AgentSession with the specified options.
+ *
+ * @example
+ * ```typescript
+ * // Minimal - uses defaults
+ * const { session } = await createAgentSession();
+ *
+ * // With explicit model
+ * import { getModel } from '@mariozechner/pi-ai';
+ * const { session } = await createAgentSession({
+ *   model: getModel('anthropic', 'claude-opus-4-5'),
+ *   thinkingLevel: 'high',
+ * });
+ *
+ * // Continue previous session
+ * const { session, modelFallbackMessage } = await createAgentSession({
+ *   continueSession: true,
+ * });
+ *
+ * // Full control
+ * const loader = new DefaultResourceLoader({
+ *   cwd: process.cwd(),
+ *   agentDir: getAgentDir(),
+ *   settingsManager: SettingsManager.create(),
+ * });
+ * await loader.reload();
+ * const { session } = await createAgentSession({
+ *   model: myModel,
+ *   tools: [readTool, bashTool],
+ *   resourceLoader: loader,
+ *   sessionManager: SessionManager.inMemory(),
+ * });
+ * ```
+ */
+export async function createAgentSession(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const agentDir = options.agentDir ?? getDefaultAgentDir();
+    let resourceLoader = options.resourceLoader;
+    // Use provided or create AuthStorage and ModelRegistry
+    const authPath = options.agentDir ? join(agentDir, 'auth.json') : undefined;
+    const modelsPath = options.agentDir ? join(agentDir, 'models.json') : undefined;
+    const authStorage = options.authStorage ?? AuthStorage.create(authPath);
+    const modelRegistry = options.modelRegistry ?? new ModelRegistry(authStorage, modelsPath);
+    const settingsManager = options.settingsManager ?? SettingsManager.create(cwd, agentDir);
+    const sessionManager = options.sessionManager ?? SessionManager.create(cwd);
+    if (!resourceLoader) {
+        resourceLoader = new DefaultResourceLoader({ cwd, agentDir, settingsManager });
+        await resourceLoader.reload();
+        time('resourceLoader.reload');
+    }
+    // Check if session has existing data to restore
+    const existingSession = sessionManager.buildSessionContext();
+    const hasExistingSession = existingSession.messages.length > 0;
+    const hasThinkingEntry = sessionManager
+        .getBranch()
+        .some((entry) => entry.type === 'thinking_level_change');
+    let model = options.model;
+    let modelFallbackMessage;
+    // If session has data, try to restore model from it
+    if (!model && hasExistingSession && existingSession.model) {
+        const restoredModel = modelRegistry.find(existingSession.model.provider, existingSession.model.modelId);
+        if (restoredModel && (await modelRegistry.getApiKey(restoredModel))) {
+            model = restoredModel;
+        }
+        if (!model) {
+            modelFallbackMessage = `Could not restore model ${existingSession.model.provider}/${existingSession.model.modelId}`;
+        }
+    }
+    // If still no model, use findInitialModel (checks settings default, then provider defaults)
+    if (!model) {
+        const result = await findInitialModel({
+            isContinuing: hasExistingSession,
+            defaultProvider: settingsManager.getDefaultProvider(),
+            defaultModelId: settingsManager.getDefaultModel(),
+            defaultThinkingLevel: settingsManager.getDefaultThinkingLevel(),
+            modelRegistry
+        });
+        model = result.model;
+        if (!model) {
+            modelFallbackMessage = `No models available. Use /login or set an API key environment variable. See ${join(getDocsPath(), 'providers.md')}. Then use /model to select a model.`;
+        }
+        else if (modelFallbackMessage) {
+            modelFallbackMessage += `. Using ${model.provider}/${model.id}`;
+        }
+    }
+    let thinkingLevel = options.thinkingLevel;
+    // If session has data, restore thinking level from it
+    if (thinkingLevel === undefined && hasExistingSession) {
+        thinkingLevel = hasThinkingEntry
+            ? existingSession.thinkingLevel
+            : (settingsManager.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL);
+    }
+    // Fall back to settings default
+    if (thinkingLevel === undefined) {
+        thinkingLevel = settingsManager.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL;
+    }
+    // Clamp to model capabilities
+    if (!model || !model.reasoning) {
+        thinkingLevel = 'off';
+    }
+    // SHORTCUT PATCH: no default tools — every agent must explicitly declare its tools
+    const initialActiveToolNames = options.tools
+        ? options.tools.map((t) => t.name).filter((n) => n in allTools)
+        : [];
+    const extensionRunnerRef = {};
+    const agent = new Agent({
+        initialState: {
+            systemPrompt: '',
+            model,
+            thinkingLevel,
+            tools: []
+        },
+        convertToLlm,
+        sessionId: sessionManager.getSessionId(),
+        transformContext: async (messages) => {
+            const runner = extensionRunnerRef.current;
+            if (!runner)
+                return messages;
+            return runner.emitContext(messages);
+        },
+        steeringMode: settingsManager.getSteeringMode(),
+        followUpMode: settingsManager.getFollowUpMode(),
+        transport: settingsManager.getTransport(),
+        thinkingBudgets: settingsManager.getThinkingBudgets(),
+        maxRetryDelayMs: settingsManager.getRetrySettings().maxDelayMs,
+        getApiKey: async (provider) => {
+            // Use the provider argument from the in-flight request;
+            // agent.state.model may already be switched mid-turn.
+            const resolvedProvider = provider || agent.state.model?.provider;
+            if (!resolvedProvider) {
+                throw new LoginRequiredError();
+            }
+            const key = await modelRegistry.getApiKeyForProvider(resolvedProvider);
+            if (!key) {
+                throw new LoginRequiredError();
+            }
+            return key;
+        }
+    });
+    // Restore messages if session has existing data
+    if (hasExistingSession) {
+        agent.replaceMessages(existingSession.messages);
+        if (!hasThinkingEntry) {
+            sessionManager.appendThinkingLevelChange(thinkingLevel);
+        }
+    }
+    else {
+        // Save initial model and thinking level for new sessions so they can be restored on resume
+        if (model) {
+            sessionManager.appendModelChange(model.provider, model.id);
+        }
+        sessionManager.appendThinkingLevelChange(thinkingLevel);
+    }
+    const session = new AgentSession({
+        agent: agent, // SHORTCUT PATCH: vendored Agent class (structurally identical, TS private mismatch)
+        sessionManager,
+        settingsManager,
+        cwd,
+        resourceLoader,
+        customTools: options.customTools,
+        modelRegistry,
+        initialActiveToolNames,
+        extensionRunnerRef,
+        prePromptContext: options.prePromptContext
+    });
+    const extensionsResult = resourceLoader.getExtensions();
+    return {
+        session,
+        extensionsResult,
+        modelFallbackMessage
+    };
+}
+//# sourceMappingURL=sdk.js.map

package/dist/core/session-bash.js

@@ -0,0 +1,99 @@
+/**
+ * Bash execution state management.
+ *
+ * Extracted from AgentSession. Manages:
+ * - Command execution with abort support
+ * - Shell command prefix resolution
+ * - Deferred message queueing during streaming
+ *
+ * The actual bash execution lives in bash-executor.ts.
+ * This module owns the state and queueing logic.
+ */
+import { executeBash as executeBashCommand, executeBashWithOperations } from './bash-executor.js';
+// ============================================================================
+// Pure helpers
+// ============================================================================
+/** Prepend shell command prefix to a command if configured. */
+export function resolveCommand(command, prefix) {
+    return prefix ? `${prefix}\n${command}` : command;
+}
+/** Build a BashExecutionMessage from command + result. */
+export function buildBashMessage(command, result, options) {
+    return {
+        role: 'bashExecution',
+        command,
+        output: result.output,
+        exitCode: result.exitCode,
+        cancelled: result.cancelled,
+        truncated: result.truncated,
+        fullOutputPath: result.fullOutputPath,
+        timestamp: Date.now(),
+        excludeFromContext: options?.excludeFromContext
+    };
+}
+// ============================================================================
+// State Machine
+// ============================================================================
+export class SessionBash {
+    _abortController = undefined;
+    _pendingMessages = [];
+    get isRunning() {
+        return this._abortController !== undefined;
+    }
+    get hasPendingMessages() {
+        return this._pendingMessages.length > 0;
+    }
+    /**
+     * Execute a bash command.
+     * Records result via actions (immediately or deferred if streaming).
+     */
+    async execute(command, actions, onChunk, options) {
+        this._abortController = new AbortController();
+        const resolvedCommand = resolveCommand(command, actions.getShellCommandPrefix());
+        try {
+            const result = options?.operations
+                ? await executeBashWithOperations(resolvedCommand, process.cwd(), options.operations, {
+                    onChunk,
+                    signal: this._abortController.signal
+                })
+                : await executeBashCommand(resolvedCommand, {
+                    onChunk,
+                    signal: this._abortController.signal
+                });
+            this.record(command, result, actions, options);
+            return result;
+        }
+        finally {
+            this._abortController = undefined;
+        }
+    }
+    /**
+     * Record a bash result. If streaming, defers until flush().
+     * Also used by extensions that handle bash execution themselves.
+     */
+    record(command, result, actions, options) {
+        const message = buildBashMessage(command, result, options);
+        if (actions.isStreaming()) {
+            this._pendingMessages.push(message);
+        }
+        else {
+            actions.appendToAgent(message);
+            actions.persistToSession(message);
+        }
+    }
+    /** Flush deferred messages to agent state and session. */
+    flush(actions) {
+        if (this._pendingMessages.length === 0)
+            return;
+        for (const message of this._pendingMessages) {
+            actions.appendToAgent(message);
+            actions.persistToSession(message);
+        }
+        this._pendingMessages = [];
+    }
+    /** Cancel running bash command. */
+    abort() {
+        this._abortController?.abort();
+    }
+}
+//# sourceMappingURL=session-bash.js.map

package/dist/core/session-compaction.js

@@ -0,0 +1,165 @@
+/**
+ * Session compaction logic.
+ *
+ * Extracted from AgentSession to be independently testable.
+ * Handles two compaction triggers:
+ * 1. Overflow: LLM returned context overflow → compact → auto-retry
+ * 2. Threshold: Context over threshold → compact → user continues manually
+ *
+ * The actual LLM summarization lives in compaction/index.ts.
+ * This module owns the decision logic and orchestration.
+ */
+import { isContextOverflow } from '@mariozechner/pi-ai';
+import { calculateContextTokens, compact, prepareCompaction, shouldCompact } from './compaction/index.js';
+import { getLatestCompactionEntry } from './session-manager.js';
+/**
+ * Decide whether compaction is needed based on the last assistant message.
+ * Pure function — no side effects.
+ */
+export function checkCompactionNeeded(message, ctx, skipAbortedCheck) {
+    if (!ctx.settings.enabled)
+        return { action: 'none' };
+    if (skipAbortedCheck && message.stopReason === 'aborted')
+        return { action: 'none' };
+    const contextWindow = ctx.currentModel?.contextWindow ?? 0;
+    const sameModel = ctx.currentModel &&
+        message.provider === ctx.currentModel.provider &&
+        message.model === ctx.currentModel.id;
+    const compactionEntry = getLatestCompactionEntry(ctx.branchEntries);
+    const errorIsFromBeforeCompaction = compactionEntry !== null && message.timestamp < new Date(compactionEntry.timestamp).getTime();
+    if (sameModel && !errorIsFromBeforeCompaction && isContextOverflow(message, contextWindow)) {
+        return { action: 'overflow' };
+    }
+    if (message.stopReason === 'error')
+        return { action: 'none' };
+    const contextTokens = calculateContextTokens(message.usage);
+    if (shouldCompact(contextTokens, contextWindow, ctx.settings)) {
+        return { action: 'threshold' };
+    }
+    return { action: 'none' };
+}
+// ============================================================================
+// Orchestration
+// ============================================================================
+export class SessionCompaction {
+    _manualAbortController = undefined;
+    _autoAbortController = undefined;
+    _listener = undefined;
+    get isCompacting() {
+        return this._manualAbortController !== undefined || this._autoAbortController !== undefined;
+    }
+    /** Set the single event listener (the session facade). */
+    onEvent(listener) {
+        this._listener = listener;
+    }
+    _emit(event) {
+        this._listener?.(event);
+    }
+    abortAll() {
+        this._manualAbortController?.abort();
+        this._autoAbortController?.abort();
+    }
+    /**
+     * Run manual compaction. Caller is responsible for disconnecting/reconnecting the agent.
+     */
+    async runManual(model, apiKey, branchEntries, settings, customInstructions, actions) {
+        if (this.isCompacting)
+            throw new Error('Compaction already in progress');
+        this._manualAbortController = new AbortController();
+        try {
+            const preparation = prepareCompaction(branchEntries, settings);
+            if (!preparation) {
+                const lastEntry = branchEntries[branchEntries.length - 1];
+                throw new Error(lastEntry?.type === 'compaction'
+                    ? 'Already compacted'
+                    : 'Nothing to compact (session too small)');
+            }
+            const result = await this._executeCompaction(preparation, branchEntries, model, apiKey, customInstructions, this._manualAbortController.signal, actions);
+            if (this._manualAbortController.signal.aborted) {
+                throw new Error('Compaction cancelled');
+            }
+            await actions.persistCompaction(result.compactionResult, result.fromExtension);
+            return result.compactionResult;
+        }
+        finally {
+            this._manualAbortController = undefined;
+        }
+    }
+    /**
+     * Run auto-compaction (triggered by overflow or threshold).
+     */
+    async runAuto(reason, willRetry, model, apiKey, branchEntries, settings, actions) {
+        this._emit({ type: 'auto_compaction_start', reason });
+        this._autoAbortController = new AbortController();
+        try {
+            if (!model || !apiKey) {
+                this._emit({
+                    type: 'auto_compaction_end',
+                    result: undefined,
+                    aborted: false,
+                    willRetry: false
+                });
+                return;
+            }
+            const preparation = prepareCompaction(branchEntries, settings);
+            if (!preparation) {
+                this._emit({
+                    type: 'auto_compaction_end',
+                    result: undefined,
+                    aborted: false,
+                    willRetry: false
+                });
+                return;
+            }
+            const result = await this._executeCompaction(preparation, branchEntries, model, apiKey, undefined, this._autoAbortController.signal, actions);
+            if (this._autoAbortController.signal.aborted) {
+                this._emit({
+                    type: 'auto_compaction_end',
+                    result: undefined,
+                    aborted: true,
+                    willRetry: false
+                });
+                return;
+            }
+            await actions.persistCompaction(result.compactionResult, result.fromExtension);
+            this._emit({
+                type: 'auto_compaction_end',
+                result: result.compactionResult,
+                aborted: false,
+                willRetry
+            });
+            if (willRetry) {
+                actions.removeLastAssistantMessage();
+                actions.continueAgent();
+            }
+            else if (actions.hasQueuedMessages()) {
+                actions.continueAgent();
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'compaction failed';
+            this._emit({
+                type: 'auto_compaction_end',
+                result: undefined,
+                aborted: false,
+                willRetry: false,
+                errorMessage: reason === 'overflow'
+                    ? `Context overflow recovery failed: ${errorMessage}`
+                    : `Auto-compaction failed: ${errorMessage}`
+            });
+        }
+        finally {
+            this._autoAbortController = undefined;
+        }
+    }
+    async _executeCompaction(preparation, branchEntries, model, apiKey, customInstructions, signal, actions) {
+        const ext = await actions.tryExtensionCompaction(preparation, branchEntries, customInstructions, signal);
+        if (ext.cancelled)
+            throw new Error('Compaction cancelled');
+        if (ext.result)
+            return { compactionResult: ext.result, fromExtension: true };
+        const compactionResult = await compact(preparation, model, apiKey, customInstructions, signal);
+        return { compactionResult, fromExtension: false };
+    }
+}
+//# sourceMappingURL=session-compaction.js.map