@vertaaux/cli 0.3.3 → 0.5.0

package/dist/app/menu/categories.js

@@ -0,0 +1,181 @@
+/**
+ * Command category definitions for the interactive menu.
+ *
+ * 6 groups of 24 commands matching Commander.js registrations in index.ts.
+ * Each MenuItem.value must exactly match the Commander command name.
+ */
+/**
+ * All 24 commands organized into 6 semantic groups.
+ *
+ * Groups follow a natural user workflow:
+ *   Audit → Results → Fixes → Reports → Project → Account
+ */
+export const COMMAND_CATEGORIES = [
+    {
+        label: "Audit",
+        items: [
+            {
+                name: "Run Audit",
+                value: "audit",
+                description: "Audit a URL for UX and accessibility issues",
+            },
+            {
+                name: "Quick Scan",
+                value: "scan",
+                description: "Fast page scan without full audit pipeline",
+            },
+            {
+                name: "Accessibility Check",
+                value: "a11y",
+                description: "Run WCAG accessibility checks on a URL",
+            },
+        ],
+    },
+    {
+        label: "Results",
+        items: [
+            {
+                name: "Check Status",
+                value: "status",
+                description: "Check status of a running or completed audit job",
+            },
+            {
+                name: "Show Diff",
+                value: "diff",
+                description: "Compare audit results between two runs",
+            },
+            {
+                name: "Compare Pages",
+                value: "compare",
+                description: "Compare UX scores across multiple pages",
+            },
+            {
+                name: "Triage Issues",
+                value: "triage",
+                description: "Interactive triage of audit findings",
+            },
+            {
+                name: "Explain Issue",
+                value: "explain",
+                description: "Get plain-language explanation of an audit finding",
+            },
+        ],
+    },
+    {
+        label: "Fixes",
+        items: [
+            {
+                name: "Suggest Fix",
+                value: "suggest",
+                description: "Get AI-suggested fix for a specific issue",
+            },
+            {
+                name: "Apply Fix",
+                value: "fix",
+                description: "Apply a suggested fix to your codebase",
+            },
+            {
+                name: "Fix All",
+                value: "fix-all",
+                description: "Apply all suggested fixes in one pass",
+            },
+            {
+                name: "Fix Plan",
+                value: "fix-plan",
+                description: "Generate a structured remediation plan",
+            },
+            {
+                name: "Review Patch",
+                value: "patch-review",
+                description: "Review a generated patch before applying",
+            },
+        ],
+    },
+    {
+        label: "Reports",
+        items: [
+            {
+                name: "Generate Doc",
+                value: "doc",
+                description: "Generate accessibility documentation for a component",
+            },
+            {
+                name: "Add Comment",
+                value: "comment",
+                description: "Add audit annotations to source code",
+            },
+            {
+                name: "Release Notes",
+                value: "release-notes",
+                description: "Generate release notes from audit improvements",
+            },
+        ],
+    },
+    {
+        label: "Project",
+        items: [
+            {
+                name: "Initialize",
+                value: "init",
+                description: "Create .vertaaux.yml configuration in current project",
+            },
+            {
+                name: "Set Baseline",
+                value: "baseline",
+                description: "Set current audit results as the project baseline",
+            },
+            {
+                name: "Upload Results",
+                value: "upload",
+                description: "Upload local audit results to VertaaUX cloud",
+            },
+            {
+                name: "Download Results",
+                value: "download",
+                description: "Download audit results from VertaaUX cloud",
+            },
+            {
+                name: "Verify Quality Gate",
+                value: "verify",
+                description: "Check if results meet quality gate thresholds",
+            },
+        ],
+    },
+    {
+        label: "Account",
+        items: [
+            {
+                name: "Login",
+                value: "login",
+                description: "Authenticate with your VertaaUX account",
+            },
+            {
+                name: "Logout",
+                value: "logout",
+                description: "Sign out and remove stored credentials",
+            },
+            {
+                name: "Who Am I",
+                value: "whoami",
+                description: "Show currently authenticated account",
+            },
+            {
+                name: "Health Check",
+                value: "doctor",
+                description: "Run diagnostics on CLI configuration and connectivity",
+            },
+            {
+                name: "Policy",
+                value: "policy",
+                description: "Manage project quality gate policies",
+            },
+        ],
+    },
+];
+/**
+ * Returns a flat list of all MenuItem entries across all categories.
+ * Useful for quick lookups by command value.
+ */
+export function allMenuItems() {
+    return COMMAND_CATEGORIES.flatMap((cat) => cat.items);
+}

