terminal-pilot 0.0.32 → 0.0.34

package/node_modules/toolcraft-design/dist/explorer/two-pane.js

@@ -0,0 +1,510 @@
+import { ScreenBuffer, cellToAnsi } from "../dashboard/buffer.js";
+import { createTerminalDriver } from "../dashboard/terminal.js";
+const TOAST_MS = 2500;
+export async function runTwoPaneExplorer(config) {
+    if (process.stdout.isTTY !== true) {
+        throw new Error("two-pane explorer requires a TTY");
+    }
+    return new TwoPaneExplorerRuntime(config, createTerminalDriver()).run();
+}
+export class TwoPaneExplorerRuntime {
+    config;
+    driver;
+    state;
+    unsubscribeKeypress;
+    unsubscribeResize;
+    toastTimer;
+    stopped = false;
+    rowsRequestToken = 0;
+    settle;
+    constructor(config, driver) {
+        this.config = config;
+        this.driver = driver;
+        const size = normalizeSize(driver.getSize());
+        this.state = {
+            title: config.title,
+            panes: [
+                initialPaneState(config.panes[0]),
+                initialPaneState(config.panes[1])
+            ],
+            activePaneIndex: 0,
+            filterFocused: false,
+            toast: null,
+            size
+        };
+    }
+    run() {
+        return new Promise((resolve, reject) => {
+            this.settle = { resolve, reject };
+            try {
+                this.startTerminal();
+                this.render();
+                this.loadRows().catch((error) => this.fail(error));
+            }
+            catch (error) {
+                this.fail(error);
+            }
+        });
+    }
+    startTerminal() {
+        this.driver.enterRawMode();
+        this.driver.enterAltScreen();
+        this.driver.disableLineWrap();
+        this.driver.hideCursor();
+        this.subscribeKeypress();
+        this.unsubscribeResize = this.driver.onResize(() => {
+            this.state = { ...this.state, size: normalizeSize(this.driver.getSize()) };
+            this.render();
+        });
+    }
+    subscribeKeypress() {
+        this.unsubscribeKeypress = this.driver.onKeypress((key) => {
+            this.dispatchKey(key);
+        });
+    }
+    pauseKeypress() {
+        this.unsubscribeKeypress?.();
+        this.unsubscribeKeypress = undefined;
+    }
+    async loadRows(requestToken = ++this.rowsRequestToken) {
+        const [leftRows, rightRows] = await Promise.all([
+            this.config.panes[0].rows(),
+            this.config.panes[1].rows()
+        ]);
+        if (requestToken !== this.rowsRequestToken) {
+            return;
+        }
+        this.state = {
+            ...this.state,
+            panes: [
+                rowsLoaded(this.state.panes[0], leftRows),
+                rowsLoaded(this.state.panes[1], rightRows)
+            ]
+        };
+        this.render();
+    }
+    async refresh() {
+        await this.config.refresh?.();
+        await this.loadRows(++this.rowsRequestToken);
+    }
+    dispatchKey(key) {
+        if (this.stopped) {
+            return;
+        }
+        this.trace("key", {
+            key: traceKey(key),
+            filterFocused: this.state.filterFocused,
+            pane: this.activePane().id,
+            cursor: this.activePane().cursor,
+            selected: this.activePane().selected.size,
+            filter: this.activePane().filter
+        });
+        if (this.state.filterFocused) {
+            this.dispatchFilterKey(key);
+            return;
+        }
+        if (isQuitKey(key)) {
+            this.exit(null);
+            return;
+        }
+        if (isTabKey(key)) {
+            this.state = {
+                ...this.state,
+                activePaneIndex: this.state.activePaneIndex === 0 ? 1 : 0
+            };
+            this.render();
+            return;
+        }
+        if (key.name === "up" || key.name === "down") {
+            this.moveCursor(key.name === "up" ? -1 : 1);
+            return;
+        }
+        if (key.name === "home") {
+            this.setCursor(0);
+            return;
+        }
+        if (key.name === "end") {
+            this.setCursor(filteredRows(this.activePane()).length - 1);
+            return;
+        }
+        if (key.ch === " " || key.name === "space") {
+            this.toggleSelection();
+            return;
+        }
+        if (key.ch === "/") {
+            this.state = {
+                ...this.state,
+                filterFocused: true,
+                panes: updateActivePane(this.state, (pane) => ({ ...pane, filter: "", cursor: 0 }))
+            };
+            this.render();
+            return;
+        }
+        const action = this.config.actions.find((candidate) => actionMatchesKey(candidate, key));
+        if (action !== undefined) {
+            this.runAction(action);
+        }
+    }
+    dispatchFilterKey(key) {
+        if (key.name === "escape" || key.name === "return" || key.name === "enter") {
+            this.state = { ...this.state, filterFocused: false };
+            this.trace("filter.submit", {
+                key: traceKey(key),
+                pane: this.activePane().id,
+                filter: this.activePane().filter,
+                rows: filteredRows(this.activePane()).length
+            });
+            this.render();
+            return;
+        }
+        if (key.name === "backspace") {
+            this.state = {
+                ...this.state,
+                panes: updateActivePane(this.state, (pane) => ({
+                    ...pane,
+                    filter: Array.from(pane.filter).slice(0, -1).join(""),
+                    cursor: 0
+                }))
+            };
+            this.trace("filter.update", {
+                key: traceKey(key),
+                pane: this.activePane().id,
+                filter: this.activePane().filter,
+                rows: filteredRows(this.activePane()).length
+            });
+            this.render();
+            return;
+        }
+        if (key.ch !== undefined && key.ch.length > 0 && key.ch !== "/") {
+            this.state = {
+                ...this.state,
+                panes: updateActivePane(this.state, (pane) => ({
+                    ...pane,
+                    filter: `${pane.filter}${key.ch}`,
+                    cursor: 0
+                }))
+            };
+            this.trace("filter.update", {
+                key: traceKey(key),
+                pane: this.activePane().id,
+                filter: this.activePane().filter,
+                rows: filteredRows(this.activePane()).length
+            });
+            this.render();
+        }
+    }
+    moveCursor(delta) {
+        const pane = this.activePane();
+        const rows = filteredRows(pane);
+        if (rows.length === 0) {
+            return;
+        }
+        this.setCursor(Math.max(0, Math.min(rows.length - 1, pane.cursor + delta)));
+    }
+    setCursor(cursor) {
+        this.state = {
+            ...this.state,
+            panes: updateActivePane(this.state, (pane) => ({
+                ...pane,
+                cursor: Math.max(0, cursor)
+            }))
+        };
+        this.render();
+    }
+    toggleSelection() {
+        const pane = this.activePane();
+        const row = currentRow(pane);
+        if (row === undefined) {
+            return;
+        }
+        const selected = new Set(pane.selected);
+        if (selected.has(row.id)) {
+            selected.delete(row.id);
+        }
+        else {
+            selected.add(row.id);
+        }
+        this.state = {
+            ...this.state,
+            panes: updateActivePane(this.state, (candidate) => ({ ...candidate, selected }))
+        };
+        this.trace("selection.toggle", {
+            pane: pane.id,
+            row: row.id,
+            selected: selected.size,
+            checked: selected.has(row.id),
+            filter: pane.filter,
+            cursor: pane.cursor
+        });
+        this.render();
+    }
+    runAction(action) {
+        const activePane = this.activePane();
+        const inactivePane = this.inactivePane();
+        const row = currentRow(activePane);
+        if (row === undefined) {
+            this.showToast("Select an item first", "warning");
+            return;
+        }
+        const selectedRows = activePane.rows.filter((candidate) => activePane.selected.has(candidate.id));
+        const context = {
+            activePane,
+            inactivePane,
+            row,
+            rows: selectedRows.length > 0 ? selectedRows : [row],
+            refresh: async () => this.refresh(),
+            suspendAnd: async (fn) => this.suspendAnd(fn),
+            toast: (message, tone) => this.showToast(message, tone),
+            exit: (result) => this.exit(result ?? null)
+        };
+        Promise.resolve()
+            .then(() => action.handler(context))
+            .catch((error) => {
+            this.showToast(error instanceof Error ? error.message : "Action failed", "error");
+        });
+    }
+    async suspendAnd(fn) {
+        this.pauseKeypress();
+        this.driver.exitAltScreen();
+        this.driver.enableLineWrap();
+        this.driver.showCursor();
+        this.driver.exitRawMode();
+        try {
+            return await fn();
+        }
+        finally {
+            if (!this.stopped) {
+                this.driver.enterRawMode();
+                this.driver.enterAltScreen();
+                this.driver.disableLineWrap();
+                this.driver.hideCursor();
+                this.subscribeKeypress();
+                this.state = { ...this.state, size: normalizeSize(this.driver.getSize()) };
+                this.render();
+            }
+        }
+    }
+    showToast(message, tone = "info") {
+        if (this.toastTimer !== undefined) {
+            clearTimeout(this.toastTimer);
+        }
+        this.state = { ...this.state, toast: { message, tone } };
+        this.render();
+        this.toastTimer = setTimeout(() => {
+            this.state = { ...this.state, toast: null };
+            this.render();
+        }, TOAST_MS);
+    }
+    activePane() {
+        return this.state.panes[this.state.activePaneIndex];
+    }
+    inactivePane() {
+        return this.state.panes[this.state.activePaneIndex === 0 ? 1 : 0];
+    }
+    render() {
+        if (this.stopped) {
+            return;
+        }
+        const size = normalizeSize(this.driver.getSize());
+        if (size.cols !== this.state.size.cols || size.rows !== this.state.size.rows) {
+            this.state = { ...this.state, size };
+        }
+        const next = new ScreenBuffer(this.state.size.cols, this.state.size.rows);
+        renderTwoPaneExplorer(this.state, this.config.actions, next);
+        this.driver.write(screenToAnsi(next));
+    }
+    exit(result) {
+        if (this.stopped) {
+            return;
+        }
+        this.stopped = true;
+        this.unsubscribeKeypress?.();
+        this.unsubscribeResize?.();
+        if (this.toastTimer !== undefined) {
+            clearTimeout(this.toastTimer);
+        }
+        this.driver.destroy();
+        this.settle?.resolve(result);
+    }
+    fail(error) {
+        if (!this.stopped) {
+            this.stopped = true;
+            this.driver.destroy();
+        }
+        this.settle?.reject(error);
+    }
+    trace(event, fields = {}) {
+        const trace = this.config.trace;
+        if (trace === undefined) {
+            return;
+        }
+        void Promise.resolve(trace({ event, ...fields })).catch(() => {
+            // Diagnostic tracing must not interfere with TUI input handling.
+        });
+    }
+}
+export function renderTwoPaneExplorer(state, actions, screen) {
+    screen.clear();
+    if (state.size.cols < 60 || state.size.rows < 8) {
+        screen.put(0, 0, fit(` ${state.title} `, state.size.cols), { bold: true });
+        screen.put(0, 2, fit("Terminal is too small for two-pane view.", state.size.cols));
+        screen.put(0, state.size.rows - 1, fit("q quit", state.size.cols), { dim: true });
+        return;
+    }
+    const gap = 1;
+    const paneWidth = Math.floor((state.size.cols - gap) / 2);
+    const rightWidth = state.size.cols - paneWidth - gap;
+    const paneHeight = Math.max(5, state.size.rows - 2);
+    renderPane(screen, state.panes[0], {
+        x: 0,
+        y: 0,
+        width: paneWidth,
+        height: paneHeight,
+        active: state.activePaneIndex === 0
+    });
+    renderPane(screen, state.panes[1], {
+        x: paneWidth + gap,
+        y: 0,
+        width: rightWidth,
+        height: paneHeight,
+        active: state.activePaneIndex === 1
+    });
+    renderFooter(screen, state, actions, state.size.rows - 2);
+    if (state.toast !== null) {
+        screen.put(0, state.size.rows - 1, fit(` ${state.toast.message} `, state.size.cols), toneStyle(state.toast.tone));
+    }
+}
+function renderPane(screen, pane, layout) {
+    const borderStyle = layout.active ? { bold: true, fg: "cyan" } : { dim: true };
+    const title = `${layout.active ? ">" : " "} ${pane.title}`;
+    screen.put(layout.x, layout.y, `+${fit(title, layout.width - 2, "-")}+`, borderStyle);
+    for (let y = 1; y < layout.height - 1; y += 1) {
+        screen.put(layout.x, layout.y + y, "|", borderStyle);
+        screen.put(layout.x + layout.width - 1, layout.y + y, "|", borderStyle);
+    }
+    const filterLabel = pane.filter.length > 0 ? ` /${pane.filter}` : "";
+    screen.put(layout.x, layout.y + layout.height - 1, `+${fit(`${pane.selected.size} selected${filterLabel}`, layout.width - 2, "-")}+`, borderStyle);
+    const visibleRows = filteredRows(pane);
+    const bodyHeight = layout.height - 2;
+    if (visibleRows.length === 0) {
+        screen.put(layout.x + 2, layout.y + 2, fit(pane.emptyHint, Math.max(0, layout.width - 4)), { dim: true });
+        return;
+    }
+    const start = Math.max(0, Math.min(pane.cursor - Math.floor(bodyHeight / 2), visibleRows.length - bodyHeight));
+    for (let index = 0; index < bodyHeight; index += 1) {
+        const row = visibleRows[start + index];
+        if (row === undefined) {
+            continue;
+        }
+        const selected = pane.selected.has(row.id);
+        const cursor = start + index === pane.cursor;
+        const marker = selected ? "*" : " ";
+        const pointer = cursor && layout.active ? ">" : " ";
+        const badge = row.badge ? ` [${row.badge.text}]` : "";
+        const subtitle = row.subtitle ? ` ${row.subtitle}` : "";
+        const style = cursor && layout.active ? { inverse: true } : {};
+        screen.put(layout.x + 1, layout.y + 1 + index, fit(`${pointer}${marker} ${row.title}${badge}${subtitle}`, layout.width - 2), style);
+    }
+}
+function renderFooter(screen, state, actions, y) {
+    const actionHelp = actions.map((action) => `${firstKey(action.key)} ${action.label}`).join("   ");
+    const filter = state.filterFocused ? "search: typing, enter done" : "/ search";
+    const text = `tab pane   ${filter}   space select   ${actionHelp}   q quit`;
+    screen.put(0, y, fit(text, state.size.cols), { dim: true });
+}
+function initialPaneState(definition) {
+    return {
+        id: definition.id,
+        title: definition.title,
+        rows: [],
+        cursor: 0,
+        selected: new Set(),
+        filter: "",
+        emptyHint: definition.emptyHint ?? "No items"
+    };
+}
+function rowsLoaded(pane, rows) {
+    const ids = new Set(rows.map((row) => row.id));
+    return {
+        ...pane,
+        rows,
+        selected: new Set([...pane.selected].filter((id) => ids.has(id))),
+        cursor: Math.max(0, Math.min(pane.cursor, Math.max(0, filteredRows({ ...pane, rows }).length - 1)))
+    };
+}
+function filteredRows(pane) {
+    const query = pane.filter.trim().toLowerCase();
+    if (query.length === 0) {
+        return pane.rows;
+    }
+    return pane.rows.filter((row) => {
+        const haystack = `${row.title} ${row.subtitle ?? ""} ${row.badge?.text ?? ""}`.toLowerCase();
+        return haystack.includes(query);
+    });
+}
+function currentRow(pane) {
+    return filteredRows(pane)[pane.cursor];
+}
+function updateActivePane(state, update) {
+    return state.activePaneIndex === 0
+        ? [update(state.panes[0]), state.panes[1]]
+        : [state.panes[0], update(state.panes[1])];
+}
+function actionMatchesKey(action, key) {
+    const keys = Array.isArray(action.key) ? action.key : [action.key];
+    return keys.some((candidate) => key.ch === candidate || key.name === candidate);
+}
+function isTabKey(key) {
+    return key.name === "tab" || key.ch === "\t" || (key.name === "i" && key.ctrl);
+}
+function firstKey(key) {
+    return Array.isArray(key) ? key[0] ?? "" : key;
+}
+function traceKey(key) {
+    return {
+        name: key.name,
+        ch: key.ch,
+        ctrl: key.ctrl,
+        meta: key.meta,
+        shift: key.shift
+    };
+}
+function isQuitKey(key) {
+    return key.ch === "q" || (key.name === "c" && key.ctrl);
+}
+function normalizeSize(size) {
+    return {
+        cols: Math.max(0, Math.floor(size.cols)),
+        rows: Math.max(0, Math.floor(size.rows))
+    };
+}
+function fit(text, width, pad = " ") {
+    if (width <= 0) {
+        return "";
+    }
+    const normalized = text.length > width ? text.slice(0, width) : text;
+    return normalized.padEnd(width, pad);
+}
+function toneStyle(tone) {
+    if (tone === "success") {
+        return { fg: "green", bold: true };
+    }
+    if (tone === "warning") {
+        return { fg: "yellow", bold: true };
+    }
+    if (tone === "error") {
+        return { fg: "red", bold: true };
+    }
+    return tone === "muted" ? { dim: true } : { fg: "cyan", bold: true };
+}
+function screenToAnsi(screen) {
+    let output = "";
+    for (let y = 0; y < screen.height; y += 1) {
+        output += `\u001b[${y + 1};1H`;
+        for (let x = 0; x < screen.width; x += 1) {
+            const cell = screen.get(x, y);
+            output += cellToAnsi(cell);
+        }
+    }
+    return output;
+}

