@a5c-ai/agent-platform 5.0.1-staging.b436b3b3e611

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,OAAO,CAAC;AACtB,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAC;AAC/B,OAAO,KAAK,UAAU,MAAM,cAAc,CAAC;AAC3C,cAAc,iBAAiB,CAAC;AAChC,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AACrC,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AACrC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,52 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tasks = exports.storage = exports.session = exports.governance = exports.cost = exports.anycli = void 0;
+__exportStar(require("./cli/main"), exports);
+__exportStar(require("./harness"), exports);
+__exportStar(require("./runtime"), exports);
+__exportStar(require("./api"), exports);
+__exportStar(require("./daemon"), exports);
+__exportStar(require("./interaction"), exports);
+exports.anycli = __importStar(require("./anycli"));
+exports.cost = __importStar(require("./cost"));
+exports.governance = __importStar(require("./governance"));
+__exportStar(require("./observability"), exports);
+exports.session = __importStar(require("./session"));
+exports.storage = __importStar(require("./storage"));
+exports.tasks = __importStar(require("./tasks"));

package/dist/interaction/askUserQuestion/core.d.ts

@@ -0,0 +1,8 @@
+import type { AskUserQuestionOption, AskUserQuestionQuestion, AskUserQuestionRequest, AskUserQuestionResponse } from "../askUserQuestion";
+export declare function getQuestionKey(question: AskUserQuestionQuestion, index: number): string;
+export declare function resolveOption(token: string, options: AskUserQuestionOption[]): AskUserQuestionOption | undefined;
+export declare function parseOptionAnswer(rawAnswer: string, question: AskUserQuestionQuestion): string | undefined;
+export declare function validateAskUserQuestionRequest(request: AskUserQuestionRequest): void;
+export declare function createAskUserQuestionResponse(request: AskUserQuestionRequest, answers: Record<string, string>): AskUserQuestionResponse;
+export declare function createDefaultAskUserQuestionResponse(request: AskUserQuestionRequest): AskUserQuestionResponse;
+//# sourceMappingURL=core.d.ts.map

package/dist/interaction/askUserQuestion/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../src/interaction/askUserQuestion/core.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,qBAAqB,EACrB,uBAAuB,EACvB,sBAAsB,EACtB,uBAAuB,EACxB,MAAM,oBAAoB,CAAC;AAO5B,wBAAgB,cAAc,CAAC,QAAQ,EAAE,uBAAuB,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAMvF;AAED,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,qBAAqB,EAAE,GAC/B,qBAAqB,GAAG,SAAS,CAQnC;AAED,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,uBAAuB,GAChC,MAAM,GAAG,SAAS,CA2BpB;AAED,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,sBAAsB,GAC9B,IAAI,CA0CN;AAED,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,sBAAsB,EAC/B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC9B,uBAAuB,CAUzB;AA0BD,wBAAgB,oCAAoC,CAClD,OAAO,EAAE,sBAAsB,GAC9B,uBAAuB,CAEzB"}

