@andorra-labs/code 0.0.0-stage → 0.1.4

package/dist/vendor/engine/runtime/coding-agent/extensions/llama/ui.js

@@ -0,0 +1,415 @@
+import { AndorraContainer, andorraFuzzyFilter, AndorraInput, AndorraSelectList, AndorraSpacer, AndorraText, andorraTruncateToWidth, andorraVisibleWidth, } from "../../../tui/index.js";
+import { AndorraDynamicBorder } from "../../modes/interactive/components/dynamic-border.js";
+import { andorraKeyHint } from "../../modes/interactive/components/keybinding-hints.js";
+const DOWNLOAD_VALUE = "\0download";
+function andorraContextLabel(model) {
+    const context = model.meta?.n_ctx ?? model.meta?.n_ctx_train;
+    if (context)
+        return context >= 1000 ? `${Math.round(context / 1000)}k` : String(context);
+    const args = model.status.args ?? [];
+    for (let index = 0; index < args.length - 1; index++) {
+        if (args[index] !== "--ctx-size" && args[index] !== "-c" && args[index] !== "-ctx")
+            continue;
+        const value = Number(args[index + 1]);
+        if (Number.isFinite(value) && value > 0)
+            return value >= 1000 ? `${Math.round(value / 1000)}k` : String(value);
+    }
+    return undefined;
+}
+function andorraModelDescription(model) {
+    const details = [];
+    const loaded = model.status.value === "loaded" || model.status.value === "sleeping";
+    if (loaded)
+        details.push("loaded");
+    else if (model.status.value !== "unloaded")
+        details.push(model.status.value);
+    const context = loaded ? andorraContextLabel(model) : undefined;
+    if (context)
+        details.push(`${context} context`);
+    return details.join(" · ");
+}
+function andorraSelectTheme(theme) {
+    return {
+        selectedPrefix: (text) => theme.fg("accent", text),
+        selectedText: (text) => theme.fg("accent", text),
+        description: (text) => theme.fg("muted", text),
+        scrollInfo: (text) => theme.fg("dim", text),
+        noMatch: (text) => theme.fg("warning", text),
+    };
+}
+function andorraFrame(theme, title, body, footer) {
+    const container = new AndorraContainer();
+    container.addChild(new AndorraDynamicBorder((text) => theme.fg("accent", text)));
+    container.addChild(new AndorraText(theme.fg("accent", theme.bold(title)), 1, 0));
+    for (const child of body)
+        container.addChild(child);
+    if (footer) {
+        container.addChild(new AndorraSpacer(1));
+        container.addChild(new AndorraText(theme.fg("dim", footer), 1, 0));
+    }
+    container.addChild(new AndorraDynamicBorder((text) => theme.fg("accent", text)));
+    return container;
+}
+function andorraCompactCount(value) {
+    if (value >= 1_000_000)
+        return `${(value / 1_000_000).toFixed(value >= 10_000_000 ? 0 : 1)}M`;
+    if (value >= 1_000)
+        return `${(value / 1_000).toFixed(value >= 100_000 ? 0 : 1)}k`;
+    return String(value);
+}
+class AndorraHuggingFaceSearch extends AndorraContainer {
+    tui;
+    theme;
+    keybindings;
+    search;
+    cache;
+    onSelectModel;
+    input = new AndorraInput();
+    resultsContainer = new AndorraContainer();
+    results = [];
+    filteredResults = [];
+    selectedIndex = 0;
+    query = "";
+    status = "Type at least 2 characters";
+    debounce;
+    request;
+    closed = false;
+    _focused = false;
+    constructor(tui, theme, keybindings, search, cache, onSelectModel) {
+        super();
+        this.tui = tui;
+        this.theme = theme;
+        this.keybindings = keybindings;
+        this.search = search;
+        this.cache = cache;
+        this.onSelectModel = onSelectModel;
+        this.addChild(new AndorraText(theme.fg("dim", "Model name or owner/repository[:quant]"), 1, 0));
+        this.addChild(this.input);
+        this.addChild(new AndorraSpacer(1));
+        this.addChild(this.resultsContainer);
+        this.updateResults();
+    }
+    get focused() {
+        return this._focused;
+    }
+    set focused(value) {
+        this._focused = value;
+        this.input.focused = value;
+    }
+    updateResults() {
+        this.resultsContainer.clear();
+        const maxVisible = 10;
+        const start = Math.max(0, Math.min(this.selectedIndex - Math.floor(maxVisible / 2), this.filteredResults.length - maxVisible));
+        const end = Math.min(start + maxVisible, this.filteredResults.length);
+        for (let index = start; index < end; index++) {
+            const model = this.filteredResults[index];
+            if (!model)
+                continue;
+            const prefix = index === this.selectedIndex ? "→ " : "  ";
+            const details = `${andorraCompactCount(model.downloads)} downloads`;
+            this.resultsContainer.addChild(new AndorraText(index === this.selectedIndex
+                ? this.theme.fg("accent", `${prefix}${model.id}  ${details}`)
+                : `${prefix}${model.id}${this.theme.fg("muted", `  ${details}`)}`, 0, 0));
+        }
+        if (start > 0 || end < this.filteredResults.length) {
+            this.resultsContainer.addChild(new AndorraText(this.theme.fg("dim", `  (${this.selectedIndex + 1}/${this.filteredResults.length})`), 0, 0));
+        }
+        if (this.filteredResults.length === 0) {
+            this.resultsContainer.addChild(new AndorraText(this.theme.fg("dim", `  ${this.status}`), 0, 0));
+        }
+        else if (this.status === "Searching Hugging Face…") {
+            this.resultsContainer.addChild(new AndorraText(this.theme.fg("dim", `  ${this.status}`), 0, 0));
+        }
+        this.tui.requestRender();
+    }
+    filterResults() {
+        if (this.query) {
+            const matches = new Set(andorraFuzzyFilter(this.results, this.query, (model) => model.id).map((model) => model.id));
+            this.filteredResults = this.results.filter((model) => matches.has(model.id));
+        }
+        else {
+            this.filteredResults = this.results;
+        }
+        this.selectedIndex = Math.min(this.selectedIndex, Math.max(0, this.filteredResults.length - 1));
+        this.updateResults();
+    }
+    scheduleSearch() {
+        if (this.debounce)
+            clearTimeout(this.debounce);
+        this.request?.abort();
+        this.request = undefined;
+        if (this.query.length < 2) {
+            this.status = "Type at least 2 characters";
+            this.filterResults();
+            return;
+        }
+        const cached = this.cache.get(this.query.toLowerCase());
+        if (cached) {
+            this.results = cached;
+            this.status = cached.length === 0 ? "No GGUF models found" : "";
+            this.filterResults();
+            return;
+        }
+        this.status = "Searching Hugging Face…";
+        this.filterResults();
+        this.debounce = setTimeout(() => void this.runSearch(this.query), 500);
+    }
+    async runSearch(query) {
+        const request = new AbortController();
+        this.request = request;
+        try {
+            const results = await this.search(query, request.signal);
+            this.cache.set(query.toLowerCase(), results);
+            if (this.closed || request.signal.aborted || this.query !== query)
+                return;
+            this.results = results;
+            this.selectedIndex = 0;
+            this.status = results.length === 0 ? "No GGUF models found" : "";
+            this.filterResults();
+        }
+        catch (error) {
+            if (this.closed || request.signal.aborted || this.query !== query)
+                return;
+            this.results = [];
+            this.status = error instanceof Error ? error.message : String(error);
+            this.filterResults();
+        }
+        finally {
+            if (this.request === request)
+                this.request = undefined;
+        }
+    }
+    close(model) {
+        if (this.closed)
+            return;
+        this.closed = true;
+        if (this.debounce)
+            clearTimeout(this.debounce);
+        this.request?.abort();
+        this.onSelectModel(model);
+    }
+    handleInput(data) {
+        if (this.keybindings.matches(data, "tui.select.up")) {
+            if (this.filteredResults.length > 0) {
+                this.selectedIndex = this.selectedIndex === 0 ? this.filteredResults.length - 1 : this.selectedIndex - 1;
+                this.updateResults();
+            }
+            return;
+        }
+        if (this.keybindings.matches(data, "tui.select.down")) {
+            if (this.filteredResults.length > 0) {
+                this.selectedIndex = this.selectedIndex === this.filteredResults.length - 1 ? 0 : this.selectedIndex + 1;
+                this.updateResults();
+            }
+            return;
+        }
+        if (this.keybindings.matches(data, "tui.select.confirm")) {
+            const exact = /^[^/\s]+\/[^:\s]+(?::[^\s:]+)?$/u.test(this.query) ? this.query : undefined;
+            const selected = exact ?? this.filteredResults[this.selectedIndex]?.id;
+            if (selected)
+                this.close(selected);
+            return;
+        }
+        if (this.keybindings.matches(data, "tui.select.cancel")) {
+            this.close(undefined);
+            return;
+        }
+        this.input.handleInput(data);
+        const query = this.input.getValue().trim();
+        if (query === this.query)
+            return;
+        this.query = query;
+        this.scheduleSearch();
+    }
+}
+class AndorraLlamaView {
+    tui;
+    theme;
+    keybindings;
+    searchCache = new Map();
+    content;
+    inputHandler;
+    inputTarget;
+    progressPromise;
+    progressResolver;
+    showingProgress = false;
+    _focused = false;
+    constructor(tui, theme, keybindings) {
+        this.tui = tui;
+        this.theme = theme;
+        this.keybindings = keybindings;
+        this.content = andorraFrame(theme, "llama.cpp models", [new AndorraText(theme.fg("muted", "Loading…"), 1, 1)]);
+    }
+    get focused() {
+        return this._focused;
+    }
+    set focused(value) {
+        this._focused = value;
+        if (this.inputTarget)
+            this.inputTarget.focused = value;
+    }
+    setContent(content, inputHandler, inputTarget) {
+        if (this.inputTarget)
+            this.inputTarget.focused = false;
+        this.progressPromise = undefined;
+        this.progressResolver = undefined;
+        this.showingProgress = false;
+        this.content = content;
+        this.inputHandler = inputHandler;
+        this.inputTarget = inputTarget;
+        if (this.inputTarget)
+            this.inputTarget.focused = this._focused;
+        this.tui.requestRender();
+    }
+    showModels(serverUrl, models) {
+        const sorted = [...models].sort((left, right) => {
+            const loaded = Number(right.status.value === "loaded") - Number(left.status.value === "loaded");
+            return loaded || left.id.localeCompare(right.id);
+        });
+        const byId = new Map(sorted.map((model) => [model.id, model]));
+        const items = [
+            ...sorted.map((model) => ({
+                value: model.id,
+                label: model.id,
+                description: andorraModelDescription(model),
+            })),
+            { value: DOWNLOAD_VALUE, label: "Download model…", description: "Hugging Face owner/repository[:quant]" },
+        ];
+        return new Promise((resolve) => {
+            const list = new AndorraSelectList(items, Math.min(items.length, 12), andorraSelectTheme(this.theme), {
+                minPrimaryColumnWidth: 36,
+                maxPrimaryColumnWidth: 56,
+            });
+            list.onSelect = (item) => {
+                if (item.value === DOWNLOAD_VALUE)
+                    resolve({ type: "download" });
+                else {
+                    const model = byId.get(item.value);
+                    if (model)
+                        resolve({ type: "model", model });
+                }
+            };
+            list.onCancel = () => resolve({ type: "close" });
+            this.setContent(andorraFrame(this.theme, "llama.cpp models", [new AndorraText(this.theme.fg("dim", serverUrl), 1, 0), new AndorraSpacer(1), list], `${andorraKeyHint("tui.select.confirm", "load/unload/download")} • ${andorraKeyHint("tui.select.cancel", "close")}`), list);
+        });
+    }
+    select(title, options) {
+        return new Promise((resolve) => {
+            const list = new AndorraSelectList(options.map((option) => ({ value: option, label: option })), Math.min(options.length, 12), andorraSelectTheme(this.theme));
+            list.onSelect = (item) => resolve(item.value);
+            list.onCancel = () => resolve(undefined);
+            this.setContent(andorraFrame(this.theme, title, [new AndorraSpacer(1), list], `${andorraKeyHint("tui.select.confirm", "select")} • ${andorraKeyHint("tui.select.cancel", "cancel")}`), list);
+        });
+    }
+    async confirm(title, message) {
+        return (await this.select(`${title}\n${message}`, ["Yes", "No"])) === "Yes";
+    }
+    async connectionError(serverUrl, message) {
+        const choice = await this.select(`llama.cpp unavailable\n${serverUrl}\n\n${message}`, ["Retry", "Close"]);
+        return choice === "Retry" ? "retry" : "close";
+    }
+    searchModels(search) {
+        return new Promise((resolve) => {
+            const component = new AndorraHuggingFaceSearch(this.tui, this.theme, this.keybindings, search, this.searchCache, resolve);
+            this.setContent(andorraFrame(this.theme, "Download model", [new AndorraSpacer(1), component], `${andorraKeyHint("tui.select.confirm", "select")} • ${andorraKeyHint("tui.select.cancel", "back")}`), component, component);
+        });
+    }
+    showStatus(title, message) {
+        this.setContent(andorraFrame(this.theme, title, [new AndorraSpacer(1), new AndorraText(this.theme.fg("muted", message), 1, 0)]));
+    }
+    progress(state) {
+        if (!this.progressPromise) {
+            this.progressPromise = new Promise((resolve) => {
+                this.progressResolver = resolve;
+            });
+        }
+        this.showingProgress = true;
+        this.updateProgress(state);
+        return this.progressPromise;
+    }
+    updateProgress(state) {
+        if (!this.showingProgress)
+            return;
+        const body = [
+            new AndorraText(this.theme.fg("text", state.model), 1, 0),
+            new AndorraSpacer(1),
+            new AndorraText(this.theme.fg("muted", state.message), 1, 0),
+        ];
+        if (state.ratio !== undefined) {
+            const available = 40;
+            const filled = Math.round(Math.max(0, Math.min(1, state.ratio)) * available);
+            body.push(new AndorraText(this.theme.fg("accent", `${"█".repeat(filled)}${"─".repeat(available - filled)} ${Math.round(state.ratio * 100)}%`), 1, 0));
+        }
+        if (state.detail)
+            body.push(new AndorraText(this.theme.fg("dim", state.detail), 1, 0));
+        this.content = andorraFrame(this.theme, state.title, body, andorraKeyHint("tui.select.cancel", "stop"));
+        this.inputHandler = undefined;
+        this.tui.requestRender();
+    }
+    handleInput(data) {
+        if (this.progressResolver && this.keybindings.matches(data, "tui.select.cancel")) {
+            const resolve = this.progressResolver;
+            this.progressPromise = undefined;
+            this.progressResolver = undefined;
+            resolve();
+            return;
+        }
+        this.inputHandler?.handleInput?.(data);
+        this.tui.requestRender();
+    }
+    render(width) {
+        return this.content
+            .render(width)
+            .map((line) => (andorraVisibleWidth(line) > width ? andorraTruncateToWidth(line, width, "") : line));
+    }
+    invalidate() {
+        this.content.invalidate();
+    }
+}
+export async function andorraShowLlamaUi(ctx, run) {
+    await ctx.ui.custom((tui, theme, keybindings, done) => {
+        const view = new AndorraLlamaView(tui, theme, keybindings);
+        void run(view).then(() => done(), (error) => {
+            ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+            done();
+        });
+        return view;
+    });
+}
+export async function andorraRunWithProgress(ui, options) {
+    const controller = new AbortController();
+    const state = { title: options.title, model: options.model, message: options.initialMessage };
+    const settled = options
+        .run(controller.signal, (progress) => {
+        Object.assign(state, progress);
+        ui.updateProgress(state);
+    })
+        .then((value) => ({ ok: true, value }), (error) => ({ ok: false, error }));
+    let completed = false;
+    settled.finally(() => {
+        completed = true;
+    });
+    while (!completed) {
+        const outcome = await Promise.race([
+            settled.then(() => "settled"),
+            ui.progress(state).then(() => "stop"),
+        ]);
+        if (outcome === "settled")
+            break;
+        const stop = await ui.confirm(options.cancelTitle, options.cancelMessage);
+        if (!stop || completed)
+            continue;
+        try {
+            await options.cancel();
+        }
+        finally {
+            controller.abort(new Error("Cancelled"));
+        }
+        await settled;
+        return { cancelled: true };
+    }
+    const result = await settled;
+    if (!result.ok)
+        throw result.error;
+    return { cancelled: false, value: result.value };
+}