package/node_modules/toolcraft-design/dist/index.d.ts

@@ -23,6 +23,10 @@ export { renderCatalog } from "./components/catalog.js";
 export type { CatalogGroup, CatalogItem, CatalogMetric, CatalogTone, RenderCatalogOptions } from "./components/catalog.js";
 export { renderDetailCard } from "./components/detail-card.js";
 export type { DetailCardRow, DetailCardSection, RenderDetailCardOptions } from "./components/detail-card.js";
+export { renderInspectorCard } from "./components/inspector-card.js";
+export type { InspectorField, InspectorSection, RenderInspectorCardOptions } from "./components/inspector-card.js";
+export { renderResourceBrowser } from "./components/resource-browser.js";
+export type { RenderResourceBrowserOptions, ResourceBrowserGroup, ResourceBrowserItem } from "./components/resource-browser.js";
 export { getTemplatePartialNames, renderTemplate, resolveTemplatePartials } from "./components/template.js";
 export type { RenderTemplateOptions, TemplateEscape } from "./components/template.js";
 export { openExternal } from "./components/browser.js";
@@ -31,8 +35,8 @@ export * as dashboard from "./dashboard/index.js";
 export { createDashboard, shouldUseInteractiveDashboard } from "./dashboard/index.js";
 export type { Dashboard, DashboardOptions } from "./dashboard/index.js";
 export * as explorer from "./explorer/index.js";
