toolcraft-openapi 0.0.38 → 0.0.40

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();
+}

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

@@ -0,0 +1,55 @@
+import { EventEmitter } from "node:events";
+import { CANCEL } from "./cancel-symbol.js";
+export type PromptStateName = "initial" | "active" | "submit" | "cancel" | "error";
+export interface PromptState<Value> {
+    state: PromptStateName;
+    value: Value | undefined;
+    error: string;
+    cursor: number;
+    userInput: string;
+}
+export interface PromptOptions<Value> {
+    render: (state: Prompt<Value>) => string;
+    initialValue?: Value;
+    initialUserInput?: string;
+    validate?: (value: Value | undefined) => string | Error | undefined;
+    signal?: AbortSignal;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}
+type InputStream = NodeJS.ReadableStream & {
+    isTTY?: boolean;
+    setRawMode?: (enabled: boolean) => void;
+    unpipe?: () => void;
+};
+export declare class Prompt<Value> extends EventEmitter {
+    state: PromptStateName;
+    value: Value | undefined;
+    error: string;
+    userInput: string;
+    protected _cursor: number;
+    protected input: InputStream;
+    protected output: NodeJS.WritableStream;
+    private readonly renderFrame;
+    private readonly validate?;
+    private readonly signal?;
+    private readonly trackValue;
+    private previousFrame;
+    private readlineInterface?;
+    private abortListener?;
+    private closed;
+    constructor(opts: PromptOptions<Value>, trackValue?: boolean);
+    get cursor(): number;
+    prompt(): Promise<Value | typeof CANCEL>;
+    protected promptNonTty(): Promise<Value | typeof CANCEL>;
+    protected readNonTtyLine(): Promise<string>;
+    protected setValue(value: Value | undefined): void;
+    protected setError(message: string): void;
+    protected setUserInput(value: string): void;
+    protected clearUserInput(): void;
+    private readonly onKeypress;
+    private updateTrackedInput;
+    protected readonly render: () => void;
+    protected close(): void;
+}
+export {};