toolcraft-openapi 0.0.39 → 0.0.41

package/dist/index.d.ts

@@ -2,12 +2,17 @@ export { defineApiCommand } from "./api-command.js";
 export { defineClient } from "./define-client.js";
 export { generate } from "./generate.js";
 export type { GenerateOptions, GeneratedFile, OpenApiDocument } from "./generate.js";
+export { SUPPORTED_TOOLCRAFT_EDITION, mergeToolcraftConfig, readToolcraftConfig, validateToolcraftConfig } from "./config.js";
+export type { ToolcraftConfig, ToolcraftMethodConfig, ToolcraftResourceConfig } from "./config.js";
+export { diagnose } from "./diagnose.js";
+export { DIAGNOSTIC_CODES, formatDiagnostic, formatDiagnostics } from "./diagnostics.js";
+export type { Diagnostic, DiagnosticSeverity } from "./diagnostics.js";
 export { inspectOpenApiDocument } from "./inspect.js";
 export type { OpenApiInspectionOperation, OpenApiInspectionReport } from "./inspect.js";
 export { inspectOpenApiSource } from "./inspect-source.js";
 export type { InspectOpenApiSourceOptions, OpenApiInspectionSource } from "./inspect-source.js";
 export { renderOpenApiInspection } from "./render-inspection.js";
-export { commandsFromSpec, defineClientFromSpec } from "./runtime.js";
+export { commandsFromSpec, defineClientFromSpec, resolveOpenApiBaseUrl } from "./runtime.js";
 export type { CommandsFromSpecOptions, DefineClientFromSpecOptions, OpenApiDocumentSource } from "./runtime.js";
 export type { DefineClientOptions, DefinedClient, OpenApiClientServices } from "./define-client.js";
 export type { AuthProvider, CommandContributor, TokenSource } from "./auth/types.js";

package/dist/index.js

@@ -1,9 +1,12 @@
 export { defineApiCommand } from "./api-command.js";
 export { defineClient } from "./define-client.js";
 export { generate } from "./generate.js";
+export { SUPPORTED_TOOLCRAFT_EDITION, mergeToolcraftConfig, readToolcraftConfig, validateToolcraftConfig } from "./config.js";
+export { diagnose } from "./diagnose.js";
+export { DIAGNOSTIC_CODES, formatDiagnostic, formatDiagnostics } from "./diagnostics.js";
 export { inspectOpenApiDocument } from "./inspect.js";
 export { inspectOpenApiSource } from "./inspect-source.js";
 export { renderOpenApiInspection } from "./render-inspection.js";
-export { commandsFromSpec, defineClientFromSpec } from "./runtime.js";
+export { commandsFromSpec, defineClientFromSpec, resolveOpenApiBaseUrl } from "./runtime.js";
 export { bearerTokenAuth } from "./auth/bearer-token-auth.js";
 export { HttpError, prepareMultipartFileInputs, requestJson, writeBinaryResponseOutput } from "./http.js";

package/dist/runtime.d.ts

@@ -9,5 +9,12 @@ export interface CommandsFromSpecOptions {
     fs?: OpenApiSourceFileSystem;
 }
 export type DefineClientFromSpecOptions<TServices extends object = Record<string, never>> = Omit<DefineClientOptions<TServices>, "commands"> & CommandsFromSpecOptions;
+export interface ResolveOpenApiBaseUrlOptions {
+    document: OpenApiDocument;
+    environments?: Record<string, string>;
+    environment?: string;
+    env?: Record<string, string | undefined>;
+}
 export declare function commandsFromSpec(source: OpenApiDocumentSource, options?: CommandsFromSpecOptions): Promise<CommandNode<OpenApiClientServices>[]>;
 export declare function defineClientFromSpec<TServices extends object = Record<string, never>>(spec: OpenApiDocumentSource, options: DefineClientFromSpecOptions<TServices>): Promise<DefinedClient<TServices>>;
+export declare function resolveOpenApiBaseUrl(options: ResolveOpenApiBaseUrlOptions): string | undefined;

package/dist/runtime.js

@@ -1,5 +1,5 @@
 import fs from "node:fs/promises";
-import { defineCommand, defineGroup, S } from "toolcraft";
+import { UserError, defineCommand, defineGroup, S } from "toolcraft";
 import { defineClient } from "./define-client.js";
 import { collectSchemaOptionEntries, collectGeneratedCommands } from "./generate.js";
 import { groupByNoun } from "./group-by-noun.js";
