shortcutxl 0.2.0

package/dist/custom/ensure-excel.js

@@ -0,0 +1,63 @@
+/**
+ * Ensure Excel is running with the ShortcutXL add-in loaded.
+ *
+ * 1. Ping the XLL HTTP server.
+ * 2. If unreachable, launch Excel via COM (no splash screen) and register the XLL.
+ * 3. Wait for the HTTP server to become available.
+ */
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import { getXllPath } from '../config.js';
+import { EXCEL_HTTP_URL } from './constants.js';
+function resolveXllPath() {
+    const candidate = getXllPath();
+    return existsSync(candidate) ? candidate : null;
+}
+async function isXllReachable(url) {
+    try {
+        const res = await fetch(`${url}/ping`, { signal: AbortSignal.timeout(2000) });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+function launchExcelWithXll(xllPath) {
+    const script = [
+        '$xl = New-Object -ComObject Excel.Application',
+        '$xl.Visible = $true',
+        '$xl.Workbooks.Add() | Out-Null',
+        `$xl.RegisterXLL('${xllPath.replace(/'/g, "''")}') | Out-Null`
+    ].join('; ');
+    // Base64-encode the script to avoid all shell quoting issues.
+    const encoded = Buffer.from(script, 'utf16le').toString('base64');
+    execSync(`powershell -NoProfile -EncodedCommand ${encoded}`, {
+        stdio: 'ignore',
+        timeout: 30_000
+    });
+}
+/**
+ * Ensure Excel + XLL are running. Returns true if the HTTP server is reachable
+ * after this call, false if we couldn't start Excel.
+ */
+export async function ensureExcel() {
+    if (await isXllReachable(EXCEL_HTTP_URL))
+        return true;
+    const xllPath = resolveXllPath();
+    if (!xllPath)
+        return false;
+    try {
+        launchExcelWithXll(xllPath);
+    }
+    catch {
+        return false;
+    }
+    // Wait for the HTTP server to come up (XLL init takes a moment)
+    for (let i = 0; i < 15; i++) {
+        await new Promise((r) => setTimeout(r, 1000));
+        if (await isXllReachable(EXCEL_HTTP_URL))
+            return true;
+    }
+    return false;
+}
+//# sourceMappingURL=ensure-excel.js.map

package/dist/custom/excel-config.js

@@ -0,0 +1,36 @@
+/**
+ * Discover ShortcutXL paths by calling GET /config on the XLL's HTTP server.
+ *
+ * Returns { xll_dir, modules_path } or null if Excel isn't running.
+ * Retries a few times on startup since Excel may still be loading the XLL.
+ */
+import { EXCEL_HTTP_URL } from './constants.js';
+/**
+ * Fetch XLL config from the running Excel instance.
+ * Retries up to `maxRetries` times with `intervalMs` between attempts.
+ * Returns null if Excel/XLL is unreachable after all retries.
+ */
+export async function fetchExcelConfig(options) {
+    const maxRetries = options?.maxRetries ?? 5;
+    const intervalMs = options?.intervalMs ?? 2000;
+    const baseUrl = options?.url ?? EXCEL_HTTP_URL;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            const response = await fetch(`${baseUrl}/config`);
+            if (!response.ok)
+                continue;
+            const data = (await response.json());
+            if (data.xll_dir && data.modules_path) {
+                return { xllDir: data.xll_dir, modulesPath: data.modules_path };
+            }
+        }
+        catch {
+            // Connection refused — Excel not running or XLL not loaded yet
+        }
+        if (attempt < maxRetries) {
+            await new Promise((resolve) => setTimeout(resolve, intervalMs));
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=excel-config.js.map

package/dist/custom/preflight.js

@@ -0,0 +1,422 @@
+/**
+ * Deterministic pre-flight setup for ShortcutXL.
+ *
+ * Runs before the TUI starts on first install (!isInstalled()).
+ * Best-effort: installs what it can, the installation agent handles the rest.
+ */
+import chalk from 'chalk';
+import { spawn as cpSpawn, spawnSync } from 'child_process';
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+import { createInterface } from 'readline';
+import { getXllPath } from '../config.js';
+import { resetShellConfig } from '../utils/shell.js';
+import { EXCEL_HTTP_URL } from './constants.js';
+import { fetchExcelConfig } from './excel-config.js';
+import { getStableXllDir } from './sync-xll.js';
+// ── Helpers ──────────────────────────────────────────────────────────────
+function log(msg) {
+    console.log(chalk.cyan('  → ') + msg);
+}
+function ok(msg) {
+    console.log(chalk.green('  ✓ ') + msg);
+}
+function warn(msg) {
+    console.log(chalk.yellow('  ⚠ ') + msg);
+}
+function header(step) {
+    console.log();
+    console.log(chalk.bold.white(`  ${step}`));
+    console.log(chalk.dim('  ' + '─'.repeat(40)));
+}
+/** Prompt user for yes/no confirmation. */
+function promptConfirm(message) {
+    return new Promise((res) => {
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        rl.question(`${chalk.yellow('  ⚠')} ${message} [y/N] `, (answer) => {
+            rl.close();
+            res(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+        });
+    });
+}
+/** Run a command synchronously and return { ok, stdout, stderr }. */
+function run(cmd, options) {
+    try {
+        const result = spawnSync(cmd, {
+            encoding: 'utf-8',
+            timeout: options?.timeout ?? 30_000,
+            shell: true,
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        return {
+            ok: result.status === 0,
+            stdout: (result.stdout ?? '').trim(),
+            stderr: (result.stderr ?? '').trim()
+        };
+    }
+    catch {
+        return { ok: false, stdout: '', stderr: 'command failed' };
+    }
+}
+// ── Progress spinner ────────────────────────────────────────────────────
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+/**
+ * Run a command asynchronously with a live spinner that shows streaming output.
+ * Used for long-running installs (winget, pip) so the user sees progress.
+ */
+function runWithProgress(cmd, options) {
+    const label = options?.label ?? 'Working';
+    const timeout = options?.timeout ?? 120_000;
+    return new Promise((resolve) => {
+        const child = cpSpawn(cmd, { shell: true, stdio: ['ignore', 'pipe', 'pipe'] });
+        let stdout = '';
+        let stderr = '';
+        let lastLine = '';
+        let frame = 0;
+        let done = false;
+        const spinner = setInterval(() => {
+            if (done)
+                return;
+            const icon = chalk.cyan(SPINNER_FRAMES[frame % SPINNER_FRAMES.length]);
+            const status = lastLine
+                ? chalk.dim(lastLine.length > 60 ? lastLine.slice(0, 57) + '...' : lastLine)
+                : '';
+            process.stderr.write(`\r  ${icon} ${label} ${status}\x1b[K`);
+            frame++;
+        }, 80);
+        const timer = setTimeout(() => {
+            child.kill();
+            finish(false);
+        }, timeout);
+        function onData(stream, chunk) {
+            const text = chunk.toString('utf-8');
+            if (stream === 'stdout')
+                stdout += text;
+            else
+                stderr += text;
+            // Extract last non-empty line for status display
+            const lines = text.split(/\r?\n/).filter((l) => l.trim());
+            if (lines.length > 0) {
+                lastLine = lines[lines.length - 1].trim();
+            }
+        }
+        child.stdout?.on('data', (chunk) => onData('stdout', chunk));
+        child.stderr?.on('data', (chunk) => onData('stderr', chunk));
+        function finish(success) {
+            if (done)
+                return;
+            done = true;
+            clearInterval(spinner);
+            clearTimeout(timer);
+            // Clear spinner line
+            process.stderr.write('\r\x1b[K');
+            resolve({ ok: success, stdout: stdout.trim(), stderr: stderr.trim() });
+        }
+        child.on('close', (code) => finish(code === 0));
+        child.on('error', () => finish(false));
+    });
+}
+// ── Step implementations ─────────────────────────────────────────────────
+async function ensureGitBash() {
+    header('Git');
+    const bashCheck = run('bash --version');
+    if (bashCheck.ok) {
+        ok('Installed.');
+        return;
+    }
+    warn('Git Bash not found.');
+    const confirmed = await promptConfirm('Install Git Bash for Windows? ShortcutXL needs this to work on your machine.');
+    if (!confirmed) {
+        warn('Skipped — the setup agent will help.');
+        return;
+    }
+    // Ensure winget is available
+    const wingetCheck = run('winget --version');
+    if (!wingetCheck.ok) {
+        log('Installing package manager...');
+        run('powershell -Command "Add-AppxPackage -RegisterByFamilyName -MainPackage Microsoft.DesktopAppInstaller_8wekyb3d8bbwe"', { timeout: 60_000 });
+        const retry = run('winget --version');
+        if (!retry.ok) {
+            warn('Auto-install failed — the setup agent will help.');
+            return;
+        }
+    }
+    log('Installing Git (you may see a permissions prompt — click Yes)...');
+    const result = await runWithProgress('winget install --id Git.Git -e -h --accept-source-agreements --accept-package-agreements', { timeout: 120_000, label: 'Installing Git' });
+    if (!result.ok && !result.stdout.includes('already installed')) {
+        warn('Install failed — the setup agent will help.');
+        return;
+    }
+    // Reset shell cache so it re-detects bash
+    resetShellConfig();
+    const gitCheck = run('git --version');
+    if (!gitCheck.ok) {
+        warn('Installed but not detected yet — try restarting your terminal.');
+        return;
+    }
+    ok(`Installed.`);
+}
+async function ensurePython() {
+    header('Python');
+    let pythonCmd = null;
+    // Check for Python 3.12 specifically
+    const pyCheck = run('python --version');
+    if (pyCheck.ok && pyCheck.stdout.includes('3.12')) {
+        ok(`${pyCheck.stdout}`);
+        pythonCmd = 'python';
+    }
+    else {
+        // Also check py launcher
+        const pyLauncher = run('py -3.12 --version');
+        if (pyLauncher.ok) {
+            ok(`${pyLauncher.stdout}`);
+            pythonCmd = 'py -3.12';
+        }
+    }
+    if (!pythonCmd) {
+        const confirmed = await promptConfirm('Install Python and register ShortcutXL with Excel? This is needed for it to control Excel.');
+        if (!confirmed) {
+            warn('Skipped — the setup agent will help.');
+            return;
+        }
+        log('Installing Python 3.12...');
+        const result = await runWithProgress('winget install --id Python.Python.3.12 -e -h --accept-source-agreements --accept-package-agreements', { timeout: 120_000, label: 'Installing Python 3.12' });
+        if (!result.ok && !result.stdout.includes('already installed')) {
+            warn('Install failed — the setup agent will help.');
+            return;
+        }
+        // Verify
+        const verify = run('python --version');
+        if (verify.ok && verify.stdout.includes('3.12')) {
+            ok(`${verify.stdout}`);
+            pythonCmd = 'python';
+        }
+        else {
+            const verifyPy = run('py -3.12 --version');
+            if (verifyPy.ok) {
+                ok(`${verifyPy.stdout}`);
+                pythonCmd = 'py -3.12';
+            }
+            else {
+                warn('Installed but not detected yet — try restarting your terminal.');
+                return;
+            }
+        }
+    }
+    // Install pywin32 + openpyxl
+    log('Installing required packages...');
+    const pipResult = await runWithProgress(`${pythonCmd} -m pip install pywin32 openpyxl`, {
+        timeout: 120_000,
+        label: 'Installing packages'
+    });
+    if (pipResult.ok) {
+        ok('Packages installed.');
+    }
+    else {
+        warn('Package install had issues — the setup agent will help.');
+    }
+}
+/** Run a PowerShell script via base64-encoded command. */
+function runPS(script, options) {
+    const encoded = Buffer.from(script, 'utf16le').toString('base64');
+    return run(`powershell -NoProfile -EncodedCommand ${encoded}`, options);
+}
+function ensureXllRegistry() {
+    header('Excel Add-in');
+    const xllPath = resolve(getXllPath()).replace(/\//g, '\\');
+    if (!existsSync(xllPath)) {
+        warn(`Add-in file not found — the setup agent will help.`);
+        return;
+    }
+    // Find Office version and write the OPEN key so Excel loads the XLL on startup.
+    // Creates the Options key if it doesn't exist yet (fresh Office installs).
+    const result = runPS(`
+    $ErrorActionPreference = 'Stop'
+    $xllValue = '/R "${xllPath}"'
+    $versions = @('16.0', '15.0', '14.0')
+    $officeVer = $null
+
+    foreach ($ver in $versions) {
+      $excelKey = "HKCU:\\Software\\Microsoft\\Office\\$ver\\Excel"
+      if (Test-Path $excelKey) { $officeVer = $ver; break }
+    }
+
+    if (-not $officeVer) {
+      Write-Output "NO_OFFICE"
+      exit 0
+    }
+
+    $optionsKey = "HKCU:\\Software\\Microsoft\\Office\\$officeVer\\Excel\\Options"
+
+    if (-not (Test-Path $optionsKey)) {
+      New-Item -Path $optionsKey -Force | Out-Null
+    }
+
+    # Check if already registered
+    $props = Get-ItemProperty -Path $optionsKey -ErrorAction SilentlyContinue
+    if ($props) {
+      foreach ($p in $props.PSObject.Properties) {
+        if ($p.Name -match '^OPEN' -and $p.Value -match 'ShortcutXL') {
+          Write-Output ('ALREADY:' + $officeVer)
+          exit 0
+        }
+      }
+    }
+
+    # Find next available OPEN slot
+    $openKeys = @()
+    if ($props) {
+      $openKeys = @($props.PSObject.Properties | Where-Object { $_.Name -match '^OPEN' } | ForEach-Object { $_.Name })
+    }
+    if ($openKeys.Count -eq 0) {
+      $slot = 'OPEN'
+    } else {
+      $nums = @($openKeys | ForEach-Object { if ($_ -eq 'OPEN') { 0 } else { [int]($_ -replace 'OPEN','') } })
+      $next = ($nums | Measure-Object -Maximum).Maximum + 1
+      $slot = "OPEN$next"
+    }
+
+    New-ItemProperty -Path $optionsKey -Name $slot -Value $xllValue -PropertyType String -Force | Out-Null
+    Write-Output ('REGISTERED:' + $officeVer + ':' + $slot)
+  `);
+    if (result.stdout.includes('ALREADY:')) {
+        ok('Already registered.');
+    }
+    else if (result.stdout.includes('REGISTERED:')) {
+        ok(`Registered with Excel.`);
+    }
+    else if (result.stdout.includes('NO_OFFICE')) {
+        warn('Excel not found — the setup agent will help.');
+    }
+    else {
+        warn(`Registration failed — the setup agent will help.`);
+        if (result.stderr)
+            log(chalk.dim(result.stderr));
+    }
+}
+async function ensureExcelAndXll() {
+    header('Launch Excel');
+    // Check if XLL is already reachable
+    try {
+        const res = await fetch(`${EXCEL_HTTP_URL}/ping`, { signal: AbortSignal.timeout(2000) });
+        if (res.ok) {
+            ok('Excel is running with ShortcutXL.');
+            await verifyXllConfig();
+            return;
+        }
+    }
+    catch {
+        // Not running
+    }
+    // Check if Excel is running without XLL
+    const tasklist = run('tasklist /FI "IMAGENAME eq EXCEL.EXE" /NH');
+    const excelRunning = tasklist.ok && tasklist.stdout.includes('EXCEL.EXE');
+    if (excelRunning) {
+        warn('Excel is running but ShortcutXL is not loaded.');
+        const confirmed = await promptConfirm('Close all Excel instances to reload with ShortcutXL? Unsaved work will be lost.');
+        if (!confirmed) {
+            warn('Skipped — close Excel manually and re-run setup.');
+            return;
+        }
+        log('Closing Excel...');
+        run('taskkill /F /IM EXCEL.EXE', { timeout: 10_000 });
+        await new Promise((r) => setTimeout(r, 2000));
+    }
+    log('Opening Excel...');
+    run('start excel', { timeout: 10_000 });
+    log('Waiting for ShortcutXL to start...');
+    for (let i = 0; i < 10; i++) {
+        await new Promise((r) => setTimeout(r, 1000));
+        try {
+            const res = await fetch(`${EXCEL_HTTP_URL}/ping`, { signal: AbortSignal.timeout(2000) });
+            if (res.ok) {
+                ok('ShortcutXL is ready.');
+                await verifyXllConfig();
+                return;
+            }
+        }
+        catch {
+            // Keep waiting
+        }
+    }
+    warn('ShortcutXL did not start — the setup agent will help.');
+}
+async function verifyXllConfig() {
+    const expectedModulesDir = resolve(getStableXllDir(), 'modules');
+    const config = await fetchExcelConfig({ maxRetries: 2, intervalMs: 1000 });
+    if (!config) {
+        warn('Could not verify add-in config.');
+        return;
+    }
+    const actualModules = resolve(config.modulesPath);
+    if (actualModules !== expectedModulesDir) {
+        warn(`Add-in config mismatch — the setup agent will help.`);
+        return;
+    }
+    ok('Add-in config verified.');
+}
+async function smokeTest() {
+    header('Connection Test');
+    log('Verifying Excel connection...');
+    try {
+        const res = await fetch(`${EXCEL_HTTP_URL}/exec`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                code: 'from shortcut_xl import xl_app\nprint(f"Excel {xl_app().Version}")'
+            }),
+            signal: AbortSignal.timeout(10_000)
+        });
+        if (!res.ok) {
+            warn(`Connection error (${res.status}).`);
+            return false;
+        }
+        const data = (await res.json());
+        if (data.error) {
+            warn(`Connection failed: ${data.error}`);
+            return false;
+        }
+        ok(`${data.output?.trim()}`);
+        return true;
+    }
+    catch (e) {
+        warn(`Connection failed: ${e instanceof Error ? e.message : e}`);
+        return false;
+    }
+}
+// ── Main entry point ─────────────────────────────────────────────────────
+/**
+ * Run deterministic pre-flight checks and auto-install prerequisites.
+ * Best-effort — installs what it can, the installation agent handles the rest.
+ *
+ * Returns true if the smoke test passed (setup fully complete).
+ */
+export async function runPreflight() {
+    console.log();
+    console.log(chalk.bold.white('  Setting up ShortcutXL...'));
+    console.log(chalk.dim('  ' + '─'.repeat(40)));
+    // Git Bash (only needed on Windows when no bash is found)
+    if (process.platform === 'win32') {
+        await ensureGitBash();
+    }
+    // Python 3.12 + pip packages
+    await ensurePython();
+    // Registry key for XLL
+    ensureXllRegistry();
+    // Excel + XLL running
+    await ensureExcelAndXll();
+    // Smoke test — if this passes, everything works
+    const passed = await smokeTest();
+    if (passed) {
+        console.log();
+        ok('Preflight passed! The installation agent will verify everything.');
+        console.log();
+    }
+    else {
+        console.log();
+        warn('Some steps need attention — the setup agent will help.');
+        console.log();
+    }
+    return passed;
+}
+//# sourceMappingURL=preflight.js.map

package/dist/custom/prompts/action.js

@@ -0,0 +1,100 @@
+/**
+ * Action-mode system prompt for the Shortcut agent.
+ *
+ * This is the normal post-installation prompt. Passed as `customPrompt` to
+ * the core buildSystemPrompt(), which automatically appends: project context
+ * files, skills, date/time, and cwd.
+ *
+ * The prompt does NOT embed runtime-discovered paths (xllDir, modulesPath).
+ * Those are shown in the TUI status line. The agent discovers them dynamically
+ * via the health check endpoint or excel_exec.
+ */
+import { join, resolve } from 'path';
+import { getAgentDir, getInstalledMarkerPath, getPackageDir, getSessionsDir } from '../../config.js';
+import { EXCEL_HTTP_URL } from '../constants.js';
+import { EXCEL_COM_API_GUIDELINES } from './api.js';
+import { CODING_GUIDELINES, COMMUNICATION_GUIDELINES, DATA_FORMATTING_GUIDELINES, EXPLORATION_GUIDELINES, NOTES_COMMENTS_GUIDELINES, NUMBER_FORMAT_REFERENCE } from './shared.js';
+// ---------------------------------------------------------------------------
+// Prompt sections — all static content lives here as module-level constants.
+// The function at the bottom only resolves runtime paths and assembles them.
+// ---------------------------------------------------------------------------
+const CORE = `\
+Your name is Shortcut, an expert financial spreadsheet assistant that lives on the user's computer with Excel superpowers
+Deliver professional-grade results with precise calculations, consistent formatting, and proper validation for business professionals
+Avoid over-interpretation and don't be extra. Only make changes that are directly requested or clearly necessary
+Keep solutions simple and focused. For example, don't add extra sheets, reformat untouched areas, or make "improvements" beyond what was asked
+
+## Tools
+excel_exec: use it for all Excel interactions
+- an HTTP server at ${EXCEL_HTTP_URL} is run inside the Excel process. This auto-reloads via the registry when Excel starts
+- health check: curl ${EXCEL_HTTP_URL}/config
+- runs Python embedded inside Excel's process — direct access to the COM API via app
+
+bash: use it for everything else, including python
+- runs a separate Python subprocess
+- write python files in the modules directory to create UDFs (User-Defined Function). See your xll docs for more information
+
+## Debugging HTTP server health
+- if excel_exec or health checks fail, check if Excel is currently running
+- if Excel is not running, we need to run it -- ask the user if they want a specific file open or if you can just open a blank workbook
+- if Excel is running, we need to close the excel process and restart it. Ask the user to save work, close Excel, and then re-open
+- wait a couple seconds to health check
+
+## Extensibility — UDFs vs Skills vs Extensions
+For any extension requests, ask the user which approach fits their need, or recommend one based on context. Prefer skills by default — they're lightweight and don't pollute context
+- UDF: a live Excel formula. Best when: the user wants formulas that recalculates live
+- Skill: md file with instructions the agent reads and follows. Progressively disclosed so it don't overload agent context. Best when the user wants a reusable workflow or procedure.
+- Extension / Custom Tool: a new tool always loaded into the agent, callable in a single step. Reserve for integrations the user calls constantly (e.g. an internal API used daily). Best when the user needs something invoked often and speed matters`;
+const INSTALLATION = (markerPath) => `\
+## Installation
+The installed marker file is at \`${markerPath}\`. If the user needs to re-run installation (e.g. something is broken), delete this file and use switch_mode to switch to "installation" mode`;
+const DOCS = (paths) => `\
+## Key Directories
+- Package directory (shipped code, read-only): ${paths.packageDir}
+- Agent directory (user config, state, XLL binaries): ${paths.agentDir}
+- Sessions (prior conversation JSONL transcripts): ${paths.sessionsDir}
+- Temp directory (dump temporary/scratch files here, e.g. exported Excel files): ${paths.tempDir}
+
+## ShortcutXL Excel Reference
+These docs describe the XLL architecture and how to control Excel:
+- Architecture & two-channel design: ${paths.xllSpec}
+- Agent quick reference (/exec vs modules, hard rules): ${paths.xllSkill}
+
+## Shortcut Agent Documentation
+The agent harness is a coding agent framework.
+Read these for introspection, customization, debugging of Shortcut itself, its SDK, extensions, themes, skills, or TUI:
+- Main documentation: ${paths.readme}
+- Additional docs: ${paths.docs}
+- Examples: ${paths.examples} (extensions, custom tools, SDK)
+- Topics: extensions (docs/extensions.md, examples/extensions/), themes (docs/themes.md), skills (docs/skills.md), prompt templates (docs/prompt-templates.md), TUI (docs/tui.md), keybindings (docs/keybindings.md), SDK (docs/sdk.md), custom providers (docs/custom-provider.md), models (docs/models.md), packages (docs/packages.md)
+- Always read Shortcut .md files completely and follow links to related docs`;
+// ---------------------------------------------------------------------------
+// Assembly — resolves runtime paths, joins sections
+// ---------------------------------------------------------------------------
+export function buildActionPrompt() {
+    const agentDocsDir = resolve(join(getPackageDir(), 'agent-docs'));
+    const installedMarker = getInstalledMarkerPath();
+    return [
+        CORE,
+        EXPLORATION_GUIDELINES,
+        DATA_FORMATTING_GUIDELINES,
+        NUMBER_FORMAT_REFERENCE,
+        NOTES_COMMENTS_GUIDELINES,
+        CODING_GUIDELINES,
+        COMMUNICATION_GUIDELINES,
+        INSTALLATION(installedMarker),
+        DOCS({
+            packageDir: getPackageDir(),
+            agentDir: getAgentDir(),
+            sessionsDir: getSessionsDir(),
+            tempDir: join(getAgentDir(), 'temp'),
+            xllSpec: join(agentDocsDir, 'xll-spec.md'),
+            xllSkill: join(agentDocsDir, 'xll-skill.md'),
+            readme: join(agentDocsDir, 'README.md'),
+            docs: join(agentDocsDir, 'docs'),
+            examples: join(agentDocsDir, 'examples')
+        }),
+        EXCEL_COM_API_GUIDELINES
+    ].join('\n\n');
+}
+//# sourceMappingURL=action.js.map