agentweaver 0.1.4 → 0.1.6

package/dist/prompts.js

@@ -1,9 +1,15 @@
 export const BASE_PROMPT_HEADER = "Основная задача:";
 export const EXTRA_PROMPT_HEADER = "Дополнительные указания:";
 export const PLAN_PROMPT_TEMPLATE = "Посмотри и проанализируй задачу в {jira_task_file}. " +
-    "Разработай системный дизайн решения, запиши в {design_file}. " +
-    "Разработай подробный план реализации и запиши его в {plan_file}. " +
-    "Разработай план тестирования для QA и запиши в {qa_file}. ";
+    "Сначала создай структурированные JSON-артефакты, они являются source of truth для следующих flow. " +
+    "Человекочитаемые markdown-файлы сделай как краткое производное представление этих JSON-артефактов для пользователя. " +
+    "Разработай системный дизайн решения и запиши JSON в {design_json_file}, затем markdown в {design_file}. " +
+    "Для {design_json_file} используй объект: { summary: string, goals: string[], non_goals: string[], components: string[], decisions: [{ component: string, decision: string, rationale: string }], risks: string[], open_questions: string[] }. " +
+    "Разработай подробный план реализации и запиши JSON в {plan_json_file}, затем markdown в {plan_file}. " +
+    "Для {plan_json_file} используй объект: { summary: string, prerequisites: string[], implementation_steps: [{ id: string, title: string, details: string }], tests: string[], rollout_notes: string[] }. " +
+    "Разработай план тестирования для QA и запиши JSON в {qa_json_file}, затем markdown в {qa_file}. " +
+    "Для {qa_json_file} используй объект: { summary: string, test_scenarios: [{ id: string, title: string, expected_result: string }], non_functional_checks: string[] }. " +
+    "JSON-файлы должны быть валидными и содержать только JSON без markdown-обёртки. ";
 export const BUG_ANALYZE_PROMPT_TEMPLATE = "Посмотри и проанализируй баг в {jira_task_file}. " +
     "Сначала создай структурированные JSON-артефакты, они являются source of truth для следующих flow. " +
     "Человекочитаемые markdown-файлы сделай как краткое производное представление этих JSON-артефактов для пользователя. " +
@@ -22,31 +28,34 @@ export const BUG_FIX_PROMPT_TEMPLATE = "Используй только стру
     "После этого приступай к реализации исправления в коде. ";
 export const MR_DESCRIPTION_PROMPT_TEMPLATE = "Посмотри задачу в {jira_task_file} и текущие изменения в репозитории. " +
     "Подготовь очень краткое intent-описание для merge request без подробностей реализации, списков файлов и технических деталей. " +
-    "Сфокусируйся на том, что меняется и зачем. Запиши результат в {mr_description_file}. ";
-export const IMPLEMENT_PROMPT_TEMPLATE = "Проанализируй системный дизайн {design_file}, план реализации {plan_file} и приступай к реализации по плану. ";
+    "Сначала запиши source-of-truth JSON в {mr_description_json_file} в виде объекта { summary: string }, затем производную markdown-версию в {mr_description_file}. ";
+export const IMPLEMENT_PROMPT_TEMPLATE = "Используй только структурированные артефакты как source of truth. " +
+    "Проанализируй системный дизайн {design_json_file}, план реализации {plan_json_file} и приступай к реализации по плану. " +
+    "Markdown-артефакты предназначены только для чтения человеком и не должны определять реализацию. ";
 export const REVIEW_PROMPT_TEMPLATE = "Проведи код-ревью текущих изменений. " +
-    "Сверься с задачей в {jira_task_file}, дизайном {design_file} и планом {plan_file}. " +
-    "Замечания и комментарии запиши в {review_file}. " +
-    "Если больше нет блокеров, препятствующих merge - создай файл ready-to-merge.md.";
-export const REVIEW_REPLY_PROMPT_TEMPLATE = "Твой коллега провёл код-ревью и записал комментарии в {review_file}. " +
-    "Проанализируй комментарии к код-ревью, сверься с задачей в {jira_task_file}, " +
-    "дизайном {design_file}, планом {plan_file} и запиши свои комментарии в {review_reply_file}.";
+    "Используй только структурированные артефакты как source of truth: задачу в {jira_task_file}, дизайн в {design_json_file} и план в {plan_json_file}. " +
+    "Сначала запиши структурированный результат в {review_json_file} в виде объекта { summary: string, ready_to_merge: boolean, findings: [{ severity: string, title: string, description: string }] }. " +
+    "Затем запиши производную markdown-версию в {review_file}. " +
+    "Если ready_to_merge=true и нет блокеров, препятствующих merge - создай файл ready-to-merge.md.";
+export const REVIEW_REPLY_PROMPT_TEMPLATE = "Твой коллега провёл код-ревью и записал структурированный результат в {review_json_file}. " +
+    "Используй только структурированные артефакты как source of truth: задачу в {jira_task_file}, дизайн в {design_json_file}, план в {plan_json_file} и review в {review_json_file}. " +
+    "Сначала запиши структурированный ответ в {review_reply_json_file} в виде объекта { summary: string, ready_to_merge: boolean, responses: [{ finding_title: string, disposition: string, action: string }] }. " +
+    "Затем запиши производную markdown-версию в {review_reply_file}.";
 export const REVIEW_SUMMARY_PROMPT_TEMPLATE = "Посмотри в {review_file}. " +
     "Сделай краткий список комментариев без подробностей, 3-7 пунктов. " +
     "Запиши результат в {review_summary_file}.";
 export const REVIEW_REPLY_SUMMARY_PROMPT_TEMPLATE = "Посмотри в {review_reply_file}. " +
     "Сделай краткий список ответов и итоговых действий без подробностей, 3-7 пунктов. " +
     "Запиши результат в {review_reply_summary_file}.";
-export const REVIEW_FIX_PROMPT_TEMPLATE = "Проанализируй комментарии в {review_reply_file}. " +
+export const REVIEW_FIX_PROMPT_TEMPLATE = "Используй только структурированные артефакты как source of truth. " +
+    "Проанализируй комментарии в {review_reply_json_file}. " +
     "Исправь то, что содержится в дополнительных указаниях, а если таковых нет - исправь все пункты. " +
     "По окончании обязательно прогони вне песочницы линтер, все тесты, сгенерируй make swagger. " +
     "Исправь ошибки линтера и тестов, если будут. " +
-    "По завершении резюме запиши в {review_fix_file}.";
+    "По завершении сначала запиши структурированный отчёт в {review_fix_json_file} в виде объекта { summary: string, completed_actions: string[], validation_steps: string[] }, затем производную markdown-версию в {review_fix_file}.";
 export const TASK_SUMMARY_PROMPT_TEMPLATE = "Посмотри в {jira_task_file}. " +
-    "Сделай краткое резюме задачи, на 1-2 абзаца, " +
-    "запиши в {task_summary_file}.";
-export const TEST_FIX_PROMPT_TEMPLATE = "Прогони тесты, исправь ошибки.";
-export const TEST_LINTER_FIX_PROMPT_TEMPLATE = "Прогони линтер, исправь замечания.";
+    "Сделай краткое резюме задачи, на 1-2 абзаца. " +
+    "Сначала запиши source-of-truth JSON в {task_summary_json_file} в виде объекта { summary: string }, затем markdown-версию в {task_summary_file}.";
 export const RUN_TESTS_LOOP_FIX_PROMPT_TEMPLATE = "Запусти ./run_tests.sh, проанализируй последнюю ошибку проверки, исправь код и подготовь изменения так, чтобы следующий прогон run_tests.sh прошёл успешно.";
 export const RUN_LINTER_LOOP_FIX_PROMPT_TEMPLATE = "Запусти ./run_linter.sh, проанализируй последнюю ошибку линтера или генерации, исправь код и подготовь изменения так, чтобы следующий прогон run_linter.sh прошёл успешно.";
 export const AUTO_REVIEW_FIX_EXTRA_PROMPT = "Исправлять только блокеры, критикалы и важные";

package/dist/structured-artifacts.js

@@ -8,23 +8,119 @@ function expectNonEmptyString(value, path, issues) {
         issues.push(`${path} must be a non-empty string`);
     }
 }
-function expectStringArray(value, path, issues) {
+function expectBoolean(value, path, issues) {
+    if (typeof value !== "boolean") {
+        issues.push(`${path} must be a boolean`);
+    }
+}
+function expectObject(value, path, issues) {
+    if (!isRecord(value)) {
+        issues.push(`${path} must be an object`);
+        return false;
+    }
+    return true;
+}
+function expectStringArray(value, path, issues, allowEmpty = false) {
     if (!Array.isArray(value)) {
         issues.push(`${path} must be an array`);
         return;
     }
-    if (value.length === 0) {
+    if (!allowEmpty && value.length === 0) {
         issues.push(`${path} must not be empty`);
         return;
     }
     value.forEach((item, index) => expectNonEmptyString(item, `${path}[${index}]`, issues));
 }
-function expectObject(value, path, issues) {
-    if (!isRecord(value)) {
-        issues.push(`${path} must be an object`);
-        return false;
+function expectObjectArray(value, path, issues, validateItem, allowEmpty = false) {
+    if (!Array.isArray(value)) {
+        issues.push(`${path} must be an array`);
+        return;
     }
-    return true;
+    if (!allowEmpty && value.length === 0) {
+        issues.push(`${path} must not be empty`);
+        return;
+    }
+    value.forEach((item, index) => {
+        const itemPath = `${path}[${index}]`;
+        if (!expectObject(item, itemPath, issues)) {
+            return;
+        }
+        validateItem(item, itemPath, issues);
+    });
+}
+function validateBriefText(value, path, issues) {
+    if (!expectObject(value, path, issues)) {
+        return;
+    }
+    expectNonEmptyString(value.summary, `${path}.summary`, issues);
+}
+function expectNumber(value, path, issues) {
+    if (typeof value !== "number" || Number.isNaN(value)) {
+        issues.push(`${path} must be a number`);
+    }
+}
+function implementationDesignSchema() {
+    return {
+        id: "implementation-design/v1",
+        validate({ path, value }) {
+            const issues = [];
+            if (!expectObject(value, path, issues)) {
+                return issues;
+            }
+            expectNonEmptyString(value.summary, `${path}.summary`, issues);
+            expectStringArray(value.goals, `${path}.goals`, issues);
+            expectStringArray(value.non_goals, `${path}.non_goals`, issues, true);
+            expectStringArray(value.components, `${path}.components`, issues);
+            expectObjectArray(value.decisions, `${path}.decisions`, issues, (item, itemPath, currentIssues) => {
+                expectNonEmptyString(item.component, `${itemPath}.component`, currentIssues);
+                expectNonEmptyString(item.decision, `${itemPath}.decision`, currentIssues);
+                expectNonEmptyString(item.rationale, `${itemPath}.rationale`, currentIssues);
+            });
+            expectStringArray(value.risks, `${path}.risks`, issues, true);
+            expectStringArray(value.open_questions, `${path}.open_questions`, issues, true);
+            return issues;
+        },
+    };
+}
+function implementationPlanSchema() {
+    return {
+        id: "implementation-plan/v1",
+        validate({ path, value }) {
+            const issues = [];
+            if (!expectObject(value, path, issues)) {
+                return issues;
+            }
+            expectNonEmptyString(value.summary, `${path}.summary`, issues);
+            expectStringArray(value.prerequisites, `${path}.prerequisites`, issues, true);
+            expectObjectArray(value.implementation_steps, `${path}.implementation_steps`, issues, (item, itemPath, currentIssues) => {
+                expectNonEmptyString(item.id, `${itemPath}.id`, currentIssues);
+                expectNonEmptyString(item.title, `${itemPath}.title`, currentIssues);
+                expectNonEmptyString(item.details, `${itemPath}.details`, currentIssues);
+            });
+            expectStringArray(value.tests, `${path}.tests`, issues);
+            expectStringArray(value.rollout_notes, `${path}.rollout_notes`, issues, true);
+            return issues;
+        },
+    };
+}
+function qaPlanSchema() {
+    return {
+        id: "qa-plan/v1",
+        validate({ path, value }) {
+            const issues = [];
+            if (!expectObject(value, path, issues)) {
+                return issues;
+            }
+            expectNonEmptyString(value.summary, `${path}.summary`, issues);
+            expectObjectArray(value.test_scenarios, `${path}.test_scenarios`, issues, (item, itemPath, currentIssues) => {
+                expectNonEmptyString(item.id, `${itemPath}.id`, currentIssues);
+                expectNonEmptyString(item.title, `${itemPath}.title`, currentIssues);
+                expectNonEmptyString(item.expected_result, `${itemPath}.expected_result`, currentIssues);
+            });
+            expectStringArray(value.non_functional_checks, `${path}.non_functional_checks`, issues, true);
+            return issues;
+        },
+    };
 }
 function bugAnalysisSchema() {
     return {
@@ -42,13 +138,8 @@ function bugAnalysisSchema() {
             expectStringArray(value.reproduction_steps, `${path}.reproduction_steps`, issues);
             expectStringArray(value.affected_components, `${path}.affected_components`, issues);
             expectStringArray(value.evidence, `${path}.evidence`, issues);
-            expectStringArray(value.risks, `${path}.risks`, issues);
-            if (!Array.isArray(value.open_questions)) {
-                issues.push(`${path}.open_questions must be an array`);
-            }
-            else {
-                value.open_questions.forEach((item, index) => expectNonEmptyString(item, `${path}.open_questions[${index}]`, issues));
-            }
+            expectStringArray(value.risks, `${path}.risks`, issues, true);
+            expectStringArray(value.open_questions, `${path}.open_questions`, issues, true);
             return issues;
         },
     };
@@ -56,93 +147,106 @@ function bugAnalysisSchema() {
 function bugFixDesignSchema() {
     return {
         id: "bug-fix-design/v1",
+        validate: implementationDesignSchema().validate,
+    };
+}
+function bugFixPlanSchema() {
+    return {
+        id: "bug-fix-plan/v1",
+        validate: implementationPlanSchema().validate,
+    };
+}
+function reviewFindingsSchema() {
+    return {
+        id: "review-findings/v1",
         validate({ path, value }) {
             const issues = [];
             if (!expectObject(value, path, issues)) {
                 return issues;
             }
             expectNonEmptyString(value.summary, `${path}.summary`, issues);
-            expectStringArray(value.goals, `${path}.goals`, issues);
-            if (!Array.isArray(value.non_goals)) {
-                issues.push(`${path}.non_goals must be an array`);
-            }
-            else {
-                value.non_goals.forEach((item, index) => expectNonEmptyString(item, `${path}.non_goals[${index}]`, issues));
-            }
-            expectStringArray(value.target_components, `${path}.target_components`, issues);
-            if (!Array.isArray(value.proposed_changes)) {
-                issues.push(`${path}.proposed_changes must be an array`);
-            }
-            else if (value.proposed_changes.length === 0) {
-                issues.push(`${path}.proposed_changes must not be empty`);
-            }
-            else {
-                value.proposed_changes.forEach((item, index) => {
-                    if (!expectObject(item, `${path}.proposed_changes[${index}]`, issues)) {
-                        return;
-                    }
-                    expectNonEmptyString(item.component, `${path}.proposed_changes[${index}].component`, issues);
-                    expectNonEmptyString(item.change, `${path}.proposed_changes[${index}].change`, issues);
-                    expectNonEmptyString(item.rationale, `${path}.proposed_changes[${index}].rationale`, issues);
-                });
-            }
-            if (!Array.isArray(value.alternatives_considered)) {
-                issues.push(`${path}.alternatives_considered must be an array`);
-            }
-            else {
-                value.alternatives_considered.forEach((item, index) => {
-                    if (!expectObject(item, `${path}.alternatives_considered[${index}]`, issues)) {
-                        return;
-                    }
-                    expectNonEmptyString(item.option, `${path}.alternatives_considered[${index}].option`, issues);
-                    expectNonEmptyString(item.decision, `${path}.alternatives_considered[${index}].decision`, issues);
-                    expectNonEmptyString(item.rationale, `${path}.alternatives_considered[${index}].rationale`, issues);
-                });
-            }
-            expectStringArray(value.risks, `${path}.risks`, issues);
-            expectStringArray(value.validation_strategy, `${path}.validation_strategy`, issues);
+            expectBoolean(value.ready_to_merge, `${path}.ready_to_merge`, issues);
+            expectObjectArray(value.findings, `${path}.findings`, issues, (item, itemPath, currentIssues) => {
+                expectNonEmptyString(item.severity, `${itemPath}.severity`, currentIssues);
+                expectNonEmptyString(item.title, `${itemPath}.title`, currentIssues);
+                expectNonEmptyString(item.description, `${itemPath}.description`, currentIssues);
+            }, true);
             return issues;
         },
     };
 }
-function bugFixPlanSchema() {
+function reviewReplySchema() {
     return {
-        id: "bug-fix-plan/v1",
+        id: "review-reply/v1",
         validate({ path, value }) {
             const issues = [];
             if (!expectObject(value, path, issues)) {
                 return issues;
             }
             expectNonEmptyString(value.summary, `${path}.summary`, issues);
-            if (!Array.isArray(value.prerequisites)) {
-                issues.push(`${path}.prerequisites must be an array`);
-            }
-            else {
-                value.prerequisites.forEach((item, index) => expectNonEmptyString(item, `${path}.prerequisites[${index}]`, issues));
-            }
-            if (!Array.isArray(value.implementation_steps)) {
-                issues.push(`${path}.implementation_steps must be an array`);
-            }
-            else if (value.implementation_steps.length === 0) {
-                issues.push(`${path}.implementation_steps must not be empty`);
-            }
-            else {
-                value.implementation_steps.forEach((item, index) => {
-                    if (!expectObject(item, `${path}.implementation_steps[${index}]`, issues)) {
-                        return;
-                    }
-                    expectNonEmptyString(item.id, `${path}.implementation_steps[${index}].id`, issues);
-                    expectNonEmptyString(item.title, `${path}.implementation_steps[${index}].title`, issues);
-                    expectNonEmptyString(item.details, `${path}.implementation_steps[${index}].details`, issues);
-                });
+            expectObjectArray(value.responses, `${path}.responses`, issues, (item, itemPath, currentIssues) => {
+                expectNonEmptyString(item.finding_title, `${itemPath}.finding_title`, currentIssues);
+                expectNonEmptyString(item.disposition, `${itemPath}.disposition`, currentIssues);
+                expectNonEmptyString(item.action, `${itemPath}.action`, currentIssues);
+            }, true);
+            expectBoolean(value.ready_to_merge, `${path}.ready_to_merge`, issues);
+            return issues;
+        },
+    };
+}
+function reviewFixReportSchema() {
+    return {
+        id: "review-fix-report/v1",
+        validate({ path, value }) {
+            const issues = [];
+            if (!expectObject(value, path, issues)) {
+                return issues;
             }
-            expectStringArray(value.tests, `${path}.tests`, issues);
-            if (!Array.isArray(value.rollout_notes)) {
-                issues.push(`${path}.rollout_notes must be an array`);
+            expectNonEmptyString(value.summary, `${path}.summary`, issues);
+            expectStringArray(value.completed_actions, `${path}.completed_actions`, issues);
+            expectStringArray(value.validation_steps, `${path}.validation_steps`, issues, true);
+            return issues;
+        },
+    };
+}
+function gitlabReviewSchema() {
+    return {
+        id: "gitlab-review/v1",
+        validate({ path, value }) {
+            const issues = [];
+            if (!expectObject(value, path, issues)) {
+                return issues;
             }
-            else {
-                value.rollout_notes.forEach((item, index) => expectNonEmptyString(item, `${path}.rollout_notes[${index}]`, issues));
+            expectNonEmptyString(value.summary, `${path}.summary`, issues);
+            expectNonEmptyString(value.merge_request_url, `${path}.merge_request_url`, issues);
+            expectNonEmptyString(value.project_path, `${path}.project_path`, issues);
+            expectNumber(value.merge_request_iid, `${path}.merge_request_iid`, issues);
+            expectNonEmptyString(value.fetched_at, `${path}.fetched_at`, issues);
+            expectObjectArray(value.comments, `${path}.comments`, issues, (item, itemPath, currentIssues) => {
+                expectNonEmptyString(item.id, `${itemPath}.id`, currentIssues);
+                expectNonEmptyString(item.discussion_id, `${itemPath}.discussion_id`, currentIssues);
+                expectNonEmptyString(item.body, `${itemPath}.body`, currentIssues);
+                expectNonEmptyString(item.author, `${itemPath}.author`, currentIssues);
+                expectNonEmptyString(item.created_at, `${itemPath}.created_at`, currentIssues);
+                if (item.file_path !== undefined && item.file_path !== null) {
+                    expectNonEmptyString(item.file_path, `${itemPath}.file_path`, currentIssues);
+                }
+            }, true);
+            return issues;
+        },
+    };
+}
+function userInputSchema() {
+    return {
+        id: "user-input/v1",
+        validate({ path, value }) {
+            const issues = [];
+            if (!expectObject(value, path, issues)) {
+                return issues;
             }
+            expectNonEmptyString(value.form_id, `${path}.form_id`, issues);
+            expectNonEmptyString(value.submitted_at, `${path}.submitted_at`, issues);
+            expectObject(value.values, `${path}.values`, issues);
             return issues;
         },
     };
@@ -151,6 +255,29 @@ const schemas = {
     "bug-analysis/v1": bugAnalysisSchema(),
     "bug-fix-design/v1": bugFixDesignSchema(),
     "bug-fix-plan/v1": bugFixPlanSchema(),
+    "gitlab-review/v1": gitlabReviewSchema(),
+    "implementation-design/v1": implementationDesignSchema(),
+    "implementation-plan/v1": implementationPlanSchema(),
+    "jira-description/v1": { id: "jira-description/v1", validate: ({ path, value }) => {
+            const issues = [];
+            validateBriefText(value, path, issues);
+            return issues;
+        } },
+    "mr-description/v1": { id: "mr-description/v1", validate: ({ path, value }) => {
+            const issues = [];
+            validateBriefText(value, path, issues);
+            return issues;
+        } },
+    "qa-plan/v1": qaPlanSchema(),
+    "review-findings/v1": reviewFindingsSchema(),
+    "review-fix-report/v1": reviewFixReportSchema(),
+    "review-reply/v1": reviewReplySchema(),
+    "task-summary/v1": { id: "task-summary/v1", validate: ({ path, value }) => {
+            const issues = [];
+            validateBriefText(value, path, issues);
+            return issues;
+        } },
+    "user-input/v1": userInputSchema(),
 };
 export function validateStructuredArtifact(path, schemaId) {
     if (!existsSync(path)) {

package/dist/user-input.js

@@ -0,0 +1,171 @@
+import process from "node:process";
+import { createInterface } from "node:readline/promises";
+import { TaskRunnerError } from "./errors.js";
+function normalizeText(value) {
+    return value.trim();
+}
+export function defaultValueForField(field) {
+    if (field.type === "boolean") {
+        return field.default ?? false;
+    }
+    if (field.type === "text") {
+        return field.default ?? "";
+    }
+    if (field.type === "single-select") {
+        return field.default ?? field.options[0]?.value ?? "";
+    }
+    return [...(field.default ?? [])];
+}
+export function buildInitialUserInputValues(fields) {
+    return Object.fromEntries(fields.map((field) => [field.id, defaultValueForField(field)]));
+}
+export function validateUserInputValues(form, values) {
+    for (const field of form.fields) {
+        const value = values[field.id];
+        if (field.type === "boolean") {
+            if (typeof value !== "boolean") {
+                throw new TaskRunnerError(`Field '${field.label}' must be a boolean.`);
+            }
+            continue;
+        }
+        if (field.type === "text") {
+            if (typeof value !== "string") {
+                throw new TaskRunnerError(`Field '${field.label}' must be a string.`);
+            }
+            if (field.required && normalizeText(value).length === 0) {
+                throw new TaskRunnerError(`Field '${field.label}' is required.`);
+            }
+            continue;
+        }
+        if (field.type === "single-select") {
+            if (typeof value !== "string") {
+                throw new TaskRunnerError(`Field '${field.label}' must be a string.`);
+            }
+            if (field.required && normalizeText(value).length === 0) {
+                throw new TaskRunnerError(`Field '${field.label}' is required.`);
+            }
+            if (value && !field.options.some((option) => option.value === value)) {
+                throw new TaskRunnerError(`Field '${field.label}' contains an unknown option '${value}'.`);
+            }
+            continue;
+        }
+        if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+            throw new TaskRunnerError(`Field '${field.label}' must be a string array.`);
+        }
+        if (field.required && value.length === 0) {
+            throw new TaskRunnerError(`Field '${field.label}' requires at least one selected option.`);
+        }
+        const allowed = new Set(field.options.map((option) => option.value));
+        for (const item of value) {
+            if (!allowed.has(item)) {
+                throw new TaskRunnerError(`Field '${field.label}' contains an unknown option '${item}'.`);
+            }
+        }
+    }
+    if (form.formId === "review-fix-selection") {
+        const applyAll = values.apply_all === true;
+        const selectedFindings = Array.isArray(values.selected_findings)
+            ? values.selected_findings.filter((item) => typeof item === "string" && item.trim().length > 0)
+            : [];
+        if (!applyAll && selectedFindings.length === 0) {
+            throw new TaskRunnerError("Select at least one finding or enable 'apply all'.");
+        }
+    }
+}
+function parseBoolean(value) {
+    const normalized = normalizeText(value).toLowerCase();
+    if (["y", "yes", "true", "1", "да", "д"].includes(normalized)) {
+        return true;
+    }
+    if (["n", "no", "false", "0", "нет", "н"].includes(normalized)) {
+        return false;
+    }
+    return null;
+}
+export async function requestUserInputInTerminal(form) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw new TaskRunnerError(`Flow requires interactive user input for form '${form.formId}', but no TTY is available.`);
+    }
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        process.stdout.write(`\n${form.title}\n`);
+        if (form.description?.trim()) {
+            process.stdout.write(`${form.description.trim()}\n`);
+        }
+        const values = buildInitialUserInputValues(form.fields);
+        for (const field of form.fields) {
+            if (field.type === "boolean") {
+                while (true) {
+                    const current = values[field.id];
+                    const answer = await rl.question(`${field.label} [y/n] (${current ? "y" : "n"}): `);
+                    const parsed = answer.trim() ? parseBoolean(answer) : Boolean(current);
+                    if (parsed === null) {
+                        process.stdout.write("Please answer y/n.\n");
+                        continue;
+                    }
+                    values[field.id] = parsed;
+                    break;
+                }
+                continue;
+            }
+            if (field.type === "text") {
+                const current = String(values[field.id] ?? "");
+                const answer = await rl.question(`${field.label}${current ? ` (${current})` : ""}: `);
+                values[field.id] = answer.trim() ? answer : current;
+                continue;
+            }
+            const options = field.options.map((option, index) => `${index + 1}. ${option.label}`).join("\n");
+            process.stdout.write(`${field.label}\n${options}\n`);
+            if (field.type === "single-select") {
+                while (true) {
+                    const current = String(values[field.id] ?? "");
+                    const answer = await rl.question(`Choose one option${current ? ` (${current})` : ""}: `);
+                    const raw = answer.trim();
+                    if (!raw && current) {
+                        break;
+                    }
+                    const index = Number.parseInt(raw, 10) - 1;
+                    const option = field.options[index];
+                    if (!option) {
+                        process.stdout.write("Unknown option number.\n");
+                        continue;
+                    }
+                    values[field.id] = option.value;
+                    break;
+                }
+                continue;
+            }
+            while (true) {
+                const current = Array.isArray(values[field.id]) ? values[field.id] : [];
+                const answer = await rl.question(`Choose one or more options separated by comma${current.length > 0 ? ` (${current.join(", ")})` : ""}: `);
+                const raw = answer.trim();
+                if (!raw && current.length > 0) {
+                    break;
+                }
+                const selected = raw
+                    .split(",")
+                    .map((item) => Number.parseInt(item.trim(), 10) - 1)
+                    .map((index) => field.options[index]?.value)
+                    .filter((item) => Boolean(item));
+                if (selected.length === 0 && field.required) {
+                    process.stdout.write("Select at least one option.\n");
+                    continue;
+                }
+                values[field.id] = selected;
+                break;
+            }
+        }
+        validateUserInputValues(form, values);
+        return {
+            formId: form.formId,
+            submittedAt: new Date().toISOString(),
+            values,
+        };
+    }
+    finally {
+        rl.close();
+    }
+}