@@ -31,6 +31,24 @@ async function resolveDocument(source, options) {
     });
     return parseOpenApiDocument(sourceText, source);
 }
+export function resolveOpenApiBaseUrl(options) {
+    const environments = options.environments;
+    if (environments !== undefined && Object.keys(environments).length > 0) {
+        const selectedName = options.environment ?? options.env?.TOOLCRAFT_OPENAPI_ENV ?? Object.keys(environments)[0];
+        const selectedUrl = selectedName === undefined ? undefined : environments[selectedName];
+        if (selectedUrl !== undefined) {
+            return normalizeBaseUrl(selectedUrl);
+        }
+        if (selectedName !== undefined) {
+            throw new UserError(`Unknown OpenAPI environment ${JSON.stringify(selectedName)}. Available: ${Object.keys(environments).join(", ")}.`);
+        }
+    }
+    const server = options.document.servers?.[0]?.url;
+    return server === undefined ? undefined : normalizeBaseUrl(server);
+}
+function normalizeBaseUrl(value) {
+    return new URL(value).toString().replace(/\/$/, "");
+}
 function createRuntimeGroups(commands) {
     return groupByNoun(commands).map(({ noun, commands: nounCommands }) => defineGroup({
         name: noun,

package/node_modules/@poe-code/frontmatter/README.md

@@ -0,0 +1,35 @@
+# @poe-code/frontmatter
+
+Shared YAML frontmatter parsing for poe-code packages.
+
+## API
+
+```ts
+import {
+  FrontmatterParseError,
+  parseFrontmatter,
+  parseFrontmatterDocument,
+  stringifyFrontmatter
+} from "@poe-code/frontmatter";
+```
+
+- `parseFrontmatter(source)` returns `{ frontmatter, body }`.
+- `parseFrontmatterDocument(source)` returns `{ frontmatter, body, errors, lineCounter }` for callers that need YAML diagnostics.
+- `stringifyFrontmatter(frontmatter, body)` writes `---` fences, YAML, and the body.
+- `FrontmatterParseError` is thrown for malformed frontmatter, invalid YAML, non-object frontmatter, and stringify failures.
+
+When no leading frontmatter block exists, parsing returns `{ frontmatter: {}, body: source }`.
+The returned `body` is sliced from the original input and is otherwise byte-for-byte unchanged.
+YAML mappings that contain `__proto__` keep it as an own property without changing the object's prototype.
+
+Duplicate mapping keys use YAML's last-wins behavior by default, matching the
+legacy frontmatter readers. Callers that need strict YAML mappings can pass
+`{ uniqueKeys: true }` to `parseFrontmatter` or `parseFrontmatterDocument`.
+
+## Environment
+
+This package reads no environment variables.
+
+## Config
+
+This package has no configuration options.

package/node_modules/@poe-code/frontmatter/dist/fences.d.ts

@@ -0,0 +1,8 @@
+export type FrontmatterBlock = {
+    raw: string;
+    body: string;
+};
+export type SplitFrontmatterResult = FrontmatterBlock | {
+    body: string;
+};
+export declare function splitFrontmatterBlock(source: string): SplitFrontmatterResult;

package/node_modules/@poe-code/frontmatter/dist/fences.js

@@ -0,0 +1,72 @@
+export function splitFrontmatterBlock(source) {
+    const content = source.startsWith("\uFEFF") ? source.slice(1) : source;
+    const opening = readOpeningFence(content);
+    if (opening === undefined) {
+        return { body: source };
+    }
+    const closing = findClosingFence(content, opening.next);
+    if (closing === undefined) {
+        throw new Error("Missing YAML frontmatter end delimiter (---).");
+    }
+    return {
+        raw: content.slice(opening.next, closing.index),
+        body: content.slice(closing.end + closing.lineBreakLength)
+    };
+}
+function readOpeningFence(source) {
+    if (!source.startsWith("---")) {
+        return undefined;
+    }
+    const lineEnd = findLineEnd(source, 0);
+    if (lineEnd.lineBreakLength === 0 || source.slice(0, lineEnd.index) !== "---") {
+        return undefined;
+    }
+    return { next: lineEnd.index + lineEnd.lineBreakLength };
+}
+function findClosingFence(source, start) {
+    let lineStart = start;
+    while (lineStart <= source.length) {
+        const lineEnd = findLineEnd(source, lineStart);
+        if (isClosingFenceLine(source.slice(lineStart, lineEnd.index))) {
+            return {
+                index: lineStart,
+                end: lineEnd.index,
+                lineBreakLength: lineEnd.lineBreakLength
+            };
+        }
+        if (lineEnd.lineBreakLength === 0) {
+            break;
+        }
+        lineStart = lineEnd.index + lineEnd.lineBreakLength;
+    }
+    return undefined;
+}
+function isClosingFenceLine(line) {
+    if (!line.startsWith("---")) {
+        return false;
+    }
+    for (let index = 3; index < line.length; index += 1) {
+        const character = line[index];
+        if (character !== " " && character !== "\t") {
+            return false;
+        }
+    }
+    return true;
+}
+function findLineEnd(source, start) {
+    let index = start;
+    while (index < source.length) {
+        const character = source[index];
+        if (character === "\n") {
+            return { index, lineBreakLength: 1 };
+        }
+        if (character === "\r") {
+            return {
+                index,
+                lineBreakLength: source[index + 1] === "\n" ? 2 : 1
+            };
+        }
+        index += 1;
+    }
+    return { index: source.length, lineBreakLength: 0 };
+}

package/node_modules/@poe-code/frontmatter/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { splitFrontmatterBlock, type FrontmatterBlock, type SplitFrontmatterResult } from "./fences.js";
+export { FrontmatterParseError, parseFrontmatter, parseFrontmatterDocument, type ParsedFrontmatter, type ParsedFrontmatterDocument, type ParseFrontmatterOptions } from "./parse.js";
+export { stringifyFrontmatter } from "./stringify.js";

package/node_modules/@poe-code/frontmatter/dist/index.js

@@ -0,0 +1,3 @@
+export { splitFrontmatterBlock } from "./fences.js";
+export { FrontmatterParseError, parseFrontmatter, parseFrontmatterDocument } from "./parse.js";
+export { stringifyFrontmatter } from "./stringify.js";

package/node_modules/@poe-code/frontmatter/dist/parse.d.ts

@@ -0,0 +1,20 @@
+import { LineCounter } from "yaml";
+export interface ParsedFrontmatter {
+    frontmatter: Record<string, unknown>;
+    body: string;
+}
+export interface ParsedFrontmatterDocument extends ParsedFrontmatter {
+    errors: readonly {
+        message: string;
+        pos?: [number, number];
+    }[];
+    lineCounter: LineCounter;
+}
+export interface ParseFrontmatterOptions {
+    uniqueKeys?: boolean;
+}
+export declare class FrontmatterParseError extends Error {
+    constructor(message: string);
+}
+export declare function parseFrontmatter(source: string, options?: ParseFrontmatterOptions): ParsedFrontmatter;
+export declare function parseFrontmatterDocument(source: string, options?: ParseFrontmatterOptions): ParsedFrontmatterDocument;

package/node_modules/@poe-code/frontmatter/dist/parse.js

@@ -0,0 +1,137 @@
+import { LineCounter, parse, parseDocument } from "yaml";
+import { splitFrontmatterBlock } from "./fences.js";
+export class FrontmatterParseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "FrontmatterParseError";
+    }
+}
+export function parseFrontmatter(source, options = {}) {
+    const split = splitFrontmatter(source);
+    if (split.raw === undefined) {
+        return {
+            frontmatter: {},
+            body: split.body
+        };
+    }
+    return {
+        frontmatter: parseYamlFrontmatter(split.raw, options),
+        body: split.body
+    };
+}
+export function parseFrontmatterDocument(source, options = {}) {
+    const split = splitFrontmatter(source);
+    const lineCounter = new LineCounter();
+    if (split.raw === undefined) {
+        return {
+            frontmatter: {},
+            body: split.body,
+            errors: [],
+            lineCounter
+        };
+    }
+    const document = parseDocument(normalizeYamlLineEndings(split.raw), {
+        lineCounter,
+        prettyErrors: false,
+        uniqueKeys: options.uniqueKeys ?? false
+    });
+    const errors = document.errors.map((error) => ({
+        message: error.message,
+        ...(error.pos === undefined ? {} : { pos: error.pos })
+    }));
+    if (errors.length > 0) {
+        return {
+            frontmatter: {},
+            body: split.body,
+            errors,
+            lineCounter
+        };
+    }
+    return {
+        frontmatter: normalizeYamlFrontmatter(document.toJSON()),
+        body: split.body,
+        errors,
+        lineCounter
+    };
+}
+function splitFrontmatter(source) {
+    try {
+        return splitFrontmatterBlock(source);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new FrontmatterParseError(error.message);
+        }
+        throw error;
+    }
+}
+function parseYamlFrontmatter(yamlBlock, options) {
+    let parsed;
+    try {
+        parsed = parse(normalizeYamlLineEndings(yamlBlock), {
+            uniqueKeys: options.uniqueKeys ?? false
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown YAML parse error";
+        throw new FrontmatterParseError(`Invalid YAML frontmatter: ${message}`);
+    }
+    return normalizeYamlFrontmatter(parsed);
+}
+function normalizeYamlLineEndings(value) {
+    if (!value.includes("\r")) {
+        return value;
+    }
+    let normalized = "";
+    for (let index = 0; index < value.length; index += 1) {
+        const character = value[index];
+        if (character !== "\r") {
+            normalized += character;
+            continue;
+        }
+        if (value[index + 1] === "\n") {
+            normalized += "\r\n";
+            index += 1;
+            continue;
+        }
+        normalized += "\n";
+    }
+    return normalized;
+}
+function normalizeYamlFrontmatter(value) {
+    if (value === null || value === undefined) {
+        return {};
+    }
+    if (!isRecord(value)) {
+        throw new FrontmatterParseError("YAML frontmatter must parse to an object.");
+    }
+    return normalizeYamlValue(value);
+}
+function normalizeYamlValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => normalizeYamlValue(item));
+    }
+    if (!isPlainRecord(value)) {
+        return value;
+    }
+    const normalized = {};
+    for (const [key, entryValue] of Object.entries(value)) {
+        Object.defineProperty(normalized, key, {
+            configurable: true,
+            enumerable: true,
+            value: normalizeYamlValue(entryValue),
+            writable: true
+        });
+    }
+    return normalized;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPlainRecord(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}

package/node_modules/@poe-code/frontmatter/dist/stringify.d.ts

@@ -0,0 +1 @@
+export declare function stringifyFrontmatter(frontmatter: Record<string, unknown>, body: string): string;

package/node_modules/@poe-code/frontmatter/dist/stringify.js

@@ -0,0 +1,35 @@
+import { stringify } from "yaml";
+import { FrontmatterParseError } from "./parse.js";
+export function stringifyFrontmatter(frontmatter, body) {
+    try {
+        assertAcyclic(frontmatter);
+        return `---\n${stringify(frontmatter, { aliasDuplicateObjects: false }).trimEnd()}\n---\n${body}`;
+    }
+    catch (error) {
+        if (error instanceof FrontmatterParseError) {
+            throw error;
+        }
+        const message = error instanceof Error ? error.message : "Unknown YAML stringify error";
+        throw new FrontmatterParseError(`Invalid YAML frontmatter: ${message}`);
+    }
+}
+function assertAcyclic(value, seen = new WeakSet()) {
+    if (typeof value !== "object" || value === null) {
+        return;
+    }
+    if (seen.has(value)) {
+        throw new FrontmatterParseError("Cannot stringify cyclic frontmatter.");
+    }
+    seen.add(value);
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            assertAcyclic(item, seen);
+        }
+    }
+    else {
+        for (const item of Object.values(value)) {
+            assertAcyclic(item, seen);
+        }
+    }
+    seen.delete(value);
+}