package/dist/vendor/engine/runtime/coding-agent/index.d.ts

@@ -0,0 +1,36 @@
+export { type Args, andorraParseArgs } from "./cli/args.js";
+export { CONFIG_DIR_NAME, andorraGetAgentDir, andorraGetDocsPath, andorraGetExamplesPath, andorraGetPackageDir, andorraGetReadmePath, VERSION, } from "./config.js";
+export { AndorraAgentSession, type AgentSessionConfig, type AgentSessionEvent, type AgentSessionEventListener, type ModelCycleResult, type ParsedSkillBlock, type PromptOptions, andorraParseSkillBlock, type SessionStats, } from "./core/agent-session.js";
+export { andorraReadStoredCredential } from "./core/auth-storage.js";
+export type { CacheWarmingDecision, CacheWarmingStatus } from "./core/cache-warmer.js";
+export { type BranchPreparation, type BranchSummaryResult, type CollectEntriesResult, type CompactionResult, type CutPointResult, andorraCalculateContextTokens, andorraCollectEntriesForBranchSummary, andorraCompact, DEFAULT_COMPACTION_SETTINGS, andorraEstimateTokens, type FileOperations, andorraFindCutPoint, andorraFindTurnStartIndex, type GenerateBranchSummaryOptions, andorraGenerateBranchSummary, andorraGenerateSummary, andorraGenerateSummaryWithUsage, andorraGetLastAssistantUsage, andorraPrepareBranchEntries, andorraSerializeConversation, andorraShouldCompact, } from "./core/compaction/index.js";
+export { andorraCreateEventBus, type EventBus, type EventBusController } from "./core/event-bus.js";
+export type { AfterProviderResponseEvent, AgentEndEvent, AgentSettledEvent, AgentStartEvent, AgentToolResult, AgentToolUpdateCallback, AppKeybinding, AutocompleteProviderFactory, BashToolCallEvent, BeforeAgentStartEvent, BeforeAgentStartEventResult, BeforeProviderHeadersEvent, BeforeProviderRequestEvent, BeforeProviderRequestEventResult, BuildSystemPromptOptions, CacheWarmingDecisionEvent, CacheWarmingDecisionEventResult, CompactOptions, ContextEvent, ContextEventResult, ContextUsage, CustomToolCallEvent, EditToolCallEvent, EntryRenderer, EntryRenderOptions, ExecOptions, ExecResult, Extension, ExtensionActions, ExtensionAPI, ExtensionCommandContext, ExtensionCommandContextActions, ExtensionContext, ExtensionContextActions, ExtensionError, ExtensionEvent, ExtensionFactory, ExtensionFlag, ExtensionHandler, ExtensionRuntime, ExtensionShortcut, ExtensionUIContext, ExtensionUIDialogOptions, ExtensionWidgetOptions, FindToolCallEvent, GrepToolCallEvent, InlineExtension, InputEvent, InputEventResult, InputSource, AndorraKeybindingsManager, LoadExtensionsResult, LsToolCallEvent, MarkdownTransformContext, MarkdownTransformer, MessageEndEvent, MessageEndEventResult, MessageRenderer, MessageRenderOptions, MessageStartEvent, MessageUpdateEvent, ModelSelectEvent, ModelSelectSource, NormalizedBuildSystemPromptOptions, PowerShellToolCallEvent, ProjectTrustContext, ProjectTrustEvent, ProjectTrustEventDecision, ProjectTrustEventResult, ProjectTrustHandler, ProviderConfig, ProviderModelConfig, ReadToolCallEvent, RegisteredCommand, RegisteredTool, ResolvedCommand, ResourcesDiscoverEvent, ResourcesDiscoverResult, SessionBeforeCompactEvent, SessionBeforeCompactResult, SessionBeforeForkEvent, SessionBeforeForkResult, SessionBeforeSwitchEvent, SessionBeforeSwitchResult, SessionBeforeTreeEvent, SessionBeforeTreeResult, SessionCompactEvent, SessionCompactFailedEvent, SessionInfoChangedEvent, SessionShutdownEvent, SessionStartEvent, SessionTreeEvent, SlashCommandInfo, SlashCommandSource, SourceInfo, TerminalInputHandler, ThinkingLevelSelectEvent, ToolCallEvent, ToolCallEventResult, ToolDefinition, ToolExecutionEndEvent, ToolExecutionMode, ToolExecutionStartEvent, ToolExecutionUpdateEvent, ToolInfo, ToolRenderResultOptions, ToolResultEvent, ToolResultEventResult, TurnEndEvent, TurnStartEvent, UIPromptEndEvent, UIPromptKind, UIPromptStartEvent, UserBashEvent, UserBashEventResult, WidgetPlacement, WorkingIndicatorOptions, WriteToolCallEvent, } from "./core/extensions/index.js";
+export { andorraCreateExtensionRuntime, andorraDefineTool, andorraDiscoverAndLoadExtensions, AndorraExtensionRunner, andorraIsBashToolResult, andorraIsEditToolResult, andorraIsFindToolResult, andorraIsGrepToolResult, andorraIsLsToolResult, andorraIsPowerShellToolResult, andorraIsReadToolResult, andorraIsToolCallEventType, andorraIsWriteToolResult, andorraWrapRegisteredTool, andorraWrapRegisteredTools, } from "./core/extensions/index.js";
+export type { ReadonlyFooterDataProvider } from "./core/footer-data-provider.js";
+export { andorraConvertToLlm } from "./core/messages.js";
+export { AndorraModelRegistry } from "./core/model-registry.js";
+export { type ModelScopeDiagnostic, type ResolveCliModelResult, type ResolveModelScopeResult, andorraResolveCliModel, andorraResolveModelScopeWithDiagnostics, type ScopedModel, } from "./core/model-resolver.js";
+export { type CreateModelRuntimeOptions, AndorraCredentialSynchronizationError, type CredentialSynchronizationOperation, AndorraModelRuntime, type ModelRuntimeAuthOverrides, } from "./core/model-runtime.js";
+export type { PackageManager, PathMetadata, ProgressCallback, ProgressEvent, ResolvedPaths, ResolvedResource, } from "./core/package-manager.js";
+export { AndorraDefaultPackageManager } from "./core/package-manager.js";
+export type { ResourceCollision, ResourceDiagnostic, ResourceLoader } from "./core/resource-loader.js";
+export { AndorraDefaultResourceLoader, andorraLoadProjectContextFiles } from "./core/resource-loader.js";
+export { AndorraAgentSessionRuntime, type AgentSessionRuntimeDiagnostic, type AgentSessionServices, type CreateAgentSessionFromServicesOptions, type CreateAgentSessionOptions, type CreateAgentSessionResult, type CreateAgentSessionRuntimeFactory, type CreateAgentSessionRuntimeResult, type CreateAgentSessionServicesOptions, andorraCreateAgentSession, andorraCreateAgentSessionFromServices, andorraCreateAgentSessionRuntime, andorraCreateAgentSessionServices, andorraCreateBashTool, andorraCreateCodingTools, andorraCreateEditTool, andorraCreateFindTool, andorraCreateGrepTool, andorraCreateLsTool, andorraCreatePowerShellTool, andorraCreateReadOnlyTools, andorraCreateReadTool, andorraCreateWriteTool, type PromptTemplate, } from "./core/sdk.js";
+export { type BranchSummaryEntry, andorraBuildContextEntries, andorraBuildSessionContext, type CompactionEntry, CURRENT_SESSION_VERSION, type CustomEntry, type CustomMessageEntry, type FileEntry, andorraGetLatestCompactionEntry, type ModelChangeEntry, andorraMigrateSessionEntries, type NewSessionOptions, andorraParseSessionEntries, type SessionContext, type SessionEntry, type SessionEntryBase, type SessionHeader, type SessionInfo, type SessionInfoEntry, AndorraSessionManager, type SessionMessageEntry, type SessionTreeNode, andorraSessionEntryToContextMessages, type ThinkingLevelChangeEntry, } from "./core/session-manager.js";
+export { type CacheWarmingMode, type CompactionModelOverride, type CompactionSettings, type DefaultProjectTrust, type FullscreenExitOutput, type ImageSettings, type PackageSource, type RetrySettings, AndorraSettingsManager, type SettingsManagerCreateOptions, type TuiMode, } from "./core/settings-manager.js";
+export { andorraFormatSkillsForPrompt, type LoadSkillsFromDirOptions, type LoadSkillsResult, andorraLoadSkills, andorraLoadSkillsFromDir, type Skill, type SkillFrontmatter, } from "./core/skills.js";
+export { andorraCreateSyntheticSourceInfo } from "./core/source-info.js";
+export { type EditDiffResult, andorraGenerateDiffString, andorraGenerateUnifiedPatch } from "./core/tools/edit-diff.js";
+export { type BashOperations, type BashSpawnContext, type BashSpawnHook, type BashToolDetails, type BashToolInput, type BashToolOptions, andorraCreateBashToolDefinition, andorraCreateEditToolDefinition, andorraCreateFindToolDefinition, andorraCreateGrepToolDefinition, andorraCreateLocalBashOperations, andorraCreateLocalPowerShellOperations, andorraCreateLsToolDefinition, andorraCreatePowerShellToolDefinition, andorraCreateReadToolDefinition, andorraCreateWriteToolDefinition, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, type EditOperations, type EditToolDetails, type EditToolInput, type EditToolOptions, type FindOperations, type FindToolDetails, type FindToolInput, type FindToolOptions, andorraFormatSize, type GrepOperations, type GrepToolDetails, type GrepToolInput, type GrepToolOptions, type LsOperations, type LsToolDetails, type LsToolInput, type LsToolOptions, type PowerShellOperations, type PowerShellSpawnContext, type PowerShellSpawnHook, type PowerShellToolDetails, type PowerShellToolInput, type PowerShellToolOptions, type ReadOperations, type ReadToolDetails, type ReadToolInput, type ReadToolOptions, type ToolsOptions, type TruncationOptions, type TruncationResult, andorraTruncateHead, andorraTruncateLine, andorraTruncateTail, type WriteOperations, type WriteToolInput, type WriteToolOptions, andorraWithFileMutationQueue, } from "./core/tools/index.js";
+export { andorraHasTrustRequiringProjectResources, type ProjectTrustDecision, AndorraProjectTrustStore, type ProjectTrustStoreEntry, type ProjectTrustUpdate, } from "./core/trust-manager.js";
+export { type MainOptions, andorraMain } from "./main.js";
+export { AndorraInteractiveMode, type InteractiveModeOptions, type JsonAgentSessionEvent, type ModelInfo, type PrintModeOptions, AndorraRpcClient, type RpcClientOptions, type RpcCommand, type RpcEventListener, type RpcExtensionUIRequest, type RpcExtensionUIResponse, type RpcResponse, type RpcSessionState, andorraRunPrintMode, andorraRunRpcMode, } from "./modes/index.js";
+export { AndorraArminComponent, AndorraAssistantMessageComponent, AndorraBashExecutionComponent, AndorraBorderedLoader, AndorraBranchSummaryMessageComponent, AndorraCompactionSummaryMessageComponent, AndorraCustomEditor, type CustomEditorOptions, AndorraCustomMessageComponent, AndorraDynamicBorder, AndorraExtensionEditorComponent, AndorraExtensionInputComponent, AndorraExtensionSelectorComponent, AndorraFooterComponent, andorraKeyHint, andorraKeyText, AndorraLoginDialogComponent, AndorraModelSelectorComponent, AndorraOAuthSelectorComponent, type RenderDiffOptions, andorraRawKeyHint, andorraRenderDiff, AndorraSessionSelectorComponent, type SettingsCallbacks, type SettingsConfig, AndorraSettingsSelectorComponent, AndorraShowImagesSelectorComponent, AndorraSkillInvocationMessageComponent, AndorraThemeSelectorComponent, AndorraThinkingSelectorComponent, AndorraToolExecutionComponent, type ToolExecutionOptions, AndorraTreeSelectorComponent, andorraTruncateToVisualLines, AndorraUserMessageComponent, AndorraUserMessageSelectorComponent, type VisualTruncateResult, } from "./modes/interactive/components/index.js";
+export { andorraGetLanguageFromPath, andorraGetMarkdownTheme, andorraGetSelectListTheme, andorraGetSettingsListTheme, andorraHighlightCode, andorraInitTheme, AndorraTheme, type ThemeColor, } from "./modes/interactive/theme/theme.js";
+export { andorraCopyToClipboard } from "./utils/clipboard.js";
+export { andorraParseFrontmatter, andorraStripFrontmatter } from "./utils/frontmatter.js";
+export { andorraConvertToPng } from "./utils/image-convert.js";
+export { andorraFormatDimensionNote, type ResizedImage, andorraResizeImage } from "./utils/image-resize.js";
+export { andorraDetectSupportedImageMimeTypeFromFile } from "./utils/mime.js";
+export { andorraGetPowerShellConfig, andorraGetShellConfig } from "./utils/shell.js";