package/dist/app/menu/filter.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Type-to-filter search logic for the interactive menu.
+ *
+ * Filters command categories by a case-insensitive substring query.
+ * Matches against item name, value, and description.
+ * Returns only categories with at least one matching item, preserving order.
+ */
+import type { CommandCategory } from "../types.js";
+/**
+ * Filter categories by a search query.
+ *
+ * @param query - The search string (case-insensitive substring match)
+ * @param categories - Source categories to filter
+ * @returns Categories (and filtered items) matching the query; empty query returns all unchanged
+ */
+export declare function filterCategories(query: string, categories: CommandCategory[]): CommandCategory[];
+//# sourceMappingURL=filter.d.ts.map

package/dist/app/menu/filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../../src/app/menu/filter.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,eAAe,EAAE,GAC5B,eAAe,EAAE,CAyBnB"}

package/dist/app/menu/filter.js

@@ -0,0 +1,33 @@
+/**
+ * Type-to-filter search logic for the interactive menu.
+ *
+ * Filters command categories by a case-insensitive substring query.
+ * Matches against item name, value, and description.
+ * Returns only categories with at least one matching item, preserving order.
+ */
+/**
+ * Filter categories by a search query.
+ *
+ * @param query - The search string (case-insensitive substring match)
+ * @param categories - Source categories to filter
+ * @returns Categories (and filtered items) matching the query; empty query returns all unchanged
+ */
+export function filterCategories(query, categories) {
+    // Empty query — return all categories unchanged
+    if (query.trim() === "") {
+        return categories;
+    }
+    const lowerQuery = query.toLowerCase();
+    const result = [];
+    for (const category of categories) {
+        const matchingItems = category.items.filter((item) => {
+            return (item.name.toLowerCase().includes(lowerQuery) ||
+                item.value.toLowerCase().includes(lowerQuery) ||
+                (item.description?.toLowerCase().includes(lowerQuery) ?? false));
+        });
+        if (matchingItems.length > 0) {
+            result.push({ label: category.label, items: matchingItems });
+        }
+    }
+    return result;
+}

package/dist/app/menu/menu-view.d.ts

@@ -0,0 +1,35 @@
+/**
+ * MenuView — Two-level drilldown command menu.
+ *
+ * Level 1: 6 category groups (Audit, Results, Fixes, Reports, Project, Account)
+ * Level 2: Commands within the selected category
+ *
+ * Navigation:
+ *   ↑↓ — move selection
+ *   Enter — drill into category / run command
+ *   Escape — back to categories (or clear search)
+ *   Type — search across all commands (flat filtered list)
+ */
+import type { CommandView } from "../types.js";
+export declare class MenuView implements CommandView {
+    private searchBuffer;
+    private selectedIndex;
+    private level;
+    private activeCategory;
+    private readonly onSelect;
+    private cachedSearchQuery;
+    private cachedSearchItems;
+    constructor(onSelect: (command: string) => void);
+    render(): string;
+    handleKey(key: string, ctrl: boolean, _meta: boolean): boolean;
+    private renderCategories;
+    private renderItems;
+    private renderSearch;
+    private renderMenuItem;
+    private getSearchItems;
+    private moveCursor;
+    private getItemCount;
+    private confirmSelection;
+    private goBack;
+}
+//# sourceMappingURL=menu-view.d.ts.map

