toolcraft 0.0.16 → 0.0.18

package/node_modules/@poe-code/design-system/dist/dashboard/keymap.js

@@ -7,23 +7,78 @@ const defaultBindings = {
     retry: ["r"],
     "view-log": ["l"]
 };
-export function createKeymap(overrides) {
+export function createKeymap(overrides, options) {
+    const resolvedCommands = options?.commands ?? commands;
+    const resolvedDefaults = options?.defaultBindings ?? defaultBindings;
     const bindings = new Map();
-    for (const command of commands) {
-        const keys = overrides?.[command] ?? defaultBindings[command];
-        bindings.set(command, keys
+    const sequences = new Set();
+    let pendingSequence = "";
+    for (const command of resolvedCommands) {
+        const keys = overrides?.[command] ?? resolvedDefaults[command];
+        const commandBindings = keys
             .map(parseBinding)
-            .filter((binding) => binding !== undefined));
+            .filter((binding) => binding !== undefined);
+        for (const binding of commandBindings) {
+            if (binding.sequence !== undefined) {
+                sequences.add(binding.sequence);
+            }
+        }
+        bindings.set(command, commandBindings);
     }
     return (event) => {
-        for (const command of commands) {
+        for (const command of resolvedCommands) {
             const commandBindings = bindings.get(command);
-            if (commandBindings?.some((binding) => matches(binding, event))) {
+            if (commandBindings?.some((binding) => matchesSingleKey(binding, event))) {
+                pendingSequence = "";
                 return command;
             }
         }
+        const sequenceCommand = resolveSequence(event);
+        if (sequenceCommand !== undefined) {
+            return sequenceCommand;
+        }
         return undefined;
     };
+    function resolveSequence(event) {
+        const token = eventToSequenceToken(event);
+        if (token === undefined) {
+            pendingSequence = "";
+            return undefined;
+        }
+        pendingSequence = `${pendingSequence}${token}`;
+        for (const command of resolvedCommands) {
+            const commandBindings = bindings.get(command);
+            if (commandBindings?.some((binding) => binding.sequence === pendingSequence)) {
+                pendingSequence = "";
+                return command;
+            }
+        }
+        if (hasSequencePrefix(sequences, pendingSequence)) {
+            return undefined;
+        }
+        pendingSequence = token;
+        if (hasSequencePrefix(sequences, pendingSequence)) {
+            return undefined;
+        }
+        pendingSequence = "";
+        return undefined;
+    }
+}
+export function canonicalizeBinding(binding) {
+    const parsed = parseBinding(binding);
+    if (parsed === undefined) {
+        return undefined;
+    }
+    const modifiers = [
+        parsed.ctrl ? "ctrl" : undefined,
+        parsed.meta ? "meta" : undefined,
+        parsed.shift ? "shift" : undefined
+    ].filter((modifier) => modifier !== undefined);
+    const key = parsed.name ?? parsed.ch;
+    if (parsed.sequence !== undefined) {
+        return parsed.sequence.toLowerCase();
+    }
+    return key === undefined ? undefined : [...modifiers, key.toLowerCase()].join("+");
 }
 function parseBinding(binding) {
     const value = binding.trim();
@@ -56,25 +111,41 @@ function parseBinding(binding) {
             continue;
         }
     }
-    if (parts.length === 1 && isShiftedCharacter(key)) {
+    const normalizedKey = normalizeKeyName(key);
+    if (parts.length === 1 && isShiftedCharacter(normalizedKey)) {
         shift = true;
     }
-    if (key.length === 1) {
+    if (normalizedKey.length === 1) {
+        return {
+            ch: normalizeBindingCharacter(normalizedKey, shift),
+            ctrl,
+            meta,
+            shift
+        };
+    }
+    if (!ctrl &&
+        !meta &&
+        !shift &&
+        !isNamedKey(normalizedKey) &&
+        isPrintableSequence(normalizedKey)) {
         return {
-            ch: normalizeBindingCharacter(key, shift),
+            sequence: normalizedKey,
             ctrl,
             meta,
             shift
         };
     }
     return {
-        name: key.toLowerCase(),
+        name: normalizedKey.toLowerCase(),
         ctrl,
         meta,
         shift
     };
 }
-function matches(binding, event) {
+function matchesSingleKey(binding, event) {
+    if (binding.sequence !== undefined) {
+        return false;
+    }
     if (binding.ctrl !== event.ctrl ||
         binding.meta !== event.meta ||
         binding.shift !== event.shift) {
@@ -88,6 +159,20 @@ function matches(binding, event) {
     }
     return false;
 }
+function eventToSequenceToken(event) {
+    if (event.ctrl || event.meta || event.ch === undefined) {
+        return undefined;
+    }
+    return event.ch;
+}
+function hasSequencePrefix(sequences, prefix) {
+    for (const sequence of sequences) {
+        if (sequence.startsWith(prefix)) {
+            return true;
+        }
+    }
+    return false;
+}
 function isShiftedCharacter(value) {
     return value.length === 1 && value.toLowerCase() !== value && value.toUpperCase() === value;
 }
@@ -97,3 +182,52 @@ function normalizeBindingCharacter(value, shift) {
     }
     return value.toUpperCase();
 }
+function normalizeKeyName(value) {
+    if (value.toLowerCase() === "space") {
+        return " ";
+    }
+    if (value === "↑") {
+        return "up";
+    }
+    if (value === "↓") {
+        return "down";
+    }
+    if (value === "←") {
+        return "left";
+    }
+    if (value === "→") {
+        return "right";
+    }
+    return value;
+}
+function isNamedKey(value) {
+    return namedKeys.has(value.toLowerCase());
+}
+function isPrintableSequence(value) {
+    if (Array.from(value).length <= 1) {
+        return false;
+    }
+    for (const char of value) {
+        const codePoint = char.codePointAt(0);
+        if (codePoint === undefined || codePoint < 0x20 || codePoint === 0x7f) {
+            return false;
+        }
+    }
+    return true;
+}
+const namedKeys = new Set([
+    "backspace",
+    "delete",
+    "down",
+    "end",
+    "enter",
+    "escape",
+    "home",
+    "left",
+    "pagedown",
+    "pageup",
+    "return",
+    "right",
+    "tab",
+    "up"
+]);

package/node_modules/@poe-code/design-system/dist/dashboard/terminal.js

@@ -185,6 +185,10 @@ export function parseKeypress(data) {
     return event;
 }
 function toKeypressEvent(str, key) {
+    const controlCharacter = controlCharacterToKeypress(key?.sequence);
+    if (controlCharacter !== undefined) {
+        return controlCharacter;
+    }
     const ctrl = key?.ctrl ?? false;
     const meta = key?.meta ?? false;
     const shift = key?.shift ?? false;
@@ -206,12 +210,22 @@ function extractPrintableCharacter(str, sequence) {
     if (isPrintableCharacter(str)) {
         return str;
     }
+    if (isSinglePrintableSequence(sequence)) {
+        return sequence;
+    }
     if (sequence === undefined || sequence.length <= 1 || sequence[0] !== "\u001b") {
         return undefined;
     }
     const candidate = sequence.slice(1);
     return isPrintableCharacter(candidate) ? candidate : undefined;
 }
+function isSinglePrintableSequence(value) {
+    if (value === undefined || Array.from(value).length !== 1) {
+        return false;
+    }
+    const codePoint = value.codePointAt(0);
+    return codePoint !== undefined && codePoint >= 0x20 && codePoint !== 0x7f;
+}
 function isPrintableCharacter(value) {
     if (value === undefined || Array.from(value).length !== 1) {
         return false;
@@ -219,6 +233,23 @@ function isPrintableCharacter(value) {
     const codePoint = value.codePointAt(0);
     return codePoint !== undefined && codePoint >= 0x20 && codePoint !== 0x7f;
 }
+function controlCharacterToKeypress(sequence) {
+    if (sequence === "\u001f") {
+        return { ch: "/", ctrl: true, meta: false, shift: false };
+    }
+    if (sequence !== undefined && sequence.length === 1) {
+        const code = sequence.charCodeAt(0);
+        if (code >= 1 && code <= 26 && code !== 9 && code !== 10 && code !== 13) {
+            return {
+                name: String.fromCharCode(code + 96),
+                ctrl: true,
+                meta: false,
+                shift: false
+            };
+        }
+    }
+    return undefined;
+}
 function cursorPositionAnsi(x, y) {
     return `\u001b[${normalizeCoordinate(y) + 1};${normalizeCoordinate(x) + 1}H`;
 }

package/node_modules/@poe-code/design-system/dist/dashboard/types.d.ts

@@ -23,6 +23,7 @@ export type CellStyle = {
     bg?: string;
     bold?: boolean;
     dim?: boolean;
+    underline?: boolean;
 };
 export type Cell = {
     ch: string;

package/node_modules/@poe-code/design-system/dist/explorer/actions.d.ts

@@ -0,0 +1,16 @@
+import type { ExplorerEvent } from "./events.js";
+import type { Action, ActionContext, ExplorerState, Row, Tone } from "./state.js";
+export type ActionSource = "row" | "detail";
+type ExplorerKeypressEvent = Extract<ExplorerEvent, {
+    type: "key";
+}>["key"];
+export type ActionRuntimeHandles = {
+    refresh: () => Promise<void>;
+    suspendAnd: <T>(fn: () => Promise<T>) => Promise<T>;
+    toast: (msg: string, tone?: Tone) => void;
+    confirm: (prompt: string) => Promise<boolean>;
+    exit: (after?: () => void | Promise<void>) => void;
+};
+export declare function resolveAction<R>(state: ExplorerState, keyEvent: ExplorerKeypressEvent): Action<R> | null;
+export declare function buildActionContext<R>(state: ExplorerState, _action: Action<R>, source: ActionSource, runtimeHandles: ActionRuntimeHandles, rowsOverride?: Row[]): ActionContext<R>;
+export {};

package/node_modules/@poe-code/design-system/dist/explorer/actions.js

@@ -0,0 +1,39 @@
+export function resolveAction(state, keyEvent) {
+    const target = state.bindings.resolve(keyEvent);
+    if (target?.type !== "action") {
+        return null;
+    }
+    const actionState = state.actionState.get(target.id);
+    if (actionState?.available !== true ||
+        actionState.running === true ||
+        actionState.action === undefined) {
+        return null;
+    }
+    return actionState.action;
+}
+export function buildActionContext(state, _action, source, runtimeHandles, rowsOverride) {
+    const row = rowsOverride?.[0] ?? currentRow(state) ?? { id: "", title: "" };
+    return {
+        row,
+        rows: rowsOverride ?? selectedRows(state, row),
+        item: source === "detail" ? currentDetailItem(state) : undefined,
+        filter: state.filter,
+        refresh: runtimeHandles.refresh,
+        suspendAnd: runtimeHandles.suspendAnd,
+        toast: runtimeHandles.toast,
+        confirm: runtimeHandles.confirm,
+        exit: runtimeHandles.exit
+    };
+}
+function currentRow(state) {
+    return state.rows[state.filtered[state.cursor] ?? -1];
+}
+function currentDetailItem(state) {
+    return state.detail.items?.[state.detail.cursor];
+}
+function selectedRows(state, fallback) {
+    if (state.selected.size === 0) {
+        return fallback.id === "" ? [] : [fallback];
+    }
+    return state.rows.filter((row) => state.selected.has(row.id));
+}

package/node_modules/@poe-code/design-system/dist/explorer/demo.d.ts

@@ -0,0 +1,13 @@
+import type { ExplorerConfig } from "./state.js";
+type ExplorerDemoMode = "single-detail-mode" | "list-detail-mode";
+export interface ExplorerDemoOptions {
+    mode: ExplorerDemoMode;
+    slowDetail: boolean;
+}
+export interface BuildExplorerDemoConfigOptions extends ExplorerDemoOptions {
+    onReorder?: (orderedIds: string[]) => void | Promise<void>;
+}
+export declare function parseExplorerDemoOptions(argv?: string[], env?: NodeJS.ProcessEnv): ExplorerDemoOptions;
+export declare function buildExplorerDemoConfig(options: BuildExplorerDemoConfigOptions): ExplorerConfig<void>;
+export declare function main(): Promise<void>;
+export {};

package/node_modules/@poe-code/design-system/dist/explorer/demo.js

@@ -0,0 +1,297 @@
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { runExplorer } from "./index.js";
+const detailDelayMs = 500;
+const truthyEnvValues = new Set(["1", "true", "yes", "on"]);
+const singleDetailRows = [
+    {
+        id: "configure-commands",
+        title: "Configure commands",
+        subtitle: "Provider config mutation flow",
+        badge: { text: "ready", tone: "success" },
+        group: "Planning"
+    },
+    {
+        id: "provider-boilerplate",
+        title: "Provider boilerplate audit",
+        subtitle: "Keep providers declarative and minimal",
+        badge: { text: "review", tone: "warning" },
+        group: "Planning"
+    },
+    {
+        id: "markdown-reader",
+        title: "Markdown reader",
+        subtitle: "Terminal-rendered plan preview",
+        badge: { text: "done", tone: "muted" },
+        group: "Docs"
+    },
+    {
+        id: "design-system-prompts",
+        title: "Design system prompts",
+        subtitle: "Prompt primitives owned by the package",
+        badge: { text: "active", tone: "info" },
+        group: "UI"
+    }
+];
+const singleDetailMarkdown = {
+    "configure-commands": [
+        "# Configure commands",
+        "",
+        "Provider configuration should be derived from declarative provider config.",
+        "",
+        "- Parse existing files with structured parsers.",
+        "- Deep merge edits instead of replacing user-owned configuration.",
+        "- Keep CLI and SDK arguments in parity."
+    ].join("\n"),
+    "provider-boilerplate": [
+        "# Provider boilerplate audit",
+        "",
+        "Adding a provider should mean adding one provider file. Everything else should come from the provider config.",
+        "",
+        "Avoid provider-specific branches in shared code paths."
+    ].join("\n"),
+    "markdown-reader": [
+        "# Markdown reader",
+        "",
+        "Render markdown plans with stable wrapping and predictable terminal styling.",
+        "",
+        "The reader is a display surface, not a planning store."
+    ].join("\n"),
+    "design-system-prompts": [
+        "# Design system prompts",
+        "",
+        "Prompt primitives belong in the design-system package so CLI surfaces share one style.",
+        "",
+        "Direct use of unrelated prompt libraries should stay out of consumers."
+    ].join("\n")
+};
+const reviewRows = [
+    {
+        id: "pr-1842",
+        title: "PR #1842 provider config parser",
+        subtitle: "3 unresolved comments by reviewbot",
+        badge: { text: "changes", tone: "warning" },
+        group: "Review queue"
+    },
+    {
+        id: "pr-1847",
+        title: "PR #1847 explorer TUI library",
+        subtitle: "2 comments, one destructive flow question",
+        badge: { text: "ready", tone: "success" },
+        group: "Review queue"
+    },
+    {
+        id: "pr-1851",
+        title: "PR #1851 markdown QA checklist",
+        subtitle: "1 docs-only note",
+        badge: { text: "docs", tone: "info" },
+        group: "Review queue"
+    }
+];
+const reviewComments = {
+    "pr-1842": [
+        {
+            id: "pr-1842-comment-1",
+            title: "Review: provider registry",
+            subtitle: "packages/providers/src/registry.ts:42",
+            body: "The provider data is already present in config. Derive the registry entry instead of repeating provider names here.",
+            tone: "warning"
+        },
+        {
+            id: "pr-1842-comment-2",
+            title: "Review: config merge",
+            subtitle: "packages/config-mutations/src/apply.ts:88",
+            body: "This should deep merge the parsed structure so user-owned fields remain intact.",
+            tone: "error"
+        },
+        {
+            id: "pr-1842-comment-3",
+            title: "Review: parser coverage",
+            subtitle: "packages/config-mutations/src/apply.test.ts:131",
+            body: "Add a fixture that proves comments and unknown keys survive the update path.",
+            tone: "info"
+        }
+    ],
+    "pr-1847": [
+        {
+            id: "pr-1847-comment-1",
+            title: "Review: detail loading",
+            subtitle: "packages/design-system/src/explorer/jobs.ts:19",
+            body: "The 150 ms loading threshold is the right behavior. This demo should make that visible with --slow-detail.",
+            tone: "success"
+        },
+        {
+            id: "pr-1847-comment-2",
+            title: "Review: destructive confirm",
+            subtitle: "packages/design-system/src/explorer/reducer.ts:435",
+            body: "Confirm modal behavior should be reachable from manual QA with a simple keybinding.",
+            tone: "warning"
+        }
+    ],
+    "pr-1851": [
+        {
+            id: "pr-1851-comment-1",
+            title: "Review: QA format",
+            subtitle: "docs/qa/explorer-tui-library.md",
+            body: "Keep this as a markdown checklist. Do not convert manual QA into a script.",
+            tone: "info"
+        }
+    ]
+};
+export function parseExplorerDemoOptions(argv = process.argv.slice(2), env = process.env) {
+    let mode = parseMode(env.EXPLORER_DEMO_MODE) ?? "single-detail-mode";
+    let slowDetail = isTruthy(env.EXPLORER_DEMO_SLOW_DETAIL);
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === "--slow-detail") {
+            slowDetail = true;
+            continue;
+        }
+        if (arg === "--single-detail-mode") {
+            mode = "single-detail-mode";
+            continue;
+        }
+        if (arg === "--list-detail-mode") {
+            mode = "list-detail-mode";
+            continue;
+        }
+        if (arg === "--mode") {
+            const next = argv[index + 1];
+            const parsed = parseMode(next);
+            if (parsed === undefined) {
+                throw new Error(`Unsupported explorer demo mode: ${next ?? ""}`);
+            }
+            mode = parsed;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith("--mode=")) {
+            const parsed = parseMode(arg.slice("--mode=".length));
+            if (parsed === undefined) {
+                throw new Error(`Unsupported explorer demo mode: ${arg.slice("--mode=".length)}`);
+            }
+            mode = parsed;
+        }
+    }
+    return { mode, slowDetail };
+}
+export function buildExplorerDemoConfig(options) {
+    const rows = options.mode === "single-detail-mode" ? singleDetailRows : reviewRows;
+    const detail = options.mode === "single-detail-mode"
+        ? buildSingleDetail(options.slowDetail)
+        : buildReviewDetail(options.slowDetail);
+    return {
+        title: `Explorer Demo - ${options.mode}`,
+        rows: async () => rows,
+        detail,
+        actions: demoActions(),
+        reorder: {
+            onReorder: options.onReorder ?? (() => undefined)
+        },
+        multiSelect: true,
+        emptyHint: "No rows match the current filter"
+    };
+}
+export async function main() {
+    const options = parseExplorerDemoOptions();
+    await runExplorer(buildExplorerDemoConfig(options));
+}
+function buildSingleDetail(slowDetail) {
+    return {
+        items: async (row, ctx) => {
+            await delayDetailIfNeeded(slowDetail, ctx);
+            const markdown = singleDetailMarkdown[row.id] ?? `# ${row.title}\n\nNo demo detail is available.`;
+            return [{ id: row.id, render: () => markdown }];
+        }
+    };
+}
+function buildReviewDetail(slowDetail) {
+    return {
+        items: async (row, ctx) => {
+            await delayDetailIfNeeded(slowDetail, ctx);
+            const comments = reviewComments[row.id] ?? [];
+            return comments.map((comment) => ({
+                id: comment.id,
+                title: comment.title,
+                subtitle: comment.subtitle,
+                badge: { text: "comment", tone: comment.tone },
+                render: () => comment.body
+            }));
+        },
+        actions: [
+            {
+                id: "resolve-comment",
+                label: "Resolve comment",
+                key: "x",
+                showInFooter: true,
+                handler: (ctx) => {
+                    ctx.toast(`Resolved ${ctx.item?.title ?? ctx.row.title}`, "success");
+                }
+            }
+        ]
+    };
+}
+function demoActions() {
+    return [
+        {
+            id: "open",
+            label: "Open",
+            primary: true,
+            showInFooter: true,
+            handler: (ctx) => {
+                ctx.toast(`Opened ${ctx.row.title}`, "info");
+            }
+        },
+        {
+            id: "refresh",
+            label: "Refresh",
+            key: "r",
+            showInFooter: true,
+            handler: async (ctx) => {
+                await ctx.refresh();
+                ctx.toast("Rows refreshed", "success");
+            }
+        },
+        {
+            id: "archive",
+            label: () => "Archive selected",
+            key: "a",
+            destructive: true,
+            showInFooter: true,
+            handler: (ctx) => {
+                ctx.toast(`Archived ${ctx.rows.length} row${ctx.rows.length === 1 ? "" : "s"}`, "warning");
+            }
+        }
+    ];
+}
+async function delayDetailIfNeeded(slowDetail, ctx) {
+    if (!slowDetail) {
+        return;
+    }
+    await new Promise((resolve) => {
+        const timeout = setTimeout(resolve, detailDelayMs);
+        ctx.signal.addEventListener("abort", () => {
+            clearTimeout(timeout);
+            resolve();
+        }, { once: true });
+    });
+}
+function parseMode(value) {
+    if (value === "single-detail-mode" || value === "list-detail-mode") {
+        return value;
+    }
+    return undefined;
+}
+function isTruthy(value) {
+    return value === undefined ? false : truthyEnvValues.has(value.toLowerCase());
+}
+const entry = process.argv[1];
+const isMain = typeof entry === "string" && path.resolve(entry) === fileURLToPath(import.meta.url);
+if (isMain) {
+    main().catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`${message}\n`);
+        process.exitCode = 1;
+    });
+}