shortcutxl 0.2.19 → 0.2.21

package/dist/core/session/tool-registry.js

@@ -0,0 +1,231 @@
+/**
+ * ToolRegistry — manages tool registration, activation, prompt snippets, and
+ * system prompt rebuilding.
+ *
+ * Stable deps (agent, resourceLoader, cwd) are constructor-injected.
+ * The ExtensionRunner is volatile (recreated on reload) so it's passed only
+ * to refresh().
+ *
+ * Part of the AgentSession API modules (phase 4). Does not reference
+ * AgentSession or any pipeline handler.
+ */
+import { wrapRegisteredTools, wrapToolsWithExtensions } from '../extensions/index.js';
+import { buildSystemPrompt } from '../system-prompt.js';
+// ============================================================================
+// Helpers (pure)
+// ============================================================================
+function normalizePromptSnippet(text) {
+    if (!text)
+        return undefined;
+    const oneLine = text
+        .replace(/[\r\n]+/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    return oneLine.length > 0 ? oneLine : undefined;
+}
+function normalizePromptGuidelines(guidelines) {
+    if (!guidelines || guidelines.length === 0)
+        return [];
+    const unique = new Set();
+    for (const guideline of guidelines) {
+        const normalized = guideline.trim();
+        if (normalized.length > 0)
+            unique.add(normalized);
+    }
+    return Array.from(unique);
+}
+/**
+ * Determine which tools should be active after a registry rebuild.
+ *
+ * Precedence:
+ * 1. explicitNames — caller specifies exact set.
+ * 2. Default — previous active + any tools new to the registry.
+ *
+ * Extension tools are always included by setActiveToolsByName(), so they
+ * don't need special handling here.
+ */
+function resolveNextActiveTools(opts) {
+    if (opts.explicitNames) {
+        return [...new Set(opts.explicitNames)];
+    }
+    const names = [...opts.previousActiveNames];
+    // Auto-activate tools that are new to the registry
+    for (const name of opts.currentRegistryNames) {
+        if (!opts.previousRegistryNames.has(name)) {
+            names.push(name);
+        }
+    }
+    return [...new Set(names)];
+}
+// ============================================================================
+// Registry
+// ============================================================================
+export class ToolRegistry {
+    _agent;
+    _resourceLoader;
+    _cwd;
+    _baseToolRegistry = new Map();
+    _toolRegistry = new Map();
+    _toolPromptSnippets = new Map();
+    _toolPromptGuidelines = new Map();
+    /** Extension tool names — always included in setActiveToolsByName(). */
+    _extensionToolNames = [];
+    /** Current base system prompt (without per-turn extension appends). */
+    _baseSystemPrompt = '';
+    /** Read the current base system prompt. */
+    get baseSystemPrompt() {
+        return this._baseSystemPrompt;
+    }
+    /**
+     * Override the base system prompt directly (bypasses tool-driven rebuild).
+     * Used for mode switching where the prompt is replaced wholesale.
+     */
+    overrideBaseSystemPrompt(prompt) {
+        this._baseSystemPrompt = prompt;
+        this._agent.setSystemPrompt(prompt);
+    }
+    constructor(_agent, _resourceLoader, _cwd) {
+        this._agent = _agent;
+        this._resourceLoader = _resourceLoader;
+        this._cwd = _cwd;
+    }
+    /**
+     * Set the base tool registry (built-in tools from createAllTools).
+     * Called by _buildRuntime in AgentSession.
+     */
+    setBaseTools(tools) {
+        this._baseToolRegistry = new Map(Object.entries(tools).map(([name, tool]) => [name, tool]));
+    }
+    /** Get all registered tools as ToolInfo (name, description, parameters). */
+    getAllTools() {
+        return Array.from(this._toolRegistry.values()).map((t) => ({
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters
+        }));
+    }
+    /** Get names of currently active tools from the agent. */
+    getActiveToolNames() {
+        return this._agent.state.tools.map((t) => t.name);
+    }
+    /**
+     * Set active tools by name. Only tools in the registry can be enabled.
+     * Unknown names are silently ignored. Rebuilds the system prompt.
+     * Extension tools are always included automatically.
+     */
+    setActiveToolsByName(toolNames) {
+        const allNames = [...new Set([...toolNames, ...this._extensionToolNames])];
+        const tools = [];
+        const validToolNames = [];
+        for (const name of allNames) {
+            const tool = this._toolRegistry.get(name);
+            if (tool) {
+                tools.push(tool);
+                validToolNames.push(name);
+            }
+        }
+        this._agent.setTools(tools);
+        this._baseSystemPrompt = this.rebuildSystemPrompt(validToolNames);
+        this._agent.setSystemPrompt(this._baseSystemPrompt);
+    }
+    /**
+     * Rebuild and return a system prompt for the given active tool names.
+     * Collects per-tool prompt snippets and guidelines, merges with resource
+     * loader data, and calls buildSystemPrompt().
+     */
+    rebuildSystemPrompt(toolNames) {
+        const validToolNames = toolNames.filter((name) => this._toolRegistry.has(name));
+        const toolSnippets = {};
+        const promptGuidelines = [];
+        for (const name of validToolNames) {
+            const snippet = this._toolPromptSnippets.get(name);
+            if (snippet)
+                toolSnippets[name] = snippet;
+            const toolGuidelines = this._toolPromptGuidelines.get(name);
+            if (toolGuidelines)
+                promptGuidelines.push(...toolGuidelines);
+        }
+        const loaderSystemPrompt = this._resourceLoader.getSystemPrompt();
+        const loaderAppendSystemPrompt = this._resourceLoader.getAppendSystemPrompt();
+        const appendSystemPrompt = loaderAppendSystemPrompt.length > 0 ? loaderAppendSystemPrompt.join('\n\n') : undefined;
+        const loadedSkills = this._resourceLoader.getSkills().skills;
+        const loadedContextFiles = this._resourceLoader.getAgentsFiles().agentsFiles;
+        return buildSystemPrompt({
+            cwd: this._cwd,
+            skills: loadedSkills,
+            contextFiles: loadedContextFiles,
+            customPrompt: loaderSystemPrompt,
+            appendSystemPrompt,
+            selectedTools: validToolNames,
+            toolSnippets,
+            promptGuidelines
+        });
+    }
+    /**
+     * Refresh the tool registry from base tools + extension-registered tools.
+     * Called after _buildRuntime sets up the ExtensionRunner, and when extensions
+     * register/unregister tools at runtime.
+     *
+     * @param extensionRunner Volatile — pass current runner (may be undefined).
+     * @param customTools Custom tool definitions to register alongside extension tools.
+     * @param activeToolNames Optional explicit set of tool names to activate.
+     */
+    refresh(options) {
+        const { extensionRunner, customTools } = options;
+        const previousRegistryNames = new Set(this._toolRegistry.keys());
+        const previousActiveToolNames = this.getActiveToolNames();
+        const wrappedExtensionTools = this._rebuildRegistry(extensionRunner, customTools);
+        this._extensionToolNames = wrappedExtensionTools.map((t) => t.name);
+        const nextActiveToolNames = resolveNextActiveTools({
+            explicitNames: options.activeToolNames,
+            previousActiveNames: previousActiveToolNames,
+            previousRegistryNames,
+            currentRegistryNames: new Set(this._toolRegistry.keys())
+        });
+        this.setActiveToolsByName(nextActiveToolNames);
+    }
+    // --------------------------------------------------------------------------
+    // Internal
+    // --------------------------------------------------------------------------
+    /**
+     * Rebuild tool maps from base + extension tools. Returns wrapped extension tools
+     * so the caller can use them for activation policy.
+     */
+    _rebuildRegistry(extensionRunner, customTools) {
+        const registeredTools = extensionRunner?.getAllRegisteredTools() ?? [];
+        const allCustomTools = [
+            ...registeredTools,
+            ...customTools.map((def) => ({ definition: def, extensionPath: '<sdk>' }))
+        ];
+        this._toolPromptSnippets = new Map(allCustomTools
+            .map((registeredTool) => {
+            const snippet = normalizePromptSnippet(registeredTool.definition.promptSnippet ?? registeredTool.definition.description);
+            return snippet ? [registeredTool.definition.name, snippet] : undefined;
+        })
+            .filter((entry) => entry !== undefined));
+        this._toolPromptGuidelines = new Map(allCustomTools
+            .map((registeredTool) => {
+            const guidelines = normalizePromptGuidelines(registeredTool.definition.promptGuidelines);
+            return guidelines.length > 0
+                ? [registeredTool.definition.name, guidelines]
+                : undefined;
+        })
+            .filter((entry) => entry !== undefined));
+        const wrappedExtensionTools = extensionRunner
+            ? wrapRegisteredTools(allCustomTools, extensionRunner)
+            : [];
+        const toolRegistry = new Map(this._baseToolRegistry);
+        for (const tool of wrappedExtensionTools) {
+            toolRegistry.set(tool.name, tool);
+        }
+        if (extensionRunner) {
+            const wrappedAllTools = wrapToolsWithExtensions(Array.from(toolRegistry.values()), extensionRunner);
+            this._toolRegistry = new Map(wrappedAllTools.map((tool) => [tool.name, tool]));
+        }
+        else {
+            this._toolRegistry = toolRegistry;
+        }
+        return wrappedExtensionTools;
+    }
+}
+//# sourceMappingURL=tool-registry.js.map

package/dist/core/settings-manager.js

@@ -1,12 +1,12 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
 import { dirname, join } from 'path';
 import lockfile from 'proper-lockfile';
-import { homedir } from 'os';
 import { CONFIG_DIR_NAME, DEFAULT_SANDBOX_NETWORK, getAgentDir } from '../config.js';
 /** Display labels for the approval mode (footer + /settings). */
 export const APPROVAL_MODE = {
     ASK: 'Ask before edits',
-    AUTO: 'Approve all edits',
+    AUTO: 'Approve all edits'
 };
 /** Concrete sandbox defaults — always called at runtime so paths resolve correctly. */
 export function getDefaultSandboxSettings() {
@@ -15,7 +15,7 @@ export function getDefaultSandboxSettings() {
         readPaths: [homedir()],
         writePaths: [getAgentDir()],
         network: DEFAULT_SANDBOX_NETWORK,
-        allowedDomains: [],
+        allowedDomains: []
     };
 }
 /** Deep merge settings: project/overrides take precedence, nested objects merge recursively */
@@ -584,6 +584,14 @@ export class SettingsManager {
     getCodeBlockIndent() {
         return this.settings.markdown?.codeBlockIndent ?? '  ';
     }
+    getNewSheet() {
+        return this.settings.newSheet === true;
+    }
+    setNewSheet(enabled) {
+        this.globalSettings.newSheet = enabled;
+        this.markModified('newSheet');
+        this.save();
+    }
     getSandboxSettings() {
         return this.settings.sandbox ?? {};
     }

package/dist/core/theme.js

@@ -513,7 +513,7 @@ function getDefaultTheme() {
 // Global Theme Instance
 // ============================================================================
 // Use globalThis to share theme across module loaders (tsx + jiti in dev mode)
-const THEME_KEY = Symbol.for('@mariozechner/pi-coding-agent:theme');
+const THEME_KEY = Symbol.for('shortcutxl:theme');
 // Export theme as a getter that reads from globalThis
 // This ensures all module instances (tsx, jiti) see the same theme
 export const theme = new Proxy({}, {

package/dist/core/tools/edit.js

@@ -1,8 +1,8 @@
 import { Type } from '@sinclair/typebox';
 import { constants } from 'fs';
 import { access as fsAccess, readFile as fsReadFile, writeFile as fsWriteFile } from 'fs/promises';
-import { ABORT_AGENT_MESSAGE } from '../abort.js';
 import { EDIT } from '../../tool-names.js';
+import { ABORT_AGENT_MESSAGE } from '../abort.js';
 import { detectLineEnding, fuzzyFindText, generateDiffString, normalizeForFuzzyMatch, normalizeToLF, restoreLineEndings, stripBom } from './edit-diff.js';
 import { resolveToCwd } from './path-utils.js';
 const editSchema = Type.Object({

package/dist/core/tools/find.js

@@ -1,11 +1,11 @@
 import { Type } from '@sinclair/typebox';
 import { spawnSync } from 'child_process';
-import { ABORT_AGENT_MESSAGE } from '../abort.js';
 import { existsSync } from 'fs';
 import { globSync } from 'glob';
 import path from 'path';
 import { FIND } from '../../tool-names.js';
 import { ensureTool } from '../../utils/tools-manager.js';
+import { ABORT_AGENT_MESSAGE } from '../abort.js';
 import { resolveToCwd } from './path-utils.js';
 import { DEFAULT_MAX_CHARS, formatSize, truncateHead } from './truncate.js';
 const findSchema = Type.Object({

package/dist/core/tools/grep.js

@@ -1,11 +1,11 @@
 import { Type } from '@sinclair/typebox';
-import { ABORT_AGENT_MESSAGE } from '../abort.js';
 import { spawn } from 'child_process';
 import { readFileSync, statSync } from 'fs';
 import { createInterface } from 'node:readline';
 import path from 'path';
 import { GREP } from '../../tool-names.js';
 import { ensureTool } from '../../utils/tools-manager.js';
+import { ABORT_AGENT_MESSAGE } from '../abort.js';
 import { resolveToCwd } from './path-utils.js';
 import { DEFAULT_MAX_CHARS, formatSize, GREP_MAX_LINE_LENGTH, truncateHead, truncateLine } from './truncate.js';
 const grepSchema = Type.Object({

package/dist/core/tools/ls.js

@@ -1,8 +1,8 @@
 import { Type } from '@sinclair/typebox';
 import { existsSync, readdirSync, statSync } from 'fs';
 import nodePath from 'path';
-import { ABORT_AGENT_MESSAGE } from '../abort.js';
 import { LS } from '../../tool-names.js';
+import { ABORT_AGENT_MESSAGE } from '../abort.js';
 import { resolveToCwd } from './path-utils.js';
 import { DEFAULT_MAX_CHARS, formatSize, truncateHead } from './truncate.js';
 const lsSchema = Type.Object({

package/dist/core/tools/read.js

@@ -1,10 +1,10 @@
 import { Type } from '@sinclair/typebox';
-import { ABORT_AGENT_MESSAGE } from '../abort.js';
 import { constants } from 'fs';
 import { access as fsAccess, readFile as fsReadFile } from 'fs/promises';
 import { READ } from '../../tool-names.js';
 import { formatDimensionNote, resizeImage } from '../../utils/image-resize.js';
 import { detectSupportedImageMimeTypeFromFile } from '../../utils/mime.js';
+import { ABORT_AGENT_MESSAGE } from '../abort.js';
 import { resolveReadPath } from './path-utils.js';
 import { DEFAULT_MAX_CHARS, formatSize, truncateHead } from './truncate.js';
 const readSchema = Type.Object({

package/dist/core/tools/write.js

@@ -1,8 +1,8 @@
 import { Type } from '@sinclair/typebox';
 import { mkdir as fsMkdir, writeFile as fsWriteFile } from 'fs/promises';
 import { dirname } from 'path';
-import { ABORT_AGENT_MESSAGE } from '../abort.js';
 import { WRITE } from '../../tool-names.js';
+import { ABORT_AGENT_MESSAGE } from '../abort.js';
 import { resolveToCwd } from './path-utils.js';
 const writeSchema = Type.Object({
     path: Type.String({ description: 'Path to the file to write (relative or absolute)' }),

package/dist/custom/dev/index.js

@@ -34,7 +34,22 @@ export function getTraceHooks(session) {
         if (command !== '/trace')
             return false;
         if (lastTracePaths.length === 0) {
-            showStatus('No traces exported yet');
+            // No cached traces — export on demand (e.g. after /resume)
+            showStatus('Exporting traces…');
+            void exportDevTraces(session)
+                .then((paths) => {
+                lastTracePaths = paths;
+                if (paths.length === 0) {
+                    showStatus('No traces to export');
+                    return;
+                }
+                for (const p of paths)
+                    openInBrowser(p);
+                showStatus(`Opened ${paths.length} trace(s) in browser`);
+            })
+                .catch(() => {
+                showStatus('Trace export failed');
+            });
             return true;
         }
         for (const p of lastTracePaths)

package/dist/custom/excel-session.js

@@ -21,7 +21,7 @@ function getSessionFilePath() {
  * Read the XLL session file. Returns { port, token } or null if unavailable.
  * Caches the result — the token is stable for the lifetime of the Excel process.
  */
-export function readXllSession() {
+function readXllSession() {
     if (cachedSession)
         return cachedSession;
     try {
@@ -48,7 +48,7 @@ export function clearXllSessionCache() {
  * Get the Authorization header value for XLL requests, or undefined
  * if no session file is available (falls back to unauthenticated).
  */
-export function getXllAuthHeader() {
+function getXllAuthHeader() {
     const session = readXllSession();
     return session ? `Bearer ${session.token}` : undefined;
 }

package/dist/custom/exec-mode-command.js

@@ -0,0 +1,27 @@
+/**
+ * /exec-mode slash command handler.
+ *
+ * Toggles between COM (Excel desktop) and SHEET (headless Rust engine) modes.
+ * Requires a restart to take effect.
+ */
+import { ExecMode } from '../config.js';
+export async function handleExecModeCommand(showStatus, select, settingsManager) {
+    const current = settingsManager.getExecMode();
+    const labels = {
+        [ExecMode.SHEET]: 'Sheet — headless Rust engine (in-process)',
+        [ExecMode.COM]: 'COM — Excel desktop via HTTP',
+    };
+    const modes = [ExecMode.SHEET, ExecMode.COM];
+    const options = modes.map((m) => m === current ? `${labels[m]} (current)` : labels[m]);
+    options.push('Cancel');
+    const choice = await select('Exec Mode', options);
+    if (!choice || choice === 'Cancel')
+        return true;
+    const selected = modes.find((m) => choice.startsWith(labels[m]));
+    if (selected && selected !== current) {
+        settingsManager.setExecMode(selected);
+        showStatus(`Exec mode set to '${selected}' — restart session to take effect`);
+    }
+    return true;
+}
+//# sourceMappingURL=exec-mode-command.js.map

package/dist/custom/install-utils.js

@@ -48,9 +48,6 @@ export function runPS(script, options) {
  * Handles: backtick, dollar sign, double quote, and null byte.
  */
 export function escapePSString(value) {
-    return value
-        .replace(/`/g, '``')
-        .replace(/\$/g, '`$')
-        .replace(/"/g, '`"');
+    return value.replace(/`/g, '``').replace(/\$/g, '`$').replace(/"/g, '`"');
 }
 //# sourceMappingURL=install-utils.js.map

package/dist/custom/new-sheet/api-guidelines.js

@@ -0,0 +1,83 @@
+/**
+ * Headless sheet engine API guidelines for the agent system prompt.
+ *
+ * Replaces the COM API guidelines when running in sheet mode.
+ * Generated from:
+ *   1. os/docs/generated/api-reference.json  (signatures + docstrings from contracts)
+ *   2. ./api-overlay.ts                       (agent policy: allowlist, tags, overrides)
+ */
+import { WORKBOOK_DOC_OVERRIDES, WORKBOOK_METHODS, WORKBOOK_PATCHES, WORKSHEET_DOC_OVERRIDES, WORKSHEET_METHODS, WORKSHEET_PATCHES } from './api-overlay.js';
+import { loadApiReference } from './api-reference-loader.js';
+// ---------------------------------------------------------------------------
+// Resolve a single method: JSON → patch → doc override
+// ---------------------------------------------------------------------------
+function resolveLine(name, json, patches, docOverrides, overlayDoc) {
+    const gen = json[name];
+    const patch = patches[name];
+    const sig = gen?.signature ?? patch?.signature;
+    if (!sig) {
+        console.warn(`[api-guidelines] "${name}" not in generated JSON or patches`);
+        return null;
+    }
+    const doc = overlayDoc ?? docOverrides[name] ?? gen?.docstring ?? patch?.docstring ?? null;
+    return doc ? `${sig}  // ${doc.split('\n')[0]}` : sig;
+}
+// ---------------------------------------------------------------------------
+// Build the full prompt
+// ---------------------------------------------------------------------------
+function renderSection(title, allowlist, json, patches, docOverrides) {
+    const lines = [`### ${title}`];
+    let currentNs = '';
+    for (const name of Object.keys(allowlist)) {
+        // Group by namespace (e.g. "formats" from "formats.set")
+        const dot = name.indexOf('.');
+        const ns = dot >= 0 ? name.slice(0, dot) : '';
+        if (ns !== currentNs) {
+            currentNs = ns;
+            if (ns)
+                lines.push(`\n${ns}:`);
+        }
+        const line = resolveLine(name, json, patches, docOverrides, allowlist[name].doc);
+        if (line)
+            lines.push(line);
+    }
+    return lines.join('\n');
+}
+export function getSheetApiGuidelines() {
+    const ref = loadApiReference();
+    const wsJson = ref.Worksheet;
+    const wbJson = ref.Workbook;
+    const ws = renderSection('Worksheet API (ws = worksheet)', WORKSHEET_METHODS, wsJson, WORKSHEET_PATCHES, WORKSHEET_DOC_OVERRIDES);
+    const wb = renderSection('Workbook API (wb = workbook)', WORKBOOK_METHODS, wbJson, WORKBOOK_PATCHES, WORKBOOK_DOC_OVERRIDES);
+    return `\
+===========================
+## Spreadsheet API Guidelines
+===========================
+Code runs in a TypeScript sandbox. All methods are async — always use \`await\`.
+Each execution is isolated — variables don't persist between calls.
+But workbooks persist across calls (like Excel staying open).
+
+### Sandbox Globals
+Convenience aliases (point to the most recently opened/created workbook):
+- \`workbook\` — the active Workbook
+- \`worksheet\` — the active Worksheet of that Workbook
+- \`console.log()\` — output captured and returned to you
+- \`getMethodInfo(name)\` — look up API docs for any method not listed below.
+  Pass a namespace to list all methods: \`getMethodInfo("slicers")\`
+  Pass a specific method for its signature: \`getMethodInfo("slicers.add")\`
+  Discoverable namespaces: charts, tables, filters, pivots, conditionalFormats, validation, slicers, sparklines, hyperlinks, outline, protection, print, objects, settings, bindings
+
+Workbook lifecycle:
+- \`createWorkbook(name?)\` — create blank workbook (auto-named "Book1" etc.), returns Workbook
+- \`loadWorkbook(path)\` — load xlsx from disk, returns Workbook. Keyed by basename (e.g. \`loadWorkbook("/tmp/Budget.xlsx")\` → keyed as \`"Budget.xlsx"\`)
+- \`getWorkbook(name)\` — get an already-open workbook by its key (the basename from loadWorkbook, or "Book1" etc. from createWorkbook)
+- \`listWorkbooks()\` — list all open workbook keys
+- \`saveWorkbook(path, wb?)\` — export workbook to xlsx on disk, defaults to active workbook
+- \`closeWorkbook(name)\` — close a workbook and free resources
+
+${wb}
+
+${ws}
+`;
+}
+//# sourceMappingURL=api-guidelines.js.map

package/dist/custom/new-sheet/api-lookup.js

@@ -0,0 +1,69 @@
+/**
+ * Runtime API method lookup for the agent sandbox.
+ *
+ * Loads `agent-docs/api-reference.json` (copied from os/ at build time)
+ * and provides a lookup function the agent can call to discover
+ * Worksheet/Workbook API methods it doesn't see in the system prompt.
+ *
+ * Usage in sandbox:
+ *   getMethodInfo("slicers")        → lists all slicers.* methods
+ *   getMethodInfo("slicers.add")    → signature + docs for that method
+ *   getMethodInfo("setCell")        → signature + docs for ws.setCell
+ */
+import { loadApiReference } from './api-reference-loader.js';
+function ensureLoaded() {
+    const ref = loadApiReference();
+    return { ws: ref.Worksheet, wb: ref.Workbook };
+}
+// ---------------------------------------------------------------------------
+// Lookup
+// ---------------------------------------------------------------------------
+function formatEntry(name, entry, prefix) {
+    const lines = [`// ${prefix}.${name}`];
+    if (entry.docstring)
+        lines.push(`// ${entry.docstring.split('\n')[0]}`);
+    lines.push(entry.signature);
+    return lines.join('\n');
+}
+/**
+ * Look up API method docs. Exposed as a sandbox global.
+ *
+ * - Exact match: getMethodInfo("slicers.add") → that method's docs
+ * - Namespace:   getMethodInfo("slicers")     → all slicers.* methods
+ * - Root method: getMethodInfo("setCell")     → ws.setCell docs
+ */
+export function getMethodInfo(query) {
+    const { ws, wb } = ensureLoaded();
+    // 1. Exact match in either interface
+    const wsHit = ws[query];
+    if (wsHit)
+        return formatEntry(query, wsHit, 'ws');
+    const wbHit = wb[query];
+    if (wbHit)
+        return formatEntry(query, wbHit, 'wb');
+    // 2. Namespace prefix — collect all matching methods
+    const prefix = query.endsWith('.') ? query : query + '.';
+    const matches = [];
+    for (const [name, entry] of Object.entries(ws)) {
+        if (name.startsWith(prefix)) {
+            matches.push(formatEntry(name, entry, 'ws'));
+        }
+    }
+    for (const [name, entry] of Object.entries(wb)) {
+        if (name.startsWith(prefix)) {
+            matches.push(formatEntry(name, entry, 'wb'));
+        }
+    }
+    if (matches.length > 0) {
+        return `${matches.length} method(s) in ${query}:\n\n${matches.join('\n\n')}`;
+    }
+    // 3. List available namespaces as help
+    const namespaces = new Set();
+    for (const name of Object.keys(ws)) {
+        const dot = name.indexOf('.');
+        if (dot >= 0)
+            namespaces.add(name.slice(0, dot));
+    }
+    return `No method "${query}" found. Available namespaces: ${[...namespaces].sort().join(', ')}. Root methods: setCell, getRange, describe, describeRange, summarize, etc.`;
+}
+//# sourceMappingURL=api-lookup.js.map