package/node_modules/@poe-code/frontmatter/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@poe-code/frontmatter",
+  "version": "0.0.1",
+  "private": true,
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "node ../../scripts/guard-package-dist.mjs && tsc",
+    "test": "cd ../.. && vitest run packages/frontmatter/src",
+    "test:unit": "cd ../.. && vitest run packages/frontmatter/src"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "yaml": "^2.8.2"
+  }
+}

package/node_modules/toolcraft-design/README.md

@@ -139,6 +139,18 @@ The registry key and `Brand.name` should match. Brand primary colors are CSS-sty
 - `VSCODE_COLOR_THEME_KIND`: automatic VS Code theme hint used after the macOS hint.
 - `COLORFGBG`: terminal foreground/background hint used after the macOS and VS Code hints. Rendering defaults to dark when no hint resolves a mode.
 
+### Prompts
+
+- `POE_NO_PROMPT`: when set to `1` in non-TTY contexts, `confirm`, `select`, and `multiselect` accept their default or initial values instead of throwing an interactive TTY error.
+
+### Node 18 Smoke
+
+After building the package, verify the prompt entrypoint under Node 18 with:
+
+```sh
+nvm exec 18.18 node packages/toolcraft-design/scripts/check-node18.mjs
+```
+
 ### Output and Color
 
 - `OUTPUT_FORMAT`: selects `terminal`, `markdown`, or `json` output for components that use the output-format resolver. Invalid or missing values default to `terminal`.

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