package/dist/vendor/engine/runtime/coding-agent/index.js

@@ -0,0 +1,47 @@
+// Core session management
+export { andorraParseArgs } from "./cli/args.js";
+// Config paths
+export { CONFIG_DIR_NAME, andorraGetAgentDir, andorraGetDocsPath, andorraGetExamplesPath, andorraGetPackageDir, andorraGetReadmePath, VERSION, } from "./config.js";
+export { AndorraAgentSession, andorraParseSkillBlock, } from "./core/agent-session.js";
+export { andorraReadStoredCredential } from "./core/auth-storage.js";
+// Compaction
+export { andorraCalculateContextTokens, andorraCollectEntriesForBranchSummary, andorraCompact, DEFAULT_COMPACTION_SETTINGS, andorraEstimateTokens, andorraFindCutPoint, andorraFindTurnStartIndex, andorraGenerateBranchSummary, andorraGenerateSummary, andorraGenerateSummaryWithUsage, andorraGetLastAssistantUsage, andorraPrepareBranchEntries, andorraSerializeConversation, andorraShouldCompact, } from "./core/compaction/index.js";
+export { andorraCreateEventBus } from "./core/event-bus.js";
+export { andorraCreateExtensionRuntime, andorraDefineTool, andorraDiscoverAndLoadExtensions, AndorraExtensionRunner, andorraIsBashToolResult, andorraIsEditToolResult, andorraIsFindToolResult, andorraIsGrepToolResult, andorraIsLsToolResult, andorraIsPowerShellToolResult, andorraIsReadToolResult, andorraIsToolCallEventType, andorraIsWriteToolResult, andorraWrapRegisteredTool, andorraWrapRegisteredTools, } from "./core/extensions/index.js";
+export { andorraConvertToLlm } from "./core/messages.js";
+export { AndorraModelRegistry } from "./core/model-registry.js";
+export { andorraResolveCliModel, andorraResolveModelScopeWithDiagnostics, } from "./core/model-resolver.js";
+export { AndorraCredentialSynchronizationError, AndorraModelRuntime, } from "./core/model-runtime.js";
+export { AndorraDefaultPackageManager } from "./core/package-manager.js";
+export { AndorraDefaultResourceLoader, andorraLoadProjectContextFiles } from "./core/resource-loader.js";
+// SDK for programmatic usage
+export { AndorraAgentSessionRuntime, 
+// Factory
+andorraCreateAgentSession, andorraCreateAgentSessionFromServices, andorraCreateAgentSessionRuntime, andorraCreateAgentSessionServices, andorraCreateBashTool, 
+// Tool factories (for custom cwd)
+andorraCreateCodingTools, andorraCreateEditTool, andorraCreateFindTool, andorraCreateGrepTool, andorraCreateLsTool, andorraCreatePowerShellTool, andorraCreateReadOnlyTools, andorraCreateReadTool, andorraCreateWriteTool, } from "./core/sdk.js";
+export { andorraBuildContextEntries, andorraBuildSessionContext, CURRENT_SESSION_VERSION, andorraGetLatestCompactionEntry, andorraMigrateSessionEntries, andorraParseSessionEntries, AndorraSessionManager, andorraSessionEntryToContextMessages, } from "./core/session-manager.js";
+export { AndorraSettingsManager, } from "./core/settings-manager.js";
+// Skills
+export { andorraFormatSkillsForPrompt, andorraLoadSkills, andorraLoadSkillsFromDir, } from "./core/skills.js";
+export { andorraCreateSyntheticSourceInfo } from "./core/source-info.js";
+export { andorraGenerateDiffString, andorraGenerateUnifiedPatch } from "./core/tools/edit-diff.js";
+// Tools
+export { andorraCreateBashToolDefinition, andorraCreateEditToolDefinition, andorraCreateFindToolDefinition, andorraCreateGrepToolDefinition, andorraCreateLocalBashOperations, andorraCreateLocalPowerShellOperations, andorraCreateLsToolDefinition, andorraCreatePowerShellToolDefinition, andorraCreateReadToolDefinition, andorraCreateWriteToolDefinition, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, andorraFormatSize, andorraTruncateHead, andorraTruncateLine, andorraTruncateTail, andorraWithFileMutationQueue, } from "./core/tools/index.js";
+export { andorraHasTrustRequiringProjectResources, AndorraProjectTrustStore, } from "./core/trust-manager.js";
+// Main entry point
+export { andorraMain } from "./main.js";
+// Run modes for programmatic SDK usage
+export { AndorraInteractiveMode, AndorraRpcClient, andorraRunPrintMode, andorraRunRpcMode, } from "./modes/index.js";
+// UI components for extensions
+export { AndorraArminComponent, AndorraAssistantMessageComponent, AndorraBashExecutionComponent, AndorraBorderedLoader, AndorraBranchSummaryMessageComponent, AndorraCompactionSummaryMessageComponent, AndorraCustomEditor, AndorraCustomMessageComponent, AndorraDynamicBorder, AndorraExtensionEditorComponent, AndorraExtensionInputComponent, AndorraExtensionSelectorComponent, AndorraFooterComponent, andorraKeyHint, andorraKeyText, AndorraLoginDialogComponent, AndorraModelSelectorComponent, AndorraOAuthSelectorComponent, andorraRawKeyHint, andorraRenderDiff, AndorraSessionSelectorComponent, AndorraSettingsSelectorComponent, AndorraShowImagesSelectorComponent, AndorraSkillInvocationMessageComponent, AndorraThemeSelectorComponent, AndorraThinkingSelectorComponent, AndorraToolExecutionComponent, AndorraTreeSelectorComponent, andorraTruncateToVisualLines, AndorraUserMessageComponent, AndorraUserMessageSelectorComponent, } from "./modes/interactive/components/index.js";
+// Theme utilities for custom tools and extensions
+export { andorraGetLanguageFromPath, andorraGetMarkdownTheme, andorraGetSelectListTheme, andorraGetSettingsListTheme, andorraHighlightCode, andorraInitTheme, AndorraTheme, } from "./modes/interactive/theme/theme.js";
+// Clipboard utilities
+export { andorraCopyToClipboard } from "./utils/clipboard.js";
+export { andorraParseFrontmatter, andorraStripFrontmatter } from "./utils/frontmatter.js";
+export { andorraConvertToPng } from "./utils/image-convert.js";
+export { andorraFormatDimensionNote, andorraResizeImage } from "./utils/image-resize.js";
+export { andorraDetectSupportedImageMimeTypeFromFile } from "./utils/mime.js";
+// Shell utilities
+export { andorraGetPowerShellConfig, andorraGetShellConfig } from "./utils/shell.js";

package/dist/vendor/engine/runtime/coding-agent/main.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Main entry point for the coding agent CLI.
+ *
+ * This file handles CLI argument parsing and translates them into
+ * createAgentSession() options. The SDK does the heavy lifting.
+ */
+import { type Args } from "./cli/args.js";
+import type { InlineExtension } from "./core/extensions/types.js";
+import { AndorraSessionManager } from "./core/session-manager.js";
+import { AndorraSettingsManager } from "./core/settings-manager.js";
+export declare function andorraCreateSessionManager(parsed: Args, cwd: string, sessionDir: string | undefined, settingsManager: AndorraSettingsManager): Promise<AndorraSessionManager>;
+export interface MainOptions {
+    extensionFactories?: InlineExtension[];
+}
+export declare function andorraMain(args: string[], options?: MainOptions): Promise<void>;