cssprobe-cli 0.1.0

package/AGENTS.md

@@ -0,0 +1,77 @@
+# AGENTS.md
+
+## Project
+
+`cssprobe-cli` — Runtime CSS probe for layout/scroll/overflow/color/font inspection. Entrypoint: `bin/cssprobe-cli.js` → `require('../dist/index')`.
+Build: `npm run build` (= `tsc` + `esbuild` collector IIFE bundle + `tsx scripts/generate-help.ts`).
+Test: `npm test` (= `tsx --test tests/*.test.ts` — Node.js built-in test runner, 26 tests).
+Dependencies: `playwright-core`, `zod`. Dev: `typescript`, `@types/node`, `tsx`, `esbuild`.
+
+## Architecture
+
+```
+src/
+├── index.ts                   # export { program } from './cli/program'
+├── cli/
+│   ├── program.ts             # Entry: minimist parse → dispatch → engine call
+│   ├── commands.ts            # 10 command definitions — all Zod schemas
+│   ├── command.ts             # declareCommand(), parseCommand() (Zod validation)
+│   ├── output.ts              # TextOutput / JsonOutput strategy pattern
+│   └── minimist.ts            # Arguments parser (forked from playwright-cli)
+├── engine/
+│   ├── types.ts               # Shared types: Snapshot, TreeNode, Finding, Confidence
+│   ├── collector.ts           # Browser-side: DOM traversal, computed styles, declared values
+│   ├── analyzer.ts            # Node-side: pure functions, confidence model, pattern detection
+│   └── renderer.ts            # Markdown / JSON rendering
+├── browser/
+│   └── launcher.ts            # Playwright wrapper: launch, navigate, inject collector, state loading
+└── config/
+    ├── config.ts              # Config loader (CLI → env → ~/.cssprobe-clirc profiles)
+    └── helpGenerator.ts       # Build-time: Zod schemas → dist/help.json
+```
+
+## Key Patterns
+
+- **Three-layer engine**: `collector.ts` (browser, esbuild IIFE) → `analyzer.ts` (Node, pure functions) → `renderer.ts` (Markdown/JSON). Collector only gathers facts; analyzer does inference with confidence; renderer formats output.
+- **Collector bundling**: `collector.ts` is bundled by esbuild as an IIFE (`format: 'iife', globalName: '__cssprobe-cli'`). The launcher injects it via `page.addScriptTag({ content })`, then calls `window.__cssprobe-cli.collect(cfg)`.
+- **Confidence model**: Every `Finding` carries `confidence: 'DEFINITE' | 'INDEFINITE' | 'UNVERIFIABLE'`. Computed values = DEFINITE. Percent declarations = INDEFINITE. Missing/blocked declarations = UNVERIFIABLE.
+- **Command definition**: `declareCommand({ name, category, description, args?, options? })` — purely declarative, no execution logic.
+- **Command dispatch**: `minimist` parse → `parseCommand()` Zod validate → `switch(commandName)` → handler function.
+- **Output strategy**: `Output` interface → `TextOutput` (Markdown for inspect, tables for lists) / `JsonOutput` (machine-readable JSON).
+- **Config priority**: CLI flags → env vars → `~/.cssprobe-clirc` profiles. Switch with `-p <profile>`.
+- **State management**: `--state <file>` loads Playwright storage state (cookies + localStorage). `state-import` converts Netscape cookies. `login` does interactive login + save state.
+- **Browser discovery**: `findBrowserExecutable()` scans `~/Library/Caches/ms-playwright/chromium-*` for existing Chrome installations.
+- **Error format**: `Error: <message>` → JSON mode: `{ isError: true, error: "<message>" }` → `process.exit(1)`
+
+## Adding a Command
+
+1. Add `declareCommand({...})` in `src/cli/commands.ts` following the existing pattern
+2. Append to `commandsArray` at the bottom of the file
+3. Add handler in `src/cli/program.ts` (switch case or dedicated function)
+4. Run `npm run build` to regenerate `help.json` and recompile
+5. Run `npm test` to verify
+
+## Build Pipeline
+
+```
+npm run build
+├── 1. tsc                    # Compile TS → dist/ (includes .d.ts)
+├── 2. esbuild collector.ts   # Bundle browser-side code → dist/collector-bundle.js (IIFE)
+└── 3. tsx generate-help.ts   # Zod schemas → dist/help.json
+```
+
+The collector bundle is a self-contained IIFE that exposes `window.__cssprobe-cli.collect(cfg)`. It runs entirely in the browser context — no Node imports.
+
+## What Makes This Different from dom-report
+
+| | dom-report (old) | cssprobe-cli (new) |
+|---|---|---|
+| Architecture | Browser-side template string (collect + analyze + render mixed) | Three-layer: collector (IIFE) → analyzer (pure) → renderer |
+| Dead code | collector.ts 459 lines never imported | Single implementation, no dead code |
+| Confidence | None — all findings treated equally | DEFINITE / INDEFINITE / UNVERIFIABLE per finding |
+| Output | Single markdown string | Markdown (default) / JSON (--json) |
+| Config | `window.__DOM_REPORT_CFG` global + eval two-step | CLI flags → env → rc file, one command |
+| ROOT_SELECTOR | Manual or eval probe | `--auto-root` auto-detection |
+| Tests | None | 26 unit tests (command, analyzer, output) |
+| Build | Regex stripping CJS module.exports | esbuild IIFE bundle, clean build |
+| Auth | None | `--state`, `login`, `state-import` |

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 strikingly
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,218 @@
+# cssprobe-cli
+
+Runtime CSS probe — inspect layout, scroll, colors, backgrounds, fonts and more in a live browser. Built for both humans and AI agents.
+
+## Installation
+
+### For Humans
+
+```bash
+npm install -g cssprobe-cli
+```
+
+### For LLM Agents
+
+```bash
+cssprobe-cli skill-install
+```
+
+---
+
+## Quick Start
+
+### 1. Inspect a Page
+
+```bash
+# With explicit selector
+cssprobe-cli inspect https://example.com ".main-content"
+
+# Auto-detect root element
+cssprobe-cli inspect https://example.com
+
+# Local HTML file
+cssprobe-cli inspect ./test.html ".container"
+```
+
+### 2. Login-Protected Pages
+
+```bash
+# Import cookies from browser export (Netscape format)
+cssprobe-cli state-import cookies.txt --out ~/.cssprobe-cli/states/mysite.json
+
+# Or interactive login
+cssprobe-cli login https://mysite.com
+
+# Then inspect with state
+cssprobe-cli inspect https://mysite.com/page ".target" --state ~/.cssprobe-cli/states/mysite.json
+```
+
+### 3. JSON Output
+
+```bash
+cssprobe-cli inspect https://example.com ".content" --json
+cssprobe-cli --json inspect https://example.com ".content" | jq '.findings[] | {id, confidence, message}'
+```
+
+---
+
+## Output Modes
+
+| Flag | Output | Use Case |
+|------|--------|----------|
+| (default) | Markdown report with ancestor chain, DOM tree, findings | Terminal viewing |
+| `--json` | Structured JSON with snapshot, findings, confidence summary | Scripts, `jq` pipes, AI agent consumption |
+
+---
+
+## Commands
+
+### Inspection
+
+```bash
+cssprobe-cli inspect <url> [selector]    # Inspect CSS layout
+cssprobe-cli login <url>                 # Interactive login, save state
+cssprobe-cli state-import [file]         # Import cookies from Netscape format
+```
+
+### Configuration
+
+```bash
+cssprobe-cli config-show                 # Show current config
+cssprobe-cli config-set <key> <value>    # Set config value
+cssprobe-cli config-list                 # List all profiles
+cssprobe-cli config-use <name>           # Switch active profile
+cssprobe-cli config-new <name>           # Create new profile
+cssprobe-cli config-path                 # Show config file path
+```
+
+---
+
+## inspect Options
+
+```bash
+cssprobe-cli inspect <url> [selector] [options]
+
+Arguments:
+  <url>                       URL, file:// path, or local HTML file
+  [selector]                  CSS selector for root (auto-detected if omitted)
+
+Options:
+  --json                      Output structured JSON
+  --headed                    Show browser window
+  --browser <engine>          chromium|firefox|webkit (default chromium)
+  --zoom                      Run 1x/0.5x viewport diagnosis
+  --depth <n>                 DOM tree depth (default 6)
+  --max-nodes <n>             Node count cap (default 60)
+  --up-to <tag>               Ancestor stop tag (default html)
+  --state <file>              Load saved state (cookies + localStorage)
+```
+
+---
+
+## state-import
+
+Import cookies from Netscape format (browser export standard) into a Playwright state file.
+
+```bash
+# From file
+cssprobe-cli state-import cookies.txt --out mystate.json
+
+# From stdin
+cat cookies.txt | cssprobe-cli state-import --out mystate.json
+
+# Merge into existing state
+cssprobe-cli state-import new-cookies.txt --merge existing.json --out merged.json
+```
+
+Netscape format (tab-separated):
+```
+.example.com	TRUE	/	TRUE	1813025057	session_id	abc123
+.example.com	TRUE	/	FALSE	-1	lang	zh-CN
+```
+
+---
+
+## Confidence Model
+
+Every finding carries a confidence level:
+
+| Level | Meaning |
+|-------|---------|
+| **DEFINITE** | Based on computed values (facts from getComputedStyle) or accessible declared values |
+| **INDEFINITE** | Declared value uses `%` — resolves at runtime |
+| **UNVERIFIABLE** | Declared value missing or from blocked cross-origin stylesheet |
+
+The report header shows: `confidence: DEFINITE 8 | INDEFINITE 0 | UNVERIFIABLE 1`
+
+---
+
+## Configuration
+
+```bash
+# Set values
+cssprobe-cli config-set browser chromium
+cssprobe-cli config-set depth 8
+
+# Show current config
+cssprobe-cli config-show
+
+# Profile management
+cssprobe-cli config-new staging
+cssprobe-cli -p staging config-set browser firefox
+cssprobe-cli config-use staging
+cssprobe-cli config-list
+```
+
+Priority: CLI flags > Environment variables > Config file
+
+```
+--browser       CSSPROBE_BROWSER
+--depth         CSSPROBE_DEPTH
+--headed        CSSPROBE_HEADED
+-p, --profile   CSSPROBE_PROFILE
+```
+
+Config file: `~/.cssprobe-clirc`
+
+---
+
+## Agent Skill
+
+```bash
+# Install skill for all detected agents
+cssprobe-cli skill-install
+
+# Install for a specific agent
+cssprobe-cli skill-install --target opencode
+cssprobe-cli skill-install --target claude
+
+# Remove installed skills
+cssprobe-cli skill-uninstall
+```
+
+---
+
+## Global Options
+
+```
+--json              Output as JSON (default: Markdown)
+--raw               Output raw result without formatting
+--help [command]    Show help for a command or global
+--version           Show version
+-p, --profile       Use named config profile
+```
+
+---
+
+## Development
+
+```bash
+npm install
+npm run build       # tsc + esbuild collector bundle + generate help.json
+npm test            # Run unit tests
+npx tsc --noEmit    # Type check only
+```
+
+## License
+
+MIT