package/dist/interaction/askUserQuestion/core.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getQuestionKey = getQuestionKey;
+exports.resolveOption = resolveOption;
+exports.parseOptionAnswer = parseOptionAnswer;
+exports.validateAskUserQuestionRequest = validateAskUserQuestionRequest;
+exports.createAskUserQuestionResponse = createAskUserQuestionResponse;
+exports.createDefaultAskUserQuestionResponse = createDefaultAskUserQuestionResponse;
+const MIN_QUESTION_COUNT = 1;
+const MAX_QUESTION_COUNT = 4;
+const MIN_OPTION_COUNT = 2;
+const MAX_OPTION_COUNT = 4;
+function getQuestionKey(question, index) {
+    const header = question.header?.trim();
+    if (header) {
+        return header;
+    }
+    return `Question ${index + 1}`;
+}
+function resolveOption(token, options) {
+    if (/^\d+$/.test(token)) {
+        const index = Number(token) - 1;
+        return index >= 0 && index < options.length ? options[index] : undefined;
+    }
+    const normalized = token.trim().toLowerCase();
+    return options.find((option) => option.label.trim().toLowerCase() === normalized);
+}
+function parseOptionAnswer(rawAnswer, question) {
+    const trimmed = rawAnswer.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const options = question.options ?? [];
+    const parts = question.multiSelect
+        ? trimmed.split(",").map((part) => part.trim()).filter(Boolean)
+        : [trimmed];
+    const selectedLabels = [];
+    for (const part of parts) {
+        const option = resolveOption(part, options);
+        if (!option) {
+            return question.allowOther === false ? undefined : trimmed;
+        }
+        if (!selectedLabels.includes(option.label)) {
+            selectedLabels.push(option.label);
+        }
+    }
+    if (!question.multiSelect && selectedLabels.length > 1) {
+        return undefined;
+    }
+    return question.multiSelect ? selectedLabels.join(", ") : selectedLabels[0];
+}
+function validateAskUserQuestionRequest(request) {
+    if (!Array.isArray(request.questions)) {
+        throw new Error("AskUserQuestion requires a questions array.");
+    }
+    if (request.questions.length < MIN_QUESTION_COUNT ||
+        request.questions.length > MAX_QUESTION_COUNT) {
+        throw new Error(`AskUserQuestion requires ${MIN_QUESTION_COUNT}-${MAX_QUESTION_COUNT} questions.`);
+    }
+    for (const question of request.questions) {
+        if (!question.question?.trim()) {
+            throw new Error("AskUserQuestion questions must include non-empty question text.");
+        }
+        if (!question.options) {
+            continue;
+        }
+        if (question.options.length < MIN_OPTION_COUNT ||
+            question.options.length > MAX_OPTION_COUNT) {
+            throw new Error(`AskUserQuestion option-based questions require ${MIN_OPTION_COUNT}-${MAX_OPTION_COUNT} options.`);
+        }
+        if (question.multiSelect && question.options.some((option) => option.preview?.trim())) {
+            throw new Error("AskUserQuestion preview is only supported for single-select questions.");
+        }
+        for (const option of question.options) {
+            if (!option.label?.trim()) {
+                throw new Error("AskUserQuestion options must include a non-empty label.");
+            }
+        }
+    }
+}
+function createAskUserQuestionResponse(request, answers) {
+    validateAskUserQuestionRequest(request);
+    const normalizedAnswers = {};
+    for (const [index, question] of request.questions.entries()) {
+        const key = getQuestionKey(question, index);
+        normalizedAnswers[key] = answers[key] ?? "";
+    }
+    return { answers: normalizedAnswers };
+}
+function getDefaultAnswerForQuestion(question) {
+    const options = question.options ?? [];
+    if (question.recommended != null &&
+        options.length > 0 &&
+        options[question.recommended]) {
+        return options[question.recommended].label;
+    }
+    if (options.length > 0) {
+        return options[0].label;
+    }
+    return "";
+}
+function buildDefaultAnswers(request) {
+    const answers = {};
+    for (const [index, question] of request.questions.entries()) {
+        const key = getQuestionKey(question, index);
+        answers[key] = getDefaultAnswerForQuestion(question);
+    }
+    return answers;
+}
+function createDefaultAskUserQuestionResponse(request) {
+    return createAskUserQuestionResponse(request, buildDefaultAnswers(request));
+}

package/dist/interaction/askUserQuestion/terminal.d.ts

@@ -0,0 +1,15 @@
+import type { Readable, Writable } from "node:stream";
+export declare const RESET = "\u001B[0m";
+export declare const BOLD = "\u001B[1m";
+export declare const CYAN = "\u001B[36m";
+export declare const DIM = "\u001B[2m";
+export declare const YELLOW = "\u001B[33m";
+interface ArrowSelectOptions {
+    multiSelect?: boolean;
+}
+export declare function isTTYInput(stream: Readable): stream is NodeJS.ReadStream & {
+    setRawMode: (mode: boolean) => void;
+};
+export declare function promptArrowKeySelect(input: NodeJS.ReadStream, output: Writable, options: string[], opts?: ArrowSelectOptions): Promise<number | number[] | undefined>;
+export {};
+//# sourceMappingURL=terminal.d.ts.map

