toolcraft 0.0.16 → 0.0.18

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

@@ -0,0 +1,61 @@
+import type { KeypressEvent } from "../dashboard/terminal.js";
+import type { Action, DetailItem, Row } from "./state.js";
+export type Effect = {
+    type: "renderDetail";
+    rowId: string;
+    token: number;
+} | {
+    type: "exit";
+    result: unknown;
+    after?: () => Promise<void>;
+} | {
+    type: "suspend";
+    fn: () => Promise<unknown>;
+    resumeWith: (value: unknown) => ExplorerEvent;
+} | {
+    type: "persistOrder";
+    orderedIds: string[];
+};
+export type ExplorerEvent = {
+    type: "key";
+    key: KeypressEvent;
+} | {
+    type: "resize";
+    cols: number;
+    rows: number;
+} | {
+    type: "rowsLoaded";
+    rows: Row[];
+} | {
+    type: "detailLoading";
+    rowId: string;
+    token: number;
+} | {
+    type: "detailLoaded";
+    rowId: string;
+    token: number;
+    items: DetailItem[];
+} | {
+    type: "detailError";
+    rowId: string;
+    token: number;
+    error: Error;
+} | {
+    type: "actionResolved";
+    actionId: string;
+} | {
+    type: "toastExpired";
+} | {
+    type: "suspendResumed";
+    value: unknown;
+    emit: ExplorerEvent;
+} | {
+    type: "modalDismissed";
+    result: unknown;
+};
+export type ConfirmModal = {
+    kind: "confirm";
+    action: Action<unknown>;
+    rows: Row[];
+    resolver: (ok: boolean) => void;
+};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,10 @@
+import type { Row } from "./state.js";
+export interface FilterMatch {
+    index: number;
+    score: number;
+    positions: number[];
+}
+export interface FilterRowsOptions {
+    caseSensitive?: boolean;
+}
+export declare function filterRows(query: string, rows: readonly Row[], opts?: FilterRowsOptions): FilterMatch[];

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