-export { runExplorer, singleDetail } from "./explorer/index.js";
-export type { Row, DetailItem, Detail, DetailCtx, Action, ActionContext, ExplorerConfig, ReorderContext, Tone } from "./explorer/index.js";
+export { runExplorer, runTwoPaneExplorer, singleDetail } from "./explorer/index.js";
+export type { Row, DetailItem, Detail, DetailCtx, Action, ActionContext, TwoPaneAction, TwoPaneActionContext, TwoPaneDefinition, TwoPaneExplorerConfig, TwoPanePaneState, TwoPaneRow, ExplorerConfig, ReorderContext, Tone } from "./explorer/index.js";
 export * as prompts from "./prompts/index.js";
 export { intro, introPlain, outro, note, select, multiselect, text as promptText, confirm, confirmOrCancel, password, spinner, withSpinner, isCancel, cancel, log, PromptCancelledError } from "./prompts/index.js";
 export type { SelectOptions, MultiselectOptions, TextOptions, ConfirmOptions, PasswordOptions, SpinnerOptions, WithSpinnerOptions } from "./prompts/index.js";

package/node_modules/toolcraft-design/dist/index.js

@@ -17,6 +17,8 @@ export { formatCommandNotFoundPanel } from "./components/command-errors.js";
 export { renderTable } from "./components/table.js";
 export { renderCatalog } from "./components/catalog.js";
 export { renderDetailCard } from "./components/detail-card.js";