package/dist/interaction/askUserQuestion/terminal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal.d.ts","sourceRoot":"","sources":["../../../src/interaction/askUserQuestion/terminal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEtD,eAAO,MAAM,KAAK,cAAY,CAAC;AAC/B,eAAO,MAAM,IAAI,cAAY,CAAC;AAC9B,eAAO,MAAM,IAAI,eAAa,CAAC;AAC/B,eAAO,MAAM,GAAG,cAAY,CAAC;AAC7B,eAAO,MAAM,MAAM,eAAa,CAAC;AAQjC,UAAU,kBAAkB;IAC1B,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,wBAAgB,UAAU,CACxB,MAAM,EAAE,QAAQ,GACf,MAAM,IAAI,MAAM,CAAC,UAAU,GAAG;IAAE,UAAU,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAA;CAAE,CAEvE;AA6CD,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,CAAC,UAAU,EACxB,MAAM,EAAE,QAAQ,EAChB,OAAO,EAAE,MAAM,EAAE,EACjB,IAAI,CAAC,EAAE,kBAAkB,GACxB,OAAO,CAAC,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC,CAqFxC"}

package/dist/interaction/askUserQuestion/terminal.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YELLOW = exports.DIM = exports.CYAN = exports.BOLD = exports.RESET = void 0;
+exports.isTTYInput = isTTYInput;
+exports.promptArrowKeySelect = promptArrowKeySelect;
+exports.RESET = "\x1b[0m";
+exports.BOLD = "\x1b[1m";
+exports.CYAN = "\x1b[36m";
+exports.DIM = "\x1b[2m";
+exports.YELLOW = "\x1b[33m";
+const HIDE_CURSOR = "\x1b[?25l";
+const SHOW_CURSOR = "\x1b[?25h";
+const CLEAR_LINE = "\x1b[2K";
+const CURSOR_COL1 = "\x1b[G";
+const CURSOR_UP = "\x1b[A";
+function isTTYInput(stream) {
+    return "isTTY" in stream && stream.isTTY === true && typeof stream.setRawMode === "function";
+}
+function renderOptions(output, options, cursor, selected, multiSelect) {
+    let lines = 0;
+    for (const [index, label] of options.entries()) {
+        const isCurrent = index === cursor;
+        const prefix = multiSelect
+            ? selected.has(index)
+                ? isCurrent
+                    ? `${exports.CYAN}${exports.BOLD}> [x]${exports.RESET} `
+                    : "  [x] "
+                : isCurrent
+                    ? `${exports.CYAN}${exports.BOLD}> [ ]${exports.RESET} `
+                    : "  [ ] "
+            : isCurrent
+                ? `${exports.CYAN}${exports.BOLD}> ${exports.RESET}`
+                : "  ";
+        const text = isCurrent ? `${exports.CYAN}${exports.BOLD}${label}${exports.RESET}` : label;
+        output.write(`${CLEAR_LINE}${CURSOR_COL1}${prefix}${text}\n`);
+        lines++;
+    }
+    if (multiSelect) {
+        output.write(`${CLEAR_LINE}${CURSOR_COL1}${exports.DIM}(Space to toggle, Enter to confirm, Esc to cancel)${exports.RESET}\n`);
+        lines++;
+    }
+    else {
+        output.write(`${CLEAR_LINE}${CURSOR_COL1}${exports.DIM}(Up/Down to move, Enter to select, 1-9 shortcut, Esc to cancel)${exports.RESET}\n`);
+        lines++;
+    }
+    return lines;
+}
+function moveUp(output, count) {
+    if (count > 0) {
+        output.write(`${CURSOR_UP}`.repeat(count));
+    }
+}
+function promptArrowKeySelect(input, output, options, opts) {
+    const multiSelect = opts?.multiSelect ?? false;
+    return new Promise((resolve) => {
+        let cursor = 0;
+        const selected = new Set();
+        let renderedLines = 0;
+        let resolved = false;
+        const cleanup = () => {
+            if (resolved) {
+                return;
+            }
+            resolved = true;
+            input.removeListener("data", onData);
+            try {
+                input.setRawMode(false);
+            }
+            catch {
+                // Ignore stream cleanup failures.
+            }
+            output.write(SHOW_CURSOR);
+        };
+        const finish = (value) => {
+            cleanup();
+            resolve(value);
+        };
+        const redraw = () => {
+            moveUp(output, renderedLines);
+            renderedLines = renderOptions(output, options, cursor, selected, multiSelect);
+        };
+        const onData = (data) => {
+            if (resolved) {
+                return;
+            }
+            const key = data.toString("utf8");
+            if (key === "\x03" || key === "\x1b" || key === "\x1b\x1b") {
+                finish(undefined);
+                return;
+            }
+            if (key === "\r" || key === "\n") {
+                finish(multiSelect ? [...selected].sort((left, right) => left - right) : cursor);
+                return;
+            }
+            if (key === " " && multiSelect) {
+                if (selected.has(cursor)) {
+                    selected.delete(cursor);
+                }
+                else {
+                    selected.add(cursor);
+                }
+                redraw();
+                return;
+            }
+            if (key === "\x1b[A") {
+                cursor = cursor > 0 ? cursor - 1 : options.length - 1;
+                redraw();
+                return;
+            }
+            if (key === "\x1b[B") {
+                cursor = cursor < options.length - 1 ? cursor + 1 : 0;
+                redraw();
+                return;
+            }
+            if (!multiSelect && /^[1-9]$/.test(key)) {
+                const index = Number(key) - 1;
+                if (index < options.length) {
+                    finish(index);
+                }
+            }
+        };
+        output.write(HIDE_CURSOR);
+        input.setRawMode(true);
+        input.resume();
+        input.on("data", onData);
+        renderedLines = renderOptions(output, options, cursor, selected, multiSelect);
+    });
+}