package/bin/cssprobe-cli.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+const { program } = require('../dist/index');
+program().catch(e => {
+  console.error(e.message);
+  process.exit(1);
+});

package/dist/browser/launcher.d.ts

@@ -0,0 +1,25 @@
+import type { Snapshot, CollectConfig } from '../engine/types';
+export interface LauncherOptions {
+    browser?: string;
+    headed?: boolean;
+    /** Path to a Playwright storage state file (cookies + localStorage). */
+    state?: string;
+}
+export declare class BrowserLauncher {
+    private options;
+    private browser;
+    private context;
+    private page;
+    constructor(options?: LauncherOptions);
+    open(url: string): Promise<void>;
+    collect(cfg: CollectConfig): Promise<Snapshot>;
+    /** Scan the page for likely root elements (modals, dialogs, scroll containers). */
+    autoDetectRoot(): Promise<string[]>;
+    /**
+     * Interactive login flow: opens browser in headed mode, navigates to URL,
+     * waits for user to complete login, then saves storage state.
+     * Returns the path to the saved state file.
+     */
+    loginAndSave(url: string, statePath: string): Promise<string>;
+    close(): Promise<void>;
+}

package/dist/browser/launcher.js

@@ -0,0 +1,213 @@
+"use strict";
+// Playwright launcher — opens a browser, navigates, injects the collector bundle,
+// and returns a Snapshot. The collector bundle is read from dist/collector-bundle.js.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserLauncher = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const playwright_core_1 = require("playwright-core");
+const COLLECTOR_BUNDLE_PATH = path_1.default.join(__dirname, '..', 'collector-bundle.js');
+let bundleContent = null;
+function loadBundle() {
+    if (bundleContent !== null)
+        return bundleContent;
+    if (!fs_1.default.existsSync(COLLECTOR_BUNDLE_PATH)) {
+        throw new Error(`collector bundle not found at ${COLLECTOR_BUNDLE_PATH}. Run "npm run build" first.`);
+    }
+    bundleContent = fs_1.default.readFileSync(COLLECTOR_BUNDLE_PATH, 'utf-8');
+    return bundleContent;
+}
+/** Try to find an existing browser executable in the Playwright cache. */
+function findBrowserExecutable(engine) {
+    const cacheDir = path_1.default.join(os_1.default.homedir(), 'Library', 'Caches', 'ms-playwright');
+    if (!fs_1.default.existsSync(cacheDir))
+        return null;
+    const platform = process.platform;
+    if (engine === 'chromium') {
+        // Look for chromium-* directories (sorted newest first)
+        const dirs = fs_1.default.readdirSync(cacheDir)
+            .filter(d => d.startsWith('chromium-'))
+            .sort((a, b) => {
+            const na = parseInt(a.split('-')[1]) || 0;
+            const nb = parseInt(b.split('-')[1]) || 0;
+            return nb - na;
+        });
+        for (const dir of dirs) {
+            if (platform === 'darwin') {
+                const app = path_1.default.join(cacheDir, dir, 'chrome-mac-arm64', 'Google Chrome for Testing.app', 'Contents', 'MacOS', 'Google Chrome for Testing');
+                if (fs_1.default.existsSync(app))
+                    return app;
+                const appIntel = path_1.default.join(cacheDir, dir, 'chrome-mac', 'Google Chrome for Testing.app', 'Contents', 'MacOS', 'Google Chrome for Testing');
+                if (fs_1.default.existsSync(appIntel))
+                    return appIntel;
+            }
+            else if (platform === 'linux') {
+                const bin = path_1.default.join(cacheDir, dir, 'chrome-linux', 'chrome');
+                if (fs_1.default.existsSync(bin))
+                    return bin;
+            }
+        }
+    }
+    return null;
+}
+class BrowserLauncher {
+    options;
+    browser = null;
+    context = null;
+    page = null;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async open(url) {
+        const engine = this.options.browser || 'chromium';
+        const factory = engine === 'firefox' ? playwright_core_1.firefox :
+            engine === 'webkit' ? playwright_core_1.webkit :
+                playwright_core_1.chromium;
+        const launchOptions = { headless: !this.options.headed };
+        // Try to find existing browser installation
+        const execPath = findBrowserExecutable(engine);
+        if (execPath) {
+            launchOptions.executablePath = execPath;
+        }
+        this.browser = await factory.launch(launchOptions);
+        // Load saved state if provided
+        const contextOptions = { viewport: { width: 1280, height: 720 } };
+        if (this.options.state && fs_1.default.existsSync(this.options.state)) {
+            contextOptions.storageState = this.options.state;
+        }
+        this.context = await this.browser.newContext(contextOptions);
+        this.page = await this.context.newPage();
+        if (url.startsWith('http://') || url.startsWith('https://')) {
+            await this.page.goto(url, { waitUntil: 'domcontentloaded', timeout: 60000 });
+        }
+        else if (url.startsWith('file://')) {
+            await this.page.goto(url, { waitUntil: 'load', timeout: 30000 });
+        }
+        else {
+            // Treat as local path
+            const resolved = path_1.default.resolve(url);
+            if (!fs_1.default.existsSync(resolved)) {
+                throw new Error(`File not found: ${resolved}`);
+            }
+            await this.page.goto(`file://${resolved}`, { waitUntil: 'load', timeout: 30000 });
+        }
+    }
+    async collect(cfg) {
+        if (!this.page)
+            throw new Error('Browser not opened. Call open() first.');
+        const bundle = loadBundle();
+        await this.page.addScriptTag({ content: bundle });
+        const snapshot = await this.page.evaluate((config) => {
+            return window.__cssprobe_cli.collect(config);
+        }, cfg);
+        return snapshot;
+    }
+    /** Scan the page for likely root elements (modals, dialogs, scroll containers). */
+    async autoDetectRoot() {
+        if (!this.page)
+            throw new Error('Browser not opened. Call open() first.');
+        return this.page.evaluate(() => {
+            const candidates = [];
+            const seen = new Set();
+            function addSelector(sel, score) {
+                if (seen.has(sel))
+                    return;
+                seen.add(sel);
+                candidates.push({ selector: sel, score });
+            }
+            // Modals / dialogs
+            for (const el of Array.from(document.querySelectorAll('.s-kit-modal, [class*="dialog"], [class*="modal"], [class*="popup"]'))) {
+                const cls = (el.getAttribute('class') || '').split(/\s+/).filter(Boolean).join('.');
+                if (cls)
+                    addSelector(`.${cls.split(/\s+/)[0]}`, 10);
+            }
+            // Scroll containers (overflow-y: auto/scroll with content overflow)
+            for (const el of Array.from(document.querySelectorAll('*'))) {
+                const cs = getComputedStyle(el);
+                if ((cs.overflowY === 'auto' || cs.overflowY === 'scroll') &&
+                    el.scrollHeight > el.clientHeight + 1 &&
+                    el.clientHeight > 100) {
+                    const tag = el.tagName.toLowerCase();
+                    const id = el.id ? `#${el.id}` : '';
+                    const cls = (el.getAttribute('class') || '').split(/\s+/).filter(Boolean).slice(0, 2).join('.');
+                    const sel = id || (cls ? `${tag}.${cls}` : tag);
+                    addSelector(sel, 5);
+                }
+            }
+            // Sections with substantial content
+            for (const el of Array.from(document.querySelectorAll('section, [class*="section"], main, [role="main"]'))) {
+                const tag = el.tagName.toLowerCase();
+                const cls = (el.getAttribute('class') || '').split(/\s+/).filter(Boolean).slice(0, 2).join('.');
+                const sel = cls ? `${tag}.${cls}` : tag;
+                addSelector(sel, 3);
+            }
+            return candidates
+                .sort((a, b) => b.score - a.score)
+                .slice(0, 5)
+                .map(c => c.selector);
+        });
+    }
+    /**
+     * Interactive login flow: opens browser in headed mode, navigates to URL,
+     * waits for user to complete login, then saves storage state.
+     * Returns the path to the saved state file.
+     */
+    async loginAndSave(url, statePath) {
+        const engine = this.options.browser || 'chromium';
+        const factory = engine === 'firefox' ? playwright_core_1.firefox :
+            engine === 'webkit' ? playwright_core_1.webkit :
+                playwright_core_1.chromium;
+        const execPath = findBrowserExecutable(engine);
+        const launchOptions = { headless: false };
+        if (execPath)
+            launchOptions.executablePath = execPath;
+        this.browser = await factory.launch(launchOptions);
+        this.context = await this.browser.newContext({ viewport: { width: 1280, height: 720 } });
+        this.page = await this.context.newPage();
+        // Navigate to the target URL
+        if (url.startsWith('http://') || url.startsWith('https://')) {
+            await this.page.goto(url, { waitUntil: 'domcontentloaded', timeout: 60000 });
+        }
+        else {
+            throw new Error('--login only works with http/https URLs');
+        }
+        // Wait for user to complete login (detect URL change or navigation)
+        console.error('');
+        console.error('  Browser opened. Please complete the login manually.');
+        console.error('  The browser will detect when you navigate away from the login page,');
+        console.error('  or you can press Enter here when done.');
+        console.error('');
+        // Wait for either URL change or Enter keypress
+        await Promise.race([
+            this.page.waitForURL('**/*', { timeout: 300000 }).catch(() => { }),
+            new Promise(resolve => {
+                process.stdin.once('data', () => resolve());
+            }),
+        ]);
+        // Small delay to let cookies/localStorage settle
+        await this.page.waitForTimeout(1000);
+        // Save state
+        const resolvedPath = path_1.default.resolve(statePath);
+        const dir = path_1.default.dirname(resolvedPath);
+        if (!fs_1.default.existsSync(dir))
+            fs_1.default.mkdirSync(dir, { recursive: true });
+        await this.context.storageState({ path: resolvedPath });
+        console.error(`  State saved to: ${resolvedPath}`);
+        return resolvedPath;
+    }
+    async close() {
+        if (this.context)
+            await this.context.close().catch(() => { });
+        if (this.browser)
+            await this.browser.close().catch(() => { });
+        this.context = null;
+        this.browser = null;
+        this.page = null;
+    }
+}
+exports.BrowserLauncher = BrowserLauncher;
+//# sourceMappingURL=launcher.js.map