@@ -1,4 +1,5 @@
-import * as clack from "@clack/prompts";
+import type { CANCEL } from "./interactive/cancel-symbol.js";
+import { type SelectOption } from "./interactive/select.js";
 import { cancel, isCancel } from "./primitives/cancel.js";
 import { intro } from "./primitives/intro.js";
 import { log } from "./primitives/log.js";
@@ -10,15 +11,24 @@ export { intro, outro, note, spinner };
 export declare function introPlain(title: string): void;
 export interface SelectOptions<Value> {
     message: string;
-    options: Array<{
-        value: Value;
-        label: string;
-        hint?: string;
-    }>;
+    options: Array<SelectOption<Value>>;
     initialValue?: Value;
+    maxItems?: number;
+    signal?: AbortSignal;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}
+export declare function select<Value>(opts: SelectOptions<Value>): Promise<Value | typeof CANCEL>;
+export interface MultiselectOptions<Value> {
+    message: string;
+    options: Array<SelectOption<Value>>;
+    initialValues?: Value[];
+    required?: boolean;
+    maxItems?: number;
+    signal?: AbortSignal;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
 }
-export declare function select<Value>(opts: SelectOptions<Value>): Promise<Value | symbol>;
-export type MultiselectOptions<Value> = Parameters<typeof clack.multiselect<Value>>[0];
 /**
  * Prompts the user to select one or more values from a list.
  *
@@ -35,23 +45,38 @@ export type MultiselectOptions<Value> = Parameters<typeof clack.multiselect<Valu
  *   // result is Value[]
  * }
  */