package/dist/app/menu/menu-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-view.d.ts","sourceRoot":"","sources":["../../../src/app/menu/menu-view.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EAAE,WAAW,EAA6B,MAAM,aAAa,CAAC;AAa1E,qBAAa,QAAS,YAAW,WAAW;IAC1C,OAAO,CAAC,YAAY,CAAM;IAC1B,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,KAAK,CAA2B;IACxC,OAAO,CAAC,cAAc,CAAgC;IACtD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA4B;IAGrD,OAAO,CAAC,iBAAiB,CAAM;IAC/B,OAAO,CAAC,iBAAiB,CAAkB;gBAE/B,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI;IAK/C,MAAM,IAAI,MAAM;IAUhB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO;IAiD9D,OAAO,CAAC,gBAAgB;IA0BxB,OAAO,CAAC,WAAW;IA4BnB,OAAO,CAAC,YAAY;IA8BpB,OAAO,CAAC,cAAc;IAetB,OAAO,CAAC,cAAc;IAWtB,OAAO,CAAC,UAAU;IAMlB,OAAO,CAAC,YAAY;IAUpB,OAAO,CAAC,gBAAgB;IA8BxB,OAAO,CAAC,MAAM;CAmBf"}

package/dist/app/menu/menu-view.js

@@ -0,0 +1,230 @@
+/**
+ * MenuView — Two-level drilldown command menu.
+ *
+ * Level 1: 6 category groups (Audit, Results, Fixes, Reports, Project, Account)
+ * Level 2: Commands within the selected category
+ *
+ * Navigation:
+ *   ↑↓ — move selection
+ *   Enter — drill into category / run command
+ *   Escape — back to categories (or clear search)
+ *   Type — search across all commands (flat filtered list)
+ */
+import { bold, colorize, dim, brand } from "@vertaaux/tui";
+import { COMMAND_CATEGORIES } from "./categories.js";
+import { filterCategories } from "./filter.js";
+const UP_ARROW = "\x1b[A";
+const DOWN_ARROW = "\x1b[B";
+// Pre-computed: category label column width (static, never changes)
+const CATEGORY_COL_WIDTH = Math.max(...COMMAND_CATEGORIES.map(c => c.label.length)) + 4;
+export class MenuView {
+    searchBuffer = "";
+    selectedIndex = 0;
+    level = "categories";
+    activeCategory = null;
+    onSelect;
+    // Cached search results — invalidated when searchBuffer changes
+    cachedSearchQuery = "";
+    cachedSearchItems = [];
+    constructor(onSelect) {
+        this.onSelect = onSelect;
+    }
+    render() {
+        if (this.searchBuffer) {
+            return this.renderSearch();
+        }
+        if (this.level === "items" && this.activeCategory) {
+            return this.renderItems();
+        }
+        return this.renderCategories();
+    }
+    handleKey(key, ctrl, _meta) {
+        if (ctrl && key === "\x03")
+            return false;
+        if (key === UP_ARROW) {
+            this.moveCursor(-1);
+            return true;
+        }
+        if (key === DOWN_ARROW) {
+            this.moveCursor(1);
+            return true;
+        }
+        if (key === "\r" || key === "\n") {
+            this.confirmSelection();
+            return true;
+        }
+        if (key === "\x1b") {
+            return this.goBack();
+        }
+        if (key === "\x7f" || key === "\b") {
+            if (this.searchBuffer.length > 0) {
+                this.searchBuffer = this.searchBuffer.slice(0, -1);
+                this.selectedIndex = 0;
+                if (this.searchBuffer === "") {
+                    this.level = "categories";
+                }
+            }
+            else if (this.level === "items") {
+                this.level = "categories";
+                this.activeCategory = null;
+                this.selectedIndex = 0;
+            }
+            return true;
+        }
+        // Printable character — enter search mode
+        if (key.length === 1 && key >= " ") {
+            this.searchBuffer += key;
+            this.level = "search";
+            this.selectedIndex = 0;
+            return true;
+        }
+        return false;
+    }
+    // ── Render methods ────────────────────────────────────────────
+    renderCategories() {
+        const lines = [
+            dim("Type to search commands..."),
+            "",
+        ];
+        const count = COMMAND_CATEGORIES.length;
+        if (this.selectedIndex >= count)
+            this.selectedIndex = count - 1;
+        for (let i = 0; i < count; i++) {
+            const cat = COMMAND_CATEGORIES[i];
+            const isSelected = i === this.selectedIndex;
+            const padding = " ".repeat(CATEGORY_COL_WIDTH - cat.label.length);
+            const label = isSelected
+                ? bold(colorize(`  ${cat.label}`, brand.lime))
+                : `  ${cat.label}`;
+            const itemCount = dim(`${cat.items.length} commands`);
+            lines.push(label + padding + itemCount);
+        }
+        lines.push("");
+        lines.push(dim("↑↓ navigate  ↵ open  type to search"));
+        return lines.join("\n");
+    }
+    renderItems() {
+        const cat = this.activeCategory;
+        if (!cat)
+            return "";
+        const lines = [
+            bold(cat.label),
+            "",
+        ];
+        const nameColWidth = Math.max(...cat.items.map(i => i.name.length), 10) + 4;
+        if (this.selectedIndex >= cat.items.length) {
+            this.selectedIndex = cat.items.length - 1;
+        }
+        for (let i = 0; i < cat.items.length; i++) {
+            const item = cat.items[i];
+            const isSelected = i === this.selectedIndex;
+            lines.push(this.renderMenuItem(item, isSelected, nameColWidth));
+        }
+        lines.push("");
+        lines.push(dim("↑↓ navigate  ↵ run  Esc back"));
+        return lines.join("\n");
+    }
+    renderSearch() {
+        const lines = [
+            `Search: ${this.searchBuffer}_`,
+            "",
+        ];
+        const flatItems = this.getSearchItems();
+        if (this.selectedIndex >= flatItems.length) {
+            this.selectedIndex = Math.max(0, flatItems.length - 1);
+        }
+        if (flatItems.length === 0) {
+            lines.push(dim("  No commands match your search."));
+        }
+        else {
+            const nameColWidth = Math.max(...flatItems.map(i => i.name.length), 10) + 4;
+            for (let i = 0; i < flatItems.length; i++) {
+                lines.push(this.renderMenuItem(flatItems[i], i === this.selectedIndex, nameColWidth));
+            }
+        }
+        lines.push("");
+        lines.push(dim("↑↓ navigate  ↵ run  Esc clear"));
+        return lines.join("\n");
+    }
+    renderMenuItem(item, selected, nameColWidth) {
+        const indent = "  ";
+        const nameText = item.name;
+        const padding = " ".repeat(Math.max(2, nameColWidth - indent.length - nameText.length));
+        const name = selected
+            ? bold(colorize(`${indent}${nameText}`, brand.lime))
+            : `${indent}${nameText}`;
+        const desc = item.description ? dim(item.description) : "";
+        return name + padding + desc;
+    }
+    // ── Search cache ────────────────────────────────────────────
+    getSearchItems() {
+        if (this.cachedSearchQuery !== this.searchBuffer) {
+            this.cachedSearchQuery = this.searchBuffer;
+            this.cachedSearchItems = filterCategories(this.searchBuffer, COMMAND_CATEGORIES)
+                .flatMap(c => c.items);
+        }
+        return this.cachedSearchItems;
+    }
+    // ── Navigation helpers ────────────────────────────────────────
+    moveCursor(delta) {
+        const count = this.getItemCount();
+        if (count === 0)
+            return;
+        this.selectedIndex = (this.selectedIndex + delta + count) % count;
+    }
+    getItemCount() {
+        if (this.searchBuffer) {
+            return this.getSearchItems().length;
+        }
+        if (this.level === "items" && this.activeCategory) {
+            return this.activeCategory.items.length;
+        }
+        return COMMAND_CATEGORIES.length;
+    }
+    confirmSelection() {
+        if (this.searchBuffer) {
+            // Search mode — select a command directly
+            const flatItems = this.getSearchItems();
+            if (flatItems[this.selectedIndex]) {
+                this.onSelect(flatItems[this.selectedIndex].value);
+            }
+            return;
+        }
+        if (this.level === "categories") {
+            // Drill into category
+            const cat = COMMAND_CATEGORIES[this.selectedIndex];
+            if (cat) {
+                this.activeCategory = cat;
+                this.level = "items";
+                this.selectedIndex = 0;
+            }
+            return;
+        }
+        if (this.level === "items" && this.activeCategory) {
+            // Select a command
+            const item = this.activeCategory.items[this.selectedIndex];
+            if (item) {
+                this.onSelect(item.value);
+            }
+        }
+    }
+    goBack() {
+        if (this.searchBuffer) {
+            this.searchBuffer = "";
+            this.selectedIndex = 0;
+            this.level = "categories";
+            return true;
+        }
+        if (this.level === "items") {
+            // Find the index of the active category to restore position
+            const catIndex = this.activeCategory
+                ? COMMAND_CATEGORIES.indexOf(this.activeCategory)
+                : -1;
+            this.level = "categories";
+            this.activeCategory = null;
+            this.selectedIndex = catIndex >= 0 ? catIndex : 0;
+            return true;
+        }
+        return false;
+    }
+}