@@ -0,0 +1,95 @@
+const MATCH_SCORE = 10;
+const CONSECUTIVE_BONUS = 14;
+const WORD_START_BONUS = 10;
+const EARLY_MATCH_BONUS = 3;
+export function filterRows(query, rows, opts = {}) {
+    if (query.length === 0) {
+        return rows.map((_, index) => ({ index, score: 0, positions: [] }));
+    }
+    const preparedQuery = opts.caseSensitive === true ? query : query.toLocaleLowerCase();
+    const matches = [];
+    rows.forEach((row, index) => {
+        const text = searchableText(row);
+        const preparedText = opts.caseSensitive === true ? text : text.toLocaleLowerCase();
+        const match = matchSubsequence(preparedQuery, preparedText);
+        if (match !== undefined) {
+            matches.push({ index, ...match });
+        }
+    });
+    return matches.sort((left, right) => right.score - left.score || left.index - right.index);
+}
+function searchableText(row) {
+    return [row.title, row.subtitle]
+        .filter((value) => value !== undefined)
+        .map(stripAnsi)
+        .join(" ");
+}
+function stripAnsi(value) {
+    return value.replace(/\u001b\[[0-9;]*m/g, "");
+}
+function matchSubsequence(query, text) {
+    let previousStates = [];
+    for (let queryIndex = 0; queryIndex < query.length; queryIndex += 1) {
+        const states = [];
+        for (let textIndex = 0; textIndex < text.length; textIndex += 1) {
+            if (text[textIndex] !== query[queryIndex]) {
+                continue;
+            }
+            if (queryIndex === 0) {
+                states[textIndex] = {
+                    score: characterScore(text, textIndex, undefined) + Math.max(0, EARLY_MATCH_BONUS - textIndex),
+                    positions: [textIndex]
+                };
+                continue;
+            }
+            for (let previousIndex = 0; previousIndex < textIndex; previousIndex += 1) {
+                const previous = previousStates[previousIndex];
+                if (previous === undefined) {
+                    continue;
+                }
+                const next = {
+                    score: previous.score + characterScore(text, textIndex, previousIndex),
+                    positions: [...previous.positions, textIndex]
+                };
+                if (isBetterMatch(next, states[textIndex])) {
+                    states[textIndex] = next;
+                }
+            }
+        }
+        previousStates = states;
+        if (!previousStates.some((state) => state !== undefined)) {
+            return undefined;
+        }
+    }
+    return previousStates.reduce((best, state) => (state !== undefined && isBetterMatch(state, best) ? state : best), undefined);
+}
+function characterScore(text, index, previousIndex) {
+    let score = MATCH_SCORE;
+    if (previousIndex !== undefined && index === previousIndex + 1) {
+        score += CONSECUTIVE_BONUS;
+    }
+    if (isWordStart(text, index)) {
+        score += WORD_START_BONUS;
+    }
+    return score;
+}
+function isBetterMatch(candidate, current) {
+    if (current === undefined || candidate.score !== current.score) {
+        return current === undefined || candidate.score > current.score;
+    }
+    for (let index = 0; index < candidate.positions.length; index += 1) {
+        const position = candidate.positions[index];
+        const currentPosition = current.positions[index] ?? Number.POSITIVE_INFINITY;
+        if (position !== currentPosition) {
+            return position < currentPosition;
+        }
+    }
+    return false;
+}
+function isWordStart(text, index) {
+    if (index === 0) {
+        return true;
+    }
+    const previous = text[index - 1];
+    return (previous === " " || previous === "-" || previous === "_" || previous === "/" || previous === ".");
+}

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

@@ -0,0 +1,8 @@
+import type { Detail, DetailCtx, Row } from "./state.js";
+export { runExplorer } from "./runtime.js";
+export { createInitialState } from "./state.js";
+export { resolveBindings } from "./keymap.js";
+export type { Effect, ExplorerEvent } from "./events.js";
+export type { BindingTarget, ExplorerBindingDefaults, ExplorerBuiltinCommand, ResolvedBindings } from "./keymap.js";
+export type { Action, ActionContext, Detail, DetailCtx, DetailItem, Dirty, ExplorerConfig, ExplorerLayoutMode, ExplorerSize, ExplorerState, Row, Tone } from "./state.js";
+export declare function singleDetail<R>(fn: (row: Row, ctx: DetailCtx) => string | Promise<string>): Detail<R>;

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

@@ -0,0 +1,8 @@
+export { runExplorer } from "./runtime.js";
+export { createInitialState } from "./state.js";
+export { resolveBindings } from "./keymap.js";
+export function singleDetail(fn) {
+    return {
+        items: async (row) => [{ id: row.id, render: ctx => fn(row, ctx) }]
+    };
+}

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

@@ -0,0 +1,7 @@
+import type { ExplorerEvent } from "./events.js";
+import type { DetailCtx, DetailItem } from "./state.js";
+export declare const LOADING_INDICATOR_MS = 150;
+export declare function createDetailJobs(emit: (event: ExplorerEvent) => void): {
+    schedule: (rowId: string, items: (ctx: DetailCtx) => Promise<DetailItem[]>, ctx: DetailCtx) => Promise<void>;
+    abort: () => void;
+};

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

@@ -0,0 +1,59 @@
+export const LOADING_INDICATOR_MS = 150;
+export function createDetailJobs(emit) {
+    let token = 0;
+    let current = null;
+    const abortedTokens = new Set();
+    return {
+        async schedule(rowId, items, ctx) {
+            if (current !== null) {
+                current.controller.abort();
+                clearTimeout(current.loadingTimer);
+            }
+            const nextToken = ++token;
+            const controller = new AbortController();
+            let finished = false;
+            const loadingTimer = setTimeout(() => {
+                if (!finished && !abortedTokens.has(nextToken)) {
+                    emit({ type: "detailLoading", rowId, token: nextToken });
+                }
+            }, LOADING_INDICATOR_MS);
+            current = { controller, loadingTimer, token: nextToken };
+            try {
+                const loadedItems = await items({ ...ctx, signal: controller.signal });
+                finished = true;
+                if (!abortedTokens.has(nextToken)) {
+                    emit({ type: "detailLoaded", rowId, token: nextToken, items: loadedItems });
+                }
+            }
+            catch (error) {
+                finished = true;
+                if (!abortedTokens.has(nextToken)) {
+                    emit({ type: "detailError", rowId, token: nextToken, error: toError(error) });
+                }
+            }
+            finally {
+                finished = true;
+                clearTimeout(loadingTimer);
+                abortedTokens.delete(nextToken);
+                if (current?.controller === controller) {
+                    current = null;
+                }
+            }
+        },
+        abort() {
+            if (current === null) {
+                return;
+            }
+            current.controller.abort();
+            clearTimeout(current.loadingTimer);
+            abortedTokens.add(current.token);
+            current = null;
+        }
+    };
+}
+function toError(error) {
+    if (error instanceof Error) {
+        return error;
+    }
+    return new Error(String(error));
+}

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

@@ -0,0 +1,21 @@
+import type { ExplorerEvent } from "./events.js";
+import type { ExplorerConfig } from "./state.js";
+export type ExplorerBuiltinCommand = "quit" | "filter" | "help" | "palette" | "cursorUp" | "cursorDown" | "top" | "bottom" | "pageUp" | "pageDown" | "focusNext" | "escape" | "confirm" | "toggleSelect" | "selectAll" | "clearSelection" | "detailScrollDown" | "detailScrollUp" | "extendSelectionUp" | "extendSelectionDown" | "reorderUp" | "reorderDown";
+export type BindingTarget = {
+    type: "builtin";
+    id: ExplorerBuiltinCommand;
+} | {
+    type: "action";
+    id: string;
+};
+type ExplorerKeypressEvent = Extract<ExplorerEvent, {
+    type: "key";
+}>["key"];
+export interface ResolvedBindings {
+    bindings: ReadonlyMap<string, BindingTarget>;
+    keysByTarget: ReadonlyMap<string, readonly string[]>;
+    resolve: (event: ExplorerKeypressEvent) => BindingTarget | undefined;
+}
+export type ExplorerBindingDefaults = Partial<Record<ExplorerBuiltinCommand, string[]>>;
+export declare function resolveBindings<R>(config: ExplorerConfig<R>, defaults?: ExplorerBindingDefaults): ResolvedBindings;
+export {};

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

@@ -0,0 +1,363 @@
+const builtinBindings = {
+    quit: ["q", "Ctrl+c"],
+    filter: ["/"],
+    help: ["?"],
+    palette: ["Ctrl+p", "Ctrl+k"],
+    cursorUp: ["up", "k"],
+    cursorDown: ["down", "j"],
+    top: ["home", "gg"],
+    bottom: ["end", "G"],
+    pageUp: ["Ctrl+u"],
+    pageDown: ["Ctrl+d"],
+    focusNext: ["tab"],
+    escape: ["escape"],
+    confirm: ["return", "enter"],
+    toggleSelect: ["space"],
+    selectAll: ["Ctrl+a"],
+    clearSelection: ["Ctrl+/"],
+    detailScrollDown: ["Ctrl+f"],
+    detailScrollUp: ["Ctrl+b"],
+    extendSelectionUp: ["Shift+up"],
+    extendSelectionDown: ["Shift+down"],
+    reorderUp: ["Ctrl+up", "K"],
+    reorderDown: ["Ctrl+down", "J"]
+};
+const baseBuiltinCommands = [
+    "quit",
+    "filter",
+    "help",
+    "palette",
+    "cursorUp",
+    "cursorDown",
+    "top",
+    "bottom",
+    "pageUp",
+    "pageDown",
+    "focusNext",
+    "escape",
+    "confirm",
+    "toggleSelect",
+    "selectAll",
+    "clearSelection",
+    "detailScrollDown",
+    "detailScrollUp",
+    "extendSelectionUp",
+    "extendSelectionDown"
+];
+const reorderCommands = ["reorderUp", "reorderDown"];
+const reservedActionIds = new Set(["quit"]);
+export function resolveBindings(config, defaults = {}) {
+    const commands = config.reorder === undefined
+        ? baseBuiltinCommands
+        : [...baseBuiltinCommands, ...reorderCommands];
+    const commandBindings = new Map();
+    const flatBindings = new Map();
+    const targetKeys = new Map();
+    const targetsByCommand = new Map();
+    const claimed = new Map();
+    const conflicts = new Map();
+    for (const command of commands) {
+        const target = { type: "builtin", id: command };
+        const keys = command === "quit"
+            ? builtinBindings.quit
+            : defaults[command] ?? builtinBindings[command];
+        addBindings({
+            keys,
+            owner: command,
+            commandId: `builtin:${command}`,
+            target,
+            commandBindings,
+            flatBindings,
+            targetKeys,
+            targetsByCommand,
+            claimed,
+            conflicts,
+            warn: false
+        });
+    }
+    for (const action of [...config.actions, ...(config.detail.actions ?? [])]) {
+        if (reservedActionIds.has(action.id)) {
+            continue;
+        }
+        const keys = toBindingArray(config.keybindOverrides?.[action.id] ?? action.key);
+        addBindings({
+            keys,
+            owner: action.id,
+            commandId: `action:${action.id}`,
+            target: { type: "action", id: action.id },
+            commandBindings,
+            flatBindings,
+            targetKeys,
+            targetsByCommand,
+            claimed,
+            conflicts,
+            warn: true
+        });
+    }
+    if (process.env.NODE_ENV !== "production") {
+        for (const warning of conflicts.values()) {
+            process.stderr.write(`${warning}\n`);
+        }
+    }
+    const commandIds = Array.from(commandBindings.keys());
+    const defaultKeymapBindings = Object.fromEntries(Array.from(commandBindings.entries()));
+    const resolveCommand = createKeymap(commandIds, defaultKeymapBindings);
+    return {
+        bindings: flatBindings,
+        keysByTarget: targetKeys,
+        resolve: (event) => {
+            const command = resolveCommand(event);
+            return command === undefined ? undefined : targetsByCommand.get(command);
+        }
+    };
+}
+function addBindings(opts) {
+    const accepted = [];
+    for (const key of opts.keys) {
+        const canonical = canonicalizeBinding(key);
+        if (canonical === undefined) {
+            continue;
+        }
+        const existing = opts.claimed.get(canonical);
+        if (existing !== undefined) {
+            if (existing !== opts.owner && opts.warn) {
+                opts.conflicts.set(`${opts.owner}:${canonical}`, `Explorer key binding conflict: ${key} for ${opts.owner} is already bound to ${existing}`);
+            }
+            continue;
+        }
+        opts.claimed.set(canonical, opts.owner);
+        opts.flatBindings.set(canonical, opts.target);
+        accepted.push(key);
+    }
+    if (accepted.length > 0) {
+        opts.commandBindings.set(opts.commandId, accepted);
+        opts.targetKeys.set(targetKey(opts.target), accepted);
+        opts.targetsByCommand.set(opts.commandId, opts.target);
+    }
+    return accepted;
+}
+function targetKey(target) {
+    return `${target.type}:${target.id}`;
+}
+function toBindingArray(value) {
+    if (value === undefined) {
+        return [];
+    }
+    return Array.isArray(value) ? value : [value];
+}
+function createKeymap(commands, defaultBindings) {
+    const bindings = new Map();
+    const sequences = new Set();
+    let pendingSequence = "";
+    for (const command of commands) {
+        const commandBindings = defaultBindings[command]
+            .map(parseBinding)
+            .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) {
+            const commandBindings = bindings.get(command);
+            if (commandBindings?.some((binding) => matchesSingleKey(binding, event))) {
+                pendingSequence = "";
+                return command;
+            }
+        }
+        const token = eventToSequenceToken(event);
+        if (token === undefined) {
+            pendingSequence = "";
+            return undefined;
+        }
+        pendingSequence = `${pendingSequence}${token}`;
+        for (const command of commands) {
+            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;
+    };
+}
+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();
+    if (value.length === 0) {
+        return undefined;
+    }
+    const parts = value.split("+").map((part) => part.trim()).filter(Boolean);
+    if (parts.length === 0) {
+        return undefined;
+    }
+    let ctrl = false;
+    let meta = false;
+    let shift = false;
+    const key = parts.at(-1);
+    if (key === undefined) {
+        return undefined;
+    }
+    for (const modifier of parts.slice(0, -1)) {
+        const normalized = modifier.toLowerCase();
+        if (normalized === "ctrl" || normalized === "control") {
+            ctrl = true;
+            continue;
+        }
+        if (normalized === "meta" || normalized === "alt") {
+            meta = true;
+            continue;
+        }
+        if (normalized === "shift") {
+            shift = true;
+        }
+    }
+    const normalizedKey = normalizeKeyName(key);
+    if (parts.length === 1 && isShiftedCharacter(normalizedKey)) {
+        shift = true;
+    }
+    if (normalizedKey.length === 1) {
+        return {
+            ch: normalizeBindingCharacter(normalizedKey, shift),
+            ctrl,
+            meta,
+            shift
+        };
+    }
+    if (!ctrl &&
+        !meta &&
+        !shift &&
+        !isNamedKey(normalizedKey) &&
+        isPrintableSequence(normalizedKey)) {
+        return {
+            sequence: normalizedKey,
+            ctrl,
+            meta,
+            shift
+        };
+    }
+    return {
+        name: normalizedKey.toLowerCase(),
+        ctrl,
+        meta,
+        shift
+    };
+}
+function matchesSingleKey(binding, event) {
+    if (binding.sequence !== undefined) {
+        return false;
+    }
+    if (binding.ctrl !== event.ctrl ||
+        binding.meta !== event.meta ||
+        binding.shift !== event.shift) {
+        return false;
+    }
+    if (binding.ch !== undefined) {
+        if (binding.ch === " " && event.name === "space") {
+            return true;
+        }
+        return event.ch === binding.ch || event.name === binding.ch.toLowerCase();
+    }
+    if (binding.name !== undefined) {
+        return event.name === binding.name;
+    }
+    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;
+}
+function normalizeBindingCharacter(value, shift) {
+    if (!shift || value.toLowerCase() === value.toUpperCase()) {
+        return value;
+    }
+    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/explorer/layout.d.ts

@@ -0,0 +1,20 @@
+export type ExplorerLayoutMode = "wide" | "medium" | "narrow-vertical" | "narrow-list-only" | "too-narrow";
+export interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface ExplorerLayoutOptions {
+    cols: number;
+    rows: number;
+    detailHidden?: boolean;
+}
+export interface ExplorerLayout {
+    mode: ExplorerLayoutMode;
+    header: Rect;
+    list: Rect;
+    detail: Rect;
+    footer: Rect;
+}
+export declare function computeExplorerLayout(opts: ExplorerLayoutOptions): ExplorerLayout;