+export { renderInspectorCard } from "./components/inspector-card.js";
+export { renderResourceBrowser } from "./components/resource-browser.js";
 export { getTemplatePartialNames, renderTemplate, resolveTemplatePartials } from "./components/template.js";
 export { openExternal } from "./components/browser.js";
 // ACP rendering
@@ -26,7 +28,7 @@ export * as dashboard from "./dashboard/index.js";
 export { createDashboard, shouldUseInteractiveDashboard } from "./dashboard/index.js";
 // Explorer
 export * as explorer from "./explorer/index.js";
-export { runExplorer, singleDetail } from "./explorer/index.js";
+export { runExplorer, runTwoPaneExplorer, singleDetail } from "./explorer/index.js";
 // Prompts
 export * as prompts from "./prompts/index.js";
 export { intro, introPlain, outro, note, select, multiselect, text as promptText, confirm, confirmOrCancel, password, spinner, withSpinner, isCancel, cancel, log, PromptCancelledError } from "./prompts/index.js";

package/node_modules/toolcraft-design/dist/prompts/interactive/glyphs.d.ts

@@ -10,9 +10,9 @@ export declare const GLYPHS: {
     readonly barEnd: string;
     readonly radioActive: string;
     readonly radioInactive: string;
-    readonly checkboxActive: string;
-    readonly checkboxSelected: string;
-    readonly checkboxInactive: string;
+    readonly checkboxActive: "[ ]";
+    readonly checkboxSelected: "[x]";
+    readonly checkboxInactive: "[ ]";
     readonly passwordMask: string;
     readonly ellipsis: "...";
 };