package/dist/app/menu/recent.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Recent commands persistence for the interactive menu.
+ *
+ * Persists the last 5 commands to ~/.vertaaux/recent.json.
+ * Deduplicates and caps at 5 entries.
+ */
+/** Path to the recent commands JSON file */
+export declare const RECENT_PATH: string;
+/**
+ * Load the recent commands list from disk.
+ *
+ * Returns an empty array if the file does not exist or contains invalid JSON.
+ */
+export declare function loadRecent(): Promise<string[]>;
+/**
+ * Record a command as recently used.
+ *
+ * Prepends the command to the list, deduplicates (case-sensitive),
+ * caps at RECENT_MAX, and writes to disk. Creates the directory if needed.
+ *
+ * @param command - The command value (e.g., "audit", "doctor")
+ */
+export declare function recordRecent(command: string): Promise<void>;
+//# sourceMappingURL=recent.d.ts.map

package/dist/app/menu/recent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recent.d.ts","sourceRoot":"","sources":["../../../src/app/menu/recent.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AASH,4CAA4C;AAC5C,eAAO,MAAM,WAAW,QAA8C,CAAC;AAEvE;;;;GAIG;AACH,wBAAsB,UAAU,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAWpD;AAED;;;;;;;GAOG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAajE"}

package/dist/app/menu/recent.js