-export declare function multiselect<Value>(opts: MultiselectOptions<Value>): Promise<Value[] | symbol>;
-export type TextOptions = Parameters<typeof clack.text>[0];
-export declare function text(opts: TextOptions): Promise<string | symbol>;
+export declare function multiselect<Value>(opts: MultiselectOptions<Value>): Promise<Value[] | typeof CANCEL>;
+export interface TextOptions {
+    message: string;
+    placeholder?: string;
+    defaultValue?: string;
+    initialValue?: string;
+    validate?: (value: string) => string | Error | undefined;
+    signal?: AbortSignal;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}
+export declare function text(opts: TextOptions): Promise<string | typeof CANCEL>;
 export interface ConfirmOptions {
     message: string;
     initialValue?: boolean;
+    signal?: AbortSignal;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
 }
-export declare function confirm(opts: ConfirmOptions): Promise<boolean | symbol>;
+export declare function confirm(opts: ConfirmOptions): Promise<boolean | typeof CANCEL>;
 export declare class PromptCancelledError extends Error {
     constructor(message?: string);
 }
 export declare function confirmOrCancel(opts: ConfirmOptions): Promise<boolean>;
 export interface PasswordOptions {
     message: string;
-    validate?: (value: string) => string | undefined;
+    validate?: (value: string) => string | Error | undefined;
+    signal?: AbortSignal;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
 }