package/node_modules/toolcraft-design/dist/prompts/interactive/glyphs.js

@@ -27,9 +27,9 @@ export const GLYPHS = {
     barEnd: glyph("└", "-"),
     radioActive: glyph("●", ">"),
     radioInactive: glyph("○", " "),
-    checkboxActive: glyph("◻", "[ ]"),
-    checkboxSelected: glyph("◼", "[+]"),
-    checkboxInactive: glyph("◻", "[ ]"),
+    checkboxActive: "[ ]",
+    checkboxSelected: "[x]",
+    checkboxInactive: "[ ]",
     passwordMask: glyph("•", "*"),
     ellipsis: "..."
 };

package/node_modules/toolcraft-design/dist/prompts/interactive/keys.js

@@ -21,6 +21,9 @@ export function mapKey(name, char) {
     if (char === " ") {
         return "space";
     }
+    if (char !== undefined && aliases[char] !== undefined) {
+        return aliases[char];
+    }
     if (!name) {
         return undefined;
     }

package/node_modules/toolcraft-design/dist/prompts/interactive/multiselect.js

@@ -102,10 +102,14 @@ function renderOption(option, values, active, submitted, cancelled) {
 }
 function renderMultiselectPrompt(prompt, opts) {
     if (prompt.state === "submit" || prompt.state === "cancel") {
-        const labels = prompt.visibleOptions
-            .filter((option) => hasValue(prompt.value, option.value))
-            .map((option) => prompt.state === "submit" ? color.dim(option.label) : color.dim.strikethrough(option.label))
-            .join(", ");
+        const selectedOptions = prompt.visibleOptions.filter((option) => hasValue(prompt.value, option.value));
+        const labels = selectedOptions.length > 3
+            ? prompt.state === "submit"
+                ? color.dim(`${selectedOptions.length} selected`)
+                : color.dim.strikethrough(`${selectedOptions.length} selected`)
+            : selectedOptions
+                .map((option) => prompt.state === "submit" ? color.dim(option.label) : color.dim.strikethrough(option.label))
+                .join(", ");
         const end = prompt.state === "submit" ? color.green(GLYPHS.barEnd) : color.red(GLYPHS.barEnd);
         return `${color.gray(GLYPHS.barStart)} ${symbol(prompt.state)} ${opts.message}\n${color.gray(GLYPHS.bar)}  ${labels}\n${end}`;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "terminal-pilot",
-  "version": "0.0.32",
+  "version": "0.0.34",
   "description": "Playwright-like SDK and CLI for automating interactive CLI apps through a real PTY",
   "type": "module",
   "main": "dist/index.js",
@@ -38,7 +38,7 @@
     "dist"
   ],
   "engines": {
-    "node": ">=20"
+    "node": ">=18.18"
   },
   "repository": {
     "type": "git",
@@ -54,13 +54,14 @@
   "dependencies": {
     "@poe-code/agent-skill-config": "*",
     "@resvg/resvg-js": "^2.6.2",
-    "commander": "^14.0.3",
+    "commander": "^13.1.0",
     "fast-string-width": "^3.0.2",
     "fast-wrap-ansi": "^0.2.0",
     "jetbrains-mono": "^1.0.6",
     "jose": "^6.1.2",
     "jsonc-parser": "^3.3.1",
     "node-pty": "^1.1.0",
+    "sisteransi": "^1.0.5",
     "smol-toml": "^1.6.0",
     "toolcraft": "^0.0.51",
     "yaml": "^2.8.2"