package/dist/interaction/askUserQuestion.d.ts

@@ -0,0 +1,10 @@
+import * as readline from "node:readline";
+import { createAskUserQuestionResponse, createDefaultAskUserQuestionResponse, validateAskUserQuestionRequest } from "./askUserQuestion/core";
+import type { AskUserQuestionRequest, AskUserQuestionResponse, AskUserQuestionUiContext } from "./askUserQuestionTypes";
+export type { AskUserQuestionOption, AskUserQuestionQuestion, AskUserQuestionRequest, AskUserQuestionResponse, AskUserQuestionUiContext, } from "./askUserQuestionTypes";
+export { createAskUserQuestionResponse, createDefaultAskUserQuestionResponse, validateAskUserQuestionRequest, };
+export declare function createApprovalAskUserQuestion(question: string, header?: string): AskUserQuestionRequest;
+export declare function createReadlineAskUserQuestionUiContext(rl: readline.Interface): AskUserQuestionUiContext;
+export declare function promptAskUserQuestionWithUiContext(ui: AskUserQuestionUiContext, request: AskUserQuestionRequest): Promise<AskUserQuestionResponse>;
+export declare function promptAskUserQuestionWithReadline(rl: readline.Interface, request: AskUserQuestionRequest): Promise<AskUserQuestionResponse>;
+//# sourceMappingURL=askUserQuestion.d.ts.map

package/dist/interaction/askUserQuestion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"askUserQuestion.d.ts","sourceRoot":"","sources":["../../src/interaction/askUserQuestion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAC;AAC1C,OAAO,EACL,6BAA6B,EAC7B,oCAAoC,EAIpC,8BAA8B,EAC/B,MAAM,wBAAwB,CAAC;AAWhC,OAAO,KAAK,EAGV,sBAAsB,EACtB,uBAAuB,EACvB,wBAAwB,EACzB,MAAM,wBAAwB,CAAC;AAChC,YAAY,EACV,qBAAqB,EACrB,uBAAuB,EACvB,sBAAsB,EACtB,uBAAuB,EACvB,wBAAwB,GACzB,MAAM,wBAAwB,CAAC;AAUhC,OAAO,EACL,6BAA6B,EAC7B,oCAAoC,EACpC,8BAA8B,GAC/B,CAAC;AAEF,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,MAAM,EAChB,MAAM,GAAE,MAAmB,GAC1B,sBAAsB,CAqBxB;AAqBD,wBAAgB,sCAAsC,CACpD,EAAE,EAAE,QAAQ,CAAC,SAAS,GACrB,wBAAwB,CA4C1B;AAED,wBAAsB,kCAAkC,CACtD,EAAE,EAAE,wBAAwB,EAC5B,OAAO,EAAE,sBAAsB,GAC9B,OAAO,CAAC,uBAAuB,CAAC,CAiGlC;AA8CD,wBAAsB,iCAAiC,CACrD,EAAE,EAAE,QAAQ,CAAC,SAAS,EACtB,OAAO,EAAE,sBAAsB,GAC9B,OAAO,CAAC,uBAAuB,CAAC,CAKlC"}

package/dist/interaction/askUserQuestion.js

@@ -0,0 +1,295 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAskUserQuestionRequest = exports.createDefaultAskUserQuestionResponse = exports.createAskUserQuestionResponse = void 0;
+exports.createApprovalAskUserQuestion = createApprovalAskUserQuestion;
+exports.createReadlineAskUserQuestionUiContext = createReadlineAskUserQuestionUiContext;
+exports.promptAskUserQuestionWithUiContext = promptAskUserQuestionWithUiContext;
+exports.promptAskUserQuestionWithReadline = promptAskUserQuestionWithReadline;
+const core_1 = require("./askUserQuestion/core");
+Object.defineProperty(exports, "createAskUserQuestionResponse", { enumerable: true, get: function () { return core_1.createAskUserQuestionResponse; } });
+Object.defineProperty(exports, "createDefaultAskUserQuestionResponse", { enumerable: true, get: function () { return core_1.createDefaultAskUserQuestionResponse; } });
+Object.defineProperty(exports, "validateAskUserQuestionRequest", { enumerable: true, get: function () { return core_1.validateAskUserQuestionRequest; } });
+const terminal_1 = require("./askUserQuestion/terminal");
+function askLine(rl, prompt) {
+    return new Promise((resolve) => {
+        rl.question(`${terminal_1.CYAN}?${terminal_1.RESET} ${prompt} `, (answer) => {
+            resolve(answer.trim());
+        });
+    });
+}
+function createApprovalAskUserQuestion(question, header = "Decision") {
+    return {
+        questions: [
+            {
+                header,
+                question,
+                options: [
+                    {
+                        label: "Approve",
+                        description: "Continue the orchestration loop.",
+                    },
+                    {
+                        label: "Reject",
+                        description: "Block the breakpoint and return a rejected decision.",
+                    },
+                ],
+                allowOther: false,
+                required: true,
+            },
+        ],
+    };
+}
+function formatUiPromptTitle(question) {
+    const lines = [question.question.trim()];
+    if (question.options?.length) {
+        lines.push("");
+        for (const [index, option] of question.options.entries()) {
+            const detailParts = [option.description?.trim(), option.preview?.trim()].filter(Boolean);
+            const detail = detailParts.length > 0 ? ` - ${detailParts.join(" | ")}` : "";
+            lines.push(`${index + 1}. ${option.label}${detail}`);
+        }
+    }
+    return lines.join("\n");
+}
+function buildUiTitle(question) {
+    const header = question.header?.trim();
+    const body = formatUiPromptTitle(question);
+    return header ? `${header}\n\n${body}` : body;
+}
+function createReadlineAskUserQuestionUiContext(rl) {
+    return {
+        async select(title, options) {
+            process.stderr.write(`${title}\n`);
+            // Use arrow-key selector when stdin is a TTY
+            if ((0, terminal_1.isTTYInput)(process.stdin)) {
+                const idx = await (0, terminal_1.promptArrowKeySelect)(process.stdin, process.stderr, options);
+                if (idx == null || typeof idx !== "number")
+                    return undefined;
+                return options[idx];
+            }
+            // Fallback: line-based prompt
+            for (const [index, option] of options.entries()) {
+                process.stderr.write(`  ${index + 1}. ${option}\n`);
+            }
+            let matched;
+            while (!matched) {
+                const answer = await askLine(rl, "Choose an option (number or label)");
+                if (!answer) {
+                    return undefined;
+                }
+                matched = (0, core_1.resolveOption)(answer, options.map((label) => ({ label })));
+                if (matched) {
+                    return matched.label;
+                }
+                process.stderr.write(`${terminal_1.YELLOW}Please choose a valid option.${terminal_1.RESET}\n`);
+            }
+        },
+        async input(title, placeholder) {
+            process.stderr.write(`${title}\n`);
+            const answer = await askLine(rl, placeholder?.trim() || "Answer");
+            return answer || undefined;
+        },
+        async confirm(title, message) {
+            process.stderr.write(`${title}\n${message}\n`);
+            const answer = await askLine(rl, "Confirm (y/N)");
+            return ["y", "yes"].includes(answer.trim().toLowerCase());
+        },
+    };
+}
+async function promptAskUserQuestionWithUiContext(ui, request) {
+    return runAskUserQuestionPrompt(request, async () => {
+        const answers = {};
+        for (const [index, question] of request.questions.entries()) {
+            const key = (0, core_1.getQuestionKey)(question, index);
+            const options = question.options ?? [];
+            if (options.length === 0) {
+                let resolved = false;
+                while (!resolved) {
+                    const answer = (await ui.input(buildUiTitle(question), question.required ? "Answer (required)" : "Answer"))?.trim();
+                    if (answer) {
+                        answers[key] = answer;
+                        resolved = true;
+                        continue;
+                    }
+                    if (!question.required) {
+                        answers[key] = "";
+                        resolved = true;
+                    }
+                }
+                continue;
+            }
+            if (question.multiSelect) {
+                let resolved = false;
+                while (!resolved) {
+                    const rawAnswer = (await ui.input(buildUiTitle(question), "Enter one or more options (numbers or labels, comma-separated)"))?.trim() ?? "";
+                    if (!rawAnswer && !question.required) {
+                        answers[key] = "";
+                        resolved = true;
+                        continue;
+                    }
+                    const parsed = (0, core_1.parseOptionAnswer)(rawAnswer, question);
+                    if (parsed !== undefined) {
+                        answers[key] = parsed;
+                        resolved = true;
+                    }
+                }
+                continue;
+            }
+            const allowOther = question.allowOther !== false;
+            const optionLabels = options.map((option) => option.label);
+            const selectOptions = allowOther
+                ? [...optionLabels, "Other (type a custom answer)"]
+                : optionLabels;
+            let resolved = false;
+            while (!resolved) {
+                const selection = await ui.select(buildUiTitle(question), selectOptions);
+                if (!selection) {
+                    if (question.required) {
+                        continue;
+                    }
+                    answers[key] = "";
+                    resolved = true;
+                    continue;
+                }
+                if (allowOther && selection === "Other (type a custom answer)") {
+                    const other = (await ui.input(buildUiTitle(question), "Type your answer"))?.trim();
+                    if (other) {
+                        answers[key] = other;
+                        resolved = true;
+                        continue;
+                    }
+                    if (!question.required) {
+                        answers[key] = "";
+                        resolved = true;
+                    }
+                    continue;
+                }
+                const parsed = (0, core_1.parseOptionAnswer)(selection, {
+                    ...question,
+                    allowOther: false,
+                });
+                if (parsed !== undefined) {
+                    answers[key] = parsed;
+                    resolved = true;
+                }
+            }
+        }
+        return (0, core_1.createAskUserQuestionResponse)(request, answers);
+    });
+}
+function runAskUserQuestionPrompt(request, runInteractive) {
+    (0, core_1.validateAskUserQuestionRequest)(request);
+    if (request.timeout == null || request.timeout <= 0) {
+        return runInteractive();
+    }
+    const fallbackResponse = (0, core_1.createDefaultAskUserQuestionResponse)(request);
+    return new Promise((resolve) => {
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            process.stderr.write(`${terminal_1.YELLOW}Ask timeout reached (${request.timeout}ms). Auto-selecting defaults.${terminal_1.RESET}\n`);
+            resolve(fallbackResponse);
+        }, request.timeout);
+        runInteractive()
+            .then((response) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            resolve(response);
+        })
+            .catch(() => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            resolve(fallbackResponse);
+        });
+    });
+}
+async function promptAskUserQuestionWithReadline(rl, request) {
+    return runAskUserQuestionPrompt(request, () => promptAskUserQuestionInteractive(rl, request));
+}
+async function promptAskUserQuestionInteractive(rl, request) {
+    const answers = {};
+    for (const [index, question] of request.questions.entries()) {
+        const key = (0, core_1.getQuestionKey)(question, index);
+        const options = question.options ?? [];
+        if (question.header?.trim()) {
+            process.stderr.write(`\n${terminal_1.BOLD}${question.header.trim()}${terminal_1.RESET}\n`);
+        }
+        process.stderr.write(`${question.question}\n`);
+        if (options.length > 0 && (0, terminal_1.isTTYInput)(process.stdin)) {
+            // Arrow-key interactive selection
+            const optionLabels = options.map((o) => {
+                const desc = o.description ? ` ${terminal_1.DIM}${o.description}${terminal_1.RESET}` : "";
+                return `${o.label}${desc}`;
+            });
+            if (question.multiSelect) {
+                const result = await (0, terminal_1.promptArrowKeySelect)(process.stdin, process.stderr, optionLabels, { multiSelect: true });
+                if (Array.isArray(result) && result.length > 0) {
+                    answers[key] = result.map((i) => options[i].label).join(", ");
+                }
+                else if (!question.required) {
+                    answers[key] = "";
+                }
+                else {
+                    // Required but cancelled — use first option as fallback
+                    answers[key] = options[0].label;
+                }
+            }
+            else {
+                const result = await (0, terminal_1.promptArrowKeySelect)(process.stdin, process.stderr, optionLabels);
+                if (typeof result === "number") {
+                    answers[key] = options[result].label;
+                }
+                else if (!question.required) {
+                    answers[key] = "";
+                }
+                else {
+                    answers[key] = options[0].label;
+                }
+            }
+        }
+        else if (options.length > 0) {
+            // Fallback: line-based prompt for non-TTY
+            for (const [optionIndex, option] of options.entries()) {
+                const description = option.description ? ` ${terminal_1.DIM}${option.description}${terminal_1.RESET}` : "";
+                const preview = option.preview ? ` ${terminal_1.YELLOW}[preview]${terminal_1.RESET}` : "";
+                process.stderr.write(`  ${optionIndex + 1}. ${option.label}${description}${preview}\n`);
+            }
+            let answered = false;
+            while (!answered) {
+                const prompt = question.multiSelect
+                    ? "Choose one or more options (numbers or labels, comma-separated)"
+                    : "Choose an option (number or label)";
+                const answer = await askLine(rl, prompt);
+                const parsed = (0, core_1.parseOptionAnswer)(answer, question);
+                if (parsed !== undefined) {
+                    answers[key] = parsed;
+                    answered = true;
+                    continue;
+                }
+                process.stderr.write(`${terminal_1.YELLOW}Please choose a valid option.${terminal_1.RESET}\n`);
+            }
+        }
+        else {
+            let answered = false;
+            while (!answered) {
+                const answer = await askLine(rl, "Answer");
+                if (!answer && question.required) {
+                    process.stderr.write(`${terminal_1.YELLOW}An answer is required.${terminal_1.RESET}\n`);
+                    continue;
+                }
+                answers[key] = answer;
+                answered = true;
+            }
+        }
+    }
+    return (0, core_1.createAskUserQuestionResponse)(request, answers);
+}

package/dist/interaction/askUserQuestionTypes.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Type definitions for askUserQuestion.
+ * Extracted from askUserQuestion.ts for max-lines compliance.
+ */
+export interface AskUserQuestionOption {
+    label: string;
+    description?: string;
+    preview?: string;
+}
+export interface AskUserQuestionQuestion {
+    question: string;
+    header?: string;
+    options?: AskUserQuestionOption[];
+    multiSelect?: boolean;
+    allowOther?: boolean;
+    required?: boolean;
+    recommended?: number;
+}
+export interface AskUserQuestionRequest {
+    questions: AskUserQuestionQuestion[];
+    timeout?: number;
+}
+export interface AskUserQuestionResponse {
+    answers: Record<string, string>;
+}
+export interface AskUserQuestionUiContext {
+    select(title: string, options: string[]): Promise<string | undefined>;
+    input(title: string, placeholder?: string): Promise<string | undefined>;
+    confirm(title: string, message: string): Promise<boolean>;
+}
+//# sourceMappingURL=askUserQuestionTypes.d.ts.map