@@ -0,0 +1,49 @@
+/**
+ * Recent commands persistence for the interactive menu.
+ *
+ * Persists the last 5 commands to ~/.vertaaux/recent.json.
+ * Deduplicates and caps at 5 entries.
+ */
+import { join } from "path";
+import { homedir } from "os";
+import * as fsp from "fs/promises";
+/** Maximum number of recent commands to retain */
+const RECENT_MAX = 5;
+/** Path to the recent commands JSON file */
+export const RECENT_PATH = join(homedir(), ".vertaaux", "recent.json");
+/**
+ * Load the recent commands list from disk.
+ *
+ * Returns an empty array if the file does not exist or contains invalid JSON.
+ */
+export async function loadRecent() {
+    try {
+        const raw = await fsp.readFile(RECENT_PATH, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed)) {
+            return parsed.filter((x) => typeof x === "string");
+        }
+        return [];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Record a command as recently used.
+ *
+ * Prepends the command to the list, deduplicates (case-sensitive),
+ * caps at RECENT_MAX, and writes to disk. Creates the directory if needed.
+ *
+ * @param command - The command value (e.g., "audit", "doctor")
+ */
+export async function recordRecent(command) {
+    const existing = await loadRecent();
+    // Deduplicate: remove any existing occurrence of this command
+    const deduped = existing.filter((c) => c !== command);
+    // Prepend to front, cap at max
+    const updated = [command, ...deduped].slice(0, RECENT_MAX);
+    // Ensure directory exists
+    await fsp.mkdir(join(homedir(), ".vertaaux"), { recursive: true });
+    await fsp.writeFile(RECENT_PATH, JSON.stringify(updated), "utf-8");
+}

package/dist/app/types.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Core type contracts for the InteractiveApp shell.
+ *
+ * CommandView is the interface all interactive command views must implement.
+ * AppState tracks the application's current screen and active view.
+ */
+/**
+ * Interface for pluggable views that can be mounted in the InteractiveApp canvas.
+ *
+ * Each view owns its rendering and keyboard handling; the app shell
+ * calls render() each tick and routes keyboard events to handleKey().
+ */
+export interface CommandView {
+    /** Render current content as string — canvas calls this each frame */
+    render(): string;
+    /** Handle keyboard event — return true if consumed */
+    handleKey?(key: string, ctrl: boolean, meta: boolean): boolean;
+    /** Called once when view is mounted in the canvas */
+    onMount?(): Promise<void>;
+    /** Called once when view is unmounted from the canvas */
+    onUnmount?(): Promise<void>;
+}
+/** A single menu item in the interactive command menu */
+export interface MenuItem {
+    name: string;
+    value: string;
+    description?: string;
+    shortcut?: string;
+}
+/** A category grouping for the root menu */
+export interface CommandCategory {
+    label: string;
+    items: MenuItem[];
+}
+/** Which top-level screen the app is currently showing */
+export type AppScreen = "menu" | "command" | "help";
+/** Full application state passed to layout renderers */
+export interface AppState {
+    screen: AppScreen;
+    statusText: string;
+    activeView: CommandView | null;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/app/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/app/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,sEAAsE;IACtE,MAAM,IAAI,MAAM,CAAC;IACjB,sDAAsD;IACtD,SAAS,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC;IAC/D,qDAAqD;IACrD,OAAO,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,yDAAyD;IACzD,SAAS,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7B;AAED,yDAAyD;AACzD,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,4CAA4C;AAC5C,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,QAAQ,EAAE,CAAC;CACnB;AAED,0DAA0D;AAC1D,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC;AAEpD,wDAAwD;AACxD,MAAM,WAAW,QAAQ;IACvB,MAAM,EAAE,SAAS,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,WAAW,GAAG,IAAI,CAAC;CAChC"}

package/dist/app/types.js

@@ -0,0 +1,7 @@
+/**
+ * Core type contracts for the InteractiveApp shell.
+ *
+ * CommandView is the interface all interactive command views must implement.
+ * AppState tracks the application's current screen and active view.
+ */
+export {};

package/dist/app/views/command-runner.d.ts

@@ -0,0 +1,36 @@
+/**
+ * CommandRunnerView — Executes a CLI command within the InteractiveApp canvas.
+ *
+ * Lifecycle:
+ *   1. "collecting" — prompts for required args ON the alt screen using raw-mode
+ *      keyboard input (same system as MenuView). No stdin mode transitions.
+ *   2. "running" — command runs INSIDE the app layout. A renderer override
+ *      captures step states so this view can render them in the canvas.
+ *      Header and footer stay visible throughout.
+ *   3. "done"/"error" — shows result summary in canvas, M returns to menu.
+ *
+ * Each command's handler is called directly (no program.parse()).
+ */
+import type { CommandView } from "../types.js";
+import type { InteractiveApp } from "../interactive-app.js";
+export declare class CommandRunnerView implements CommandView {
+    private status;
+    private statusText;
+    private commandValue;
+    private app;
+    private onReturn;
+    private argDefs;
+    private collectedArgs;
+    private currentArgIndex;
+    private inputBuffer;
+    private resolveArgCollection;
+    private canvasRenderer;
+    private outputBuffer;
+    private scrollOffset;
+    constructor(commandValue: string, app: InteractiveApp, onReturn: () => void);
+    render(): string;
+    handleKey(key: string, ctrl: boolean, _meta: boolean): boolean;
+    onMount(): Promise<void>;
+    private executeCommand;
+}
+//# sourceMappingURL=command-runner.d.ts.map

package/dist/app/views/command-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-runner.d.ts","sourceRoot":"","sources":["../../../src/app/views/command-runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAWH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAwF5D,qBAAa,iBAAkB,YAAW,WAAW;IACnD,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,UAAU,CAAM;IACxB,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,GAAG,CAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAa;IAG7B,OAAO,CAAC,OAAO,CAAW;IAC1B,OAAO,CAAC,aAAa,CAA8B;IACnD,OAAO,CAAC,eAAe,CAAK;IAC5B,OAAO,CAAC,WAAW,CAAM;IAGzB,OAAO,CAAC,oBAAoB,CAA6B;IAGzD,OAAO,CAAC,cAAc,CAAwB;IAG9C,OAAO,CAAC,YAAY,CAAgB;IAGpC,OAAO,CAAC,YAAY,CAAK;gBAGvB,YAAY,EAAE,MAAM,EACpB,GAAG,EAAE,cAAc,EACnB,QAAQ,EAAE,MAAM,IAAI;IAStB,MAAM,IAAI,MAAM;IA0EhB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO;IAsFxD,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;YA+BhB,cAAc;CA0F7B"}