-export declare function password(opts: PasswordOptions): Promise<string | symbol>;
+export declare function password(opts: PasswordOptions): Promise<string | typeof CANCEL>;
 export type SpinnerOptions = {
     start: (message?: string) => void;
     stop: (message?: string, code?: number) => void;

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

@@ -1,7 +1,11 @@
 import { color } from "../components/color.js";
-import * as clack from "@clack/prompts";
 import { resolveOutputFormat } from "../internal/output-format.js";
 import { stripAnsi } from "../internal/strip-ansi.js";
+import { confirmPrompt } from "./interactive/confirm.js";
+import { multiselectPrompt } from "./interactive/multiselect.js";
+import { passwordPrompt } from "./interactive/password.js";
+import { selectPrompt } from "./interactive/select.js";
+import { textPrompt } from "./interactive/text.js";
 import { cancel, isCancel } from "./primitives/cancel.js";
 import { intro } from "./primitives/intro.js";
 import { log } from "./primitives/log.js";
@@ -22,7 +26,7 @@ export function introPlain(title) {
     process.stdout.write(`${color.gray("┌")}  ${title}\n`);
 }
 export async function select(opts) {
-    return clack.select(opts);
+    return selectPrompt(opts);
 }
 /**
  * Prompts the user to select one or more values from a list.
@@ -41,13 +45,13 @@ export async function select(opts) {
  * }
  */
 export async function multiselect(opts) {
-    return clack.multiselect(opts);
+    return multiselectPrompt(opts);
 }
 export async function text(opts) {
-    return clack.text(opts);
+    return textPrompt(opts);
 }
 export async function confirm(opts) {
-    return clack.confirm(opts);
+    return confirmPrompt(opts);
 }
 export class PromptCancelledError extends Error {
     constructor(message = "Operation cancelled.") {
@@ -67,7 +71,7 @@ export async function confirmOrCancel(opts) {
     return result === true;
 }
 export async function password(opts) {
-    return clack.password(opts);
+    return passwordPrompt(opts);
 }
 function formatElapsed(ms) {
     const totalSeconds = Math.floor(ms / 1000);

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

@@ -0,0 +1,2 @@
+export declare const CANCEL: unique symbol;
+export declare function isCancel(value: unknown): value is typeof CANCEL;

package/node_modules/toolcraft-design/dist/prompts/interactive/cancel-symbol.js

@@ -0,0 +1,4 @@
+export const CANCEL = Symbol.for("poe.cancel");
+export function isCancel(value) {
+    return value === CANCEL;
+}

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

@@ -0,0 +1,9 @@
+import { CANCEL } from "./cancel-symbol.js";
+export interface ConfirmOptions {
+    message: string;
+    initialValue?: boolean;
+    signal?: AbortSignal;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}
+export declare function confirmPrompt(opts: ConfirmOptions): Promise<boolean | typeof CANCEL>;

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

@@ -0,0 +1,47 @@
+import { color } from "../../components/color.js";
+import { GLYPHS, symbol, symbolBar } from "./glyphs.js";
+import { Prompt } from "./core.js";
+class ConfirmPrompt extends Prompt {
+    constructor(opts) {
+        super({
+            ...opts,
+            initialValue: opts.initialValue ?? true,
+            render: (prompt) => renderConfirmPrompt(prompt, opts)
+        }, false);
+        this.on("confirm", (value) => {
+            this.setValue(value);
+            this.state = "submit";
+            this.emit("finalize");
+            this.render();
+            this.close();
+        });
+        this.on("cursor", (action) => {
+            if (action === "up" || action === "down" || action === "left" || action === "right") {
+                this.setValue(!this.value);
+            }
+        });
+    }
+    promptNonTty() {
+        if (process.env.POE_NO_PROMPT === "1") {
+            return Promise.resolve(this.value ?? true);
+        }
+        return super.promptNonTty();
+    }
+}
+function choices(value) {
+    const yes = value ? `${color.green(GLYPHS.radioActive)} ${color.bold("Yes")}` : `${color.dim(GLYPHS.radioInactive)} ${color.dim("Yes")}`;
+    const no = value ? `${color.dim(GLYPHS.radioInactive)} ${color.dim("No")}` : `${color.green(GLYPHS.radioActive)} ${color.bold("No")}`;
+    return `${yes} ${color.dim("/")} ${no}`;
+}
+function renderConfirmPrompt(prompt, opts) {
+    if (prompt.state === "submit") {
+        return `${color.gray(GLYPHS.barStart)} ${symbol(prompt.state)} ${opts.message}\n${color.gray(GLYPHS.bar)}  ${color.dim(prompt.value ? "Yes" : "No")}\n${color.green(GLYPHS.barEnd)}`;
+    }
+    if (prompt.state === "cancel") {
+        return `${color.gray(GLYPHS.barStart)} ${symbol(prompt.state)} ${opts.message}\n${color.gray(GLYPHS.bar)}  ${color.dim.strikethrough(prompt.value ? "Yes" : "No")}\n${color.red(GLYPHS.barEnd)}`;
+    }
+    return `${color.gray(GLYPHS.barStart)} ${symbol(prompt.state)} ${opts.message}\n${symbolBar(prompt.state)}  ${choices(prompt.value)}\n${color.cyan(GLYPHS.barEnd)}`;
+}
+export function confirmPrompt(opts) {
+    return new ConfirmPrompt(opts).prompt();
+}