shortcutxl 0.2.0

package/dist/utils/tools-manager.js

@@ -0,0 +1,259 @@
+import chalk from 'chalk';
+import { spawnSync } from 'child_process';
+import extractZip from 'extract-zip';
+import { chmodSync, createWriteStream, existsSync, mkdirSync, readdirSync, renameSync, rmSync } from 'fs';
+import { arch, platform } from 'os';
+import { join } from 'path';
+import { Readable } from 'stream';
+import { finished } from 'stream/promises';
+import { APP_NAME, getBinDir } from '../config.js';
+const TOOLS_DIR = getBinDir();
+const NETWORK_TIMEOUT_MS = 10000;
+function isOfflineModeEnabled() {
+    // SHORTCUT PATCH: renamed from PI_OFFLINE
+    const value = process.env.SHORTCUT_OFFLINE;
+    if (!value)
+        return false;
+    return value === '1' || value.toLowerCase() === 'true' || value.toLowerCase() === 'yes';
+}
+const TOOLS = {
+    fd: {
+        name: 'fd',
+        repo: 'sharkdp/fd',
+        binaryName: 'fd',
+        tagPrefix: 'v',
+        getAssetName: (version, plat, architecture) => {
+            if (plat === 'darwin') {
+                const archStr = architecture === 'arm64' ? 'aarch64' : 'x86_64';
+                return `fd-v${version}-${archStr}-apple-darwin.tar.gz`;
+            }
+            else if (plat === 'linux') {
+                const archStr = architecture === 'arm64' ? 'aarch64' : 'x86_64';
+                return `fd-v${version}-${archStr}-unknown-linux-gnu.tar.gz`;
+            }
+            else if (plat === 'win32') {
+                const archStr = architecture === 'arm64' ? 'aarch64' : 'x86_64';
+                return `fd-v${version}-${archStr}-pc-windows-msvc.zip`;
+            }
+            return null;
+        }
+    },
+    rg: {
+        name: 'ripgrep',
+        repo: 'BurntSushi/ripgrep',
+        binaryName: 'rg',
+        tagPrefix: '',
+        getAssetName: (version, plat, architecture) => {
+            if (plat === 'darwin') {
+                const archStr = architecture === 'arm64' ? 'aarch64' : 'x86_64';
+                return `ripgrep-${version}-${archStr}-apple-darwin.tar.gz`;
+            }
+            else if (plat === 'linux') {
+                if (architecture === 'arm64') {
+                    return `ripgrep-${version}-aarch64-unknown-linux-gnu.tar.gz`;
+                }
+                return `ripgrep-${version}-x86_64-unknown-linux-musl.tar.gz`;
+            }
+            else if (plat === 'win32') {
+                const archStr = architecture === 'arm64' ? 'aarch64' : 'x86_64';
+                return `ripgrep-${version}-${archStr}-pc-windows-msvc.zip`;
+            }
+            return null;
+        }
+    }
+};
+// Check if a command exists in PATH by trying to run it
+function commandExists(cmd) {
+    try {
+        const result = spawnSync(cmd, ['--version'], { stdio: 'pipe' });
+        // Check for ENOENT error (command not found)
+        return result.error === undefined || result.error === null;
+    }
+    catch {
+        return false;
+    }
+}
+// Get the path to a tool (system-wide or in our tools dir)
+function getToolPath(tool) {
+    const config = TOOLS[tool];
+    if (!config)
+        return null;
+    // Check our tools directory first
+    const localPath = join(TOOLS_DIR, config.binaryName + (platform() === 'win32' ? '.exe' : ''));
+    if (existsSync(localPath)) {
+        return localPath;
+    }
+    // Check system PATH - if found, just return the command name (it's in PATH)
+    if (commandExists(config.binaryName)) {
+        return config.binaryName;
+    }
+    return null;
+}
+// Fetch latest release version from GitHub
+async function getLatestVersion(repo) {
+    const response = await fetch(`https://api.github.com/repos/${repo}/releases/latest`, {
+        headers: { 'User-Agent': `${APP_NAME}-coding-agent` },
+        signal: AbortSignal.timeout(NETWORK_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+        throw new Error(`GitHub API error: ${response.status}`);
+    }
+    const data = (await response.json());
+    return data.tag_name.replace(/^v/, '');
+}
+// Download a file from URL
+async function downloadFile(url, dest) {
+    const response = await fetch(url, {
+        signal: AbortSignal.timeout(NETWORK_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to download: ${response.status}`);
+    }
+    if (!response.body) {
+        throw new Error('No response body');
+    }
+    const fileStream = createWriteStream(dest);
+    await finished(Readable.fromWeb(response.body).pipe(fileStream));
+}
+function findBinaryRecursively(rootDir, binaryFileName) {
+    const stack = [rootDir];
+    while (stack.length > 0) {
+        const currentDir = stack.pop();
+        if (!currentDir)
+            continue;
+        const entries = readdirSync(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = join(currentDir, entry.name);
+            if (entry.isFile() && entry.name === binaryFileName) {
+                return fullPath;
+            }
+            if (entry.isDirectory()) {
+                stack.push(fullPath);
+            }
+        }
+    }
+    return null;
+}
+// Download and install a tool
+async function downloadTool(tool) {
+    const config = TOOLS[tool];
+    if (!config)
+        throw new Error(`Unknown tool: ${tool}`);
+    const plat = platform();
+    const architecture = arch();
+    // Get latest version
+    const version = await getLatestVersion(config.repo);
+    // Get asset name for this platform
+    const assetName = config.getAssetName(version, plat, architecture);
+    if (!assetName) {
+        throw new Error(`Unsupported platform: ${plat}/${architecture}`);
+    }
+    // Create tools directory
+    mkdirSync(TOOLS_DIR, { recursive: true });
+    const downloadUrl = `https://github.com/${config.repo}/releases/download/${config.tagPrefix}${version}/${assetName}`;
+    const archivePath = join(TOOLS_DIR, assetName);
+    const binaryExt = plat === 'win32' ? '.exe' : '';
+    const binaryPath = join(TOOLS_DIR, config.binaryName + binaryExt);
+    // Download
+    await downloadFile(downloadUrl, archivePath);
+    // Extract into a unique temp directory. fd and rg downloads can run concurrently
+    // during startup, so sharing a fixed directory causes races.
+    const extractDir = join(TOOLS_DIR, `extract_tmp_${config.binaryName}_${process.pid}_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`);
+    mkdirSync(extractDir, { recursive: true });
+    try {
+        if (assetName.endsWith('.tar.gz')) {
+            const extractResult = spawnSync('tar', ['xzf', archivePath, '-C', extractDir], {
+                stdio: 'pipe'
+            });
+            if (extractResult.error || extractResult.status !== 0) {
+                const errMsg = extractResult.error?.message ??
+                    extractResult.stderr?.toString().trim() ??
+                    'unknown error';
+                throw new Error(`Failed to extract ${assetName}: ${errMsg}`);
+            }
+        }
+        else if (assetName.endsWith('.zip')) {
+            await extractZip(archivePath, { dir: extractDir });
+        }
+        else {
+            throw new Error(`Unsupported archive format: ${assetName}`);
+        }
+        // Find the binary in extracted files. Some archives contain files directly
+        // at root, others nest under a versioned subdirectory.
+        const binaryFileName = config.binaryName + binaryExt;
+        const extractedDir = join(extractDir, assetName.replace(/\.(tar\.gz|zip)$/, ''));
+        const extractedBinaryCandidates = [
+            join(extractedDir, binaryFileName),
+            join(extractDir, binaryFileName)
+        ];
+        let extractedBinary = extractedBinaryCandidates.find((candidate) => existsSync(candidate));
+        if (!extractedBinary) {
+            extractedBinary = findBinaryRecursively(extractDir, binaryFileName) ?? undefined;
+        }
+        if (extractedBinary) {
+            renameSync(extractedBinary, binaryPath);
+        }
+        else {
+            throw new Error(`Binary not found in archive: expected ${binaryFileName} under ${extractDir}`);
+        }
+        // Make executable (Unix only)
+        if (plat !== 'win32') {
+            chmodSync(binaryPath, 0o755);
+        }
+    }
+    finally {
+        // Cleanup
+        rmSync(archivePath, { force: true });
+        rmSync(extractDir, { recursive: true, force: true });
+    }
+    return binaryPath;
+}
+// Termux package names for tools
+const TERMUX_PACKAGES = {
+    fd: 'fd',
+    rg: 'ripgrep'
+};
+// Ensure a tool is available, downloading if necessary
+// Returns the path to the tool, or null if unavailable
+export async function ensureTool(tool, silent = false) {
+    const existingPath = getToolPath(tool);
+    if (existingPath) {
+        return existingPath;
+    }
+    const config = TOOLS[tool];
+    if (!config)
+        return undefined;
+    if (isOfflineModeEnabled()) {
+        if (!silent) {
+            console.log(chalk.yellow(`${config.name} not found. Offline mode enabled, skipping download.`));
+        }
+        return undefined;
+    }
+    // On Android/Termux, Linux binaries don't work due to Bionic libc incompatibility.
+    // Users must install via pkg.
+    if (platform() === 'android') {
+        const pkgName = TERMUX_PACKAGES[tool] ?? tool;
+        if (!silent) {
+            console.log(chalk.yellow(`${config.name} not found. Install with: pkg install ${pkgName}`));
+        }
+        return undefined;
+    }
+    // Tool not found - download it
+    if (!silent) {
+        console.log(chalk.dim(`${config.name} not found. Downloading...`));
+    }
+    try {
+        const path = await downloadTool(tool);
+        if (!silent) {
+            console.log(chalk.dim(`${config.name} installed to ${path}`));
+        }
+        return path;
+    }
+    catch (e) {
+        if (!silent) {
+            console.log(chalk.yellow(`Failed to download ${config.name}: ${e instanceof Error ? e.message : e}`));
+        }
+        return undefined;
+    }
+}
+//# sourceMappingURL=tools-manager.js.map

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "shortcutxl",
+  "version": "0.2.0",
+  "type": "module",
+  "files": [
+    "dist/",
+    "!dist/**/*.map",
+    "!dist/**/*.d.ts",
+    "!dist/**/*.d.ts.map",
+    "!dist/test-helpers/",
+    "skills/",
+    "agent-docs/",
+    "xll/"
+  ],
+  "shortcutConfig": {
+    "name": "shortcut",
+    "configDir": ".shortcut"
+  },
+  "bin": {
+    "shortcut": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc && npm run copy-assets",
+    "sync-modules": "cp -r ../modules/shortcut_xl/*.py xll/modules/shortcut_xl/",
+    "copy-assets": "npm run sync-modules && cp -r src/tui dist/tui && cp src/modes/interactive/theme/*.json dist/modes/interactive/theme/ && cp src/core/export-html/*.{html,css,js} dist/core/export-html/ && cp src/core/export-html/vendor/*.js dist/core/export-html/vendor/",
+    "test-install": "npm uninstall -g shortcutxl & npm run build && npm pack && node -e \"const g=require('glob').globSync('shortcutxl-*.tgz')[0];require('child_process').execSync('npm install -g '+g,{stdio:'inherit'});require('fs').unlinkSync(g)\"",
+    "test-uninstall": "npm uninstall -g shortcutxl",
+    "dev": "tsx src/cli.ts",
+    "start": "node dist/cli.js",
+    "lint": "eslint src/",
+    "check-types": "tsc --noEmit",
+    "format": "prettier --write 'src/**/*.{ts,tsx,js,json}'",
+    "format:check": "prettier --check 'src/**/*.{ts,tsx,js,json}'",
+    "test": "vitest --run",
+    "test:e2e": "vitest --run --config vitest.e2e.config.ts",
+    "test:watch": "vitest",
+    "knip": "knip"
+  },
+  "dependencies": {
+    "@mariozechner/jiti": "^2.6.5",
+    "@mariozechner/pi-agent-core": "^0.55.4",
+    "@mariozechner/pi-ai": "^0.55.4",
+    "@silvia-odwyer/photon-node": "^0.3.4",
+    "@sinclair/typebox": "^0.34.41",
+    "chalk": "^5.6.2",
+    "cli-highlight": "^2.1.11",
+    "croner": "^10.0.1",
+    "diff": "^8.0.3",
+    "ajv": "^8.17.1",
+    "dotenv": "^17.3.1",
+    "extract-zip": "^2.0.1",
+    "file-type": "^21.3.1",
+    "glob": "^13.0.6",
+    "hosted-git-info": "^9.0.2",
+    "ignore": "^7.0.5",
+    "marked": "^15.0.12",
+    "minimatch": "^10.2.4",
+    "proper-lockfile": "^4.1.2",
+    "strip-ansi": "^7.2.0",
+    "yaml": "^2.8.2"
+  },
+  "devDependencies": {
+    "@types/hosted-git-info": "^3.0.5",
+    "@types/node": "^22.0.0",
+    "@types/proper-lockfile": "^4.1.4",
+    "@typescript-eslint/eslint-plugin": "^8.56.1",
+    "@typescript-eslint/parser": "^8.56.1",
+    "eslint": "^9.39.3",
+    "knip": "^5.85.0",
+    "prettier": "^3.8.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.7.3",
+    "vitest": "^3.2.4"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}

package/skills/excel-com-api/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: excel-com-api
+description: Excel COM object model reference for win32com/pywin32. Use when you need to look up Excel COM properties, methods, enums, or constants for automation via Python. Covers Application, Workbook, Worksheet, Range, Chart, PivotTable, Shape, formatting, and all xl* constants.
+---
+
+# Excel COM API via win32com (pywin32)
+
+`app = xl_app()` returns `win32com.client.CDispatch` wrapping `Excel.Application`. The full VBA/COM object model is available — every property, method, and event. Nothing is neutered.
+
+## Type Libraries
+
+Two auto-generated type stubs from the actual Excel type library (`EXCEL.EXE`) via [pyxll/exceltypes](https://github.com/pyxll/exceltypes). These are `typing.Protocol` classes with full method signatures, return types, and enum definitions.
+
+- **`excel-type-library.py`** (~27,800 lines) — Microsoft Excel 16.0 Object Library. All Excel classes: Application, Workbook, Worksheet, Range, Chart, PivotTable, Shape, Style, etc. Plus all `Xl*` enums (XlChartType, XlFileFormat, XlBorderWeight, etc.) and the master `Constants` enum.
+
+- **`office-type-library.py`** (~10,900 lines) — Microsoft Office 16.0 Object Library. Shared Office types: CommandBar, Shape (Office-level), FileDialog, DocumentProperties, Ribbon/IRibbonUI, plus all `Mso*` enums (MsoAutoShapeType, MsoThemeColor, etc.).
+
+## Searching the API
+
+```bash
+# Find a class and its methods
+grep -n "class Range" excel-type-library.py
+grep -n "class Range" excel-type-library.py -A 200 | head -100
+
+# Search for method/property names
+grep -n "def AutoFilter\|def Sort\|def Find" excel-type-library.py
+
+# Find enums and their values
+grep -n "^class Xl" excel-type-library.py | head -50
+grep -n "class XlChartType" excel-type-library.py -A 60
+
+# Search for constants by name
+grep -in "xlUp\|xlDown\|xlToLeft\|xlToRight" excel-type-library.py
+
+# Find all properties on a class (properties are defined as methods with @property)
+grep -n "class _Worksheet" excel-type-library.py -A 500 | grep "def \|@property" | head -80
+
+# Search Office shared types (shapes, command bars, etc.)
+grep -n "class CommandBar\|class Shape" office-type-library.py
+```
+
+## Key Classes (line references for excel-type-library.py)
+
+Use `grep -n "class ClassName"` to find exact locations. Key Protocol classes:
+
+- `_Application` — app-level settings, calculation, display, macros
+- `_Workbook` — workbook operations, save, protect, connections
+- `_Worksheet` — sheet operations, ranges, charts, pivot tables
+- `Range` — cell operations, values, formulas, formatting, find/replace
+- `_Chart` — chart type, series, axes, title, legend, export
+- `PivotTable` — pivot cache, fields, calculated fields, refresh
+- `ListObject` — structured tables, columns, rows, totals
+- `Shape` — shapes, images, text frames, fills, lines
+- `Style` — named styles, font, borders, interior
+- `FormatCondition` — conditional formatting rules
+- `Validation` — data validation rules
+- `Comment` / `CommentThreaded` — cell comments
+- `AutoFilter` — column filters
+- `PageSetup` — print settings, margins, headers/footers
+- `Name` — named ranges and formulas
+- `Hyperlink` — cell hyperlinks
+
+CoClasses (the actual dispatchable COM objects) are at the bottom of the file:
+- `Application(_Application)` — line ~27746
+- `Workbook(_Workbook)` — line ~27762
+- `Worksheet(_Worksheet)` — line ~27766
+
+## Python ↔ COM Notes
+
+- COM collections are **1-based**: `ws.Cells(1,1)` is A1, `wb.Sheets(1)` is first sheet
+- `.Value` returns **tuples of tuples** (0-based): `data[0][0]` is first cell
+- Colors use **BGR order**: `r + (g << 8) + (b << 16)` — NOT RGB
+- Dates come back as `pywintypes.datetime`, not Python `datetime`
+- Constants can be used as raw integers (always works with late binding)