package/dist/cli/command.d.ts

@@ -0,0 +1,27 @@
+import * as z from 'zod';
+import type zodType from 'zod';
+export type Category = 'core' | 'config' | 'skill';
+export interface HelpEntry {
+    help: string;
+    flags: Record<string, 'boolean' | 'string'>;
+    args: string[];
+}
+export interface HelpData {
+    global: string;
+    commands: Record<string, HelpEntry>;
+    booleanOptions: string[];
+}
+export type CommandArgs<Args extends zodType.ZodTypeAny, Options extends zodType.ZodTypeAny> = z.infer<Args> & z.infer<Options>;
+export type CommandSchema<Args extends zodType.ZodTypeAny, Options extends zodType.ZodTypeAny> = {
+    name: string;
+    category: Category;
+    description: string;
+    hidden?: boolean;
+    args?: Args;
+    options?: Options;
+};
+export type AnyCommandSchema = CommandSchema<any, any>;
+export declare function declareCommand<Args extends zodType.ZodTypeAny, Options extends zodType.ZodTypeAny>(command: CommandSchema<Args, Options>): CommandSchema<Args, Options>;
+export declare function parseCommand(command: AnyCommandSchema, args: Record<string, string> & {
+    _: string[];
+}): Record<string, any>;

package/dist/cli/command.js

@@ -0,0 +1,84 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.declareCommand = declareCommand;
+exports.parseCommand = parseCommand;
+const z = __importStar(require("zod"));
+function declareCommand(command) {
+    return command;
+}
+const kEmptyOptions = z.object({});
+const kEmptyArgs = z.object({});
+function parseCommand(command, args) {
+    const optionsObject = { ...args };
+    delete optionsObject['_'];
+    const optionsSchema = (command.options ?? kEmptyOptions).strict();
+    const options = zodParse(optionsSchema, optionsObject, 'option');
+    const argsSchema = (command.args ?? kEmptyArgs).strict();
+    const argNames = [...Object.keys(argsSchema.shape)];
+    const argv = args['_'].slice(1);
+    if (argv.length > argNames.length)
+        throw new Error(`error: too many arguments: expected ${argNames.length}, received ${argv.length}`);
+    const argsObject = {};
+    argNames.forEach((name, index) => (argsObject[name] = argv[index]));
+    const parsedArgs = zodParse(argsSchema, argsObject, 'argument');
+    return { ...parsedArgs, ...options };
+}
+function zodParse(schema, data, type) {
+    try {
+        return schema.parse(data);
+    }
+    catch (e) {
+        throw new Error(e.issues
+            .map((issue) => {
+            const keys = issue.code === 'unrecognized_keys' ? issue.keys : [''];
+            const props = keys.map((key) => [...issue.path, key].filter(Boolean).join('.'));
+            return props.map((prop) => {
+                const label = type === 'option' ? `'--${prop}' option` : `'${prop}' argument`;
+                switch (issue.code) {
+                    case 'invalid_type':
+                        return 'error: ' + label + ': ' + issue.message.replace(/Invalid input:/, '').trim();
+                    case 'unrecognized_keys':
+                        return 'error: unknown ' + label;
+                    default:
+                        return 'error: ' + label + ': ' + issue.message;
+                }
+            });
+        })
+            .flat()
+            .join('\n'));
+    }
+}
+//# sourceMappingURL=command.js.map