@pugi/cli 0.1.0-beta.98 → 1.0.0-alpha.1

package/dist/core/artifact-chain/exporter.js

@@ -1,164 +0,0 @@
-/**
- * Artifact chain exporter — Pugi  .
- *
- * Bundles the seven step artifacts under `.pugi/chains/<id>/` into a
- * single markdown report (default) or a deterministic JSON envelope
- * the operator can feed into a future zip bundler. The exporter is
- * read-only — it never mutates state.
- *
- * Why markdown instead of an actual `.zip`: the CLI ships zero binary
- * dependencies (HARD rule for `@pugi/cli` install footprint — the
- * 4.4MB bundled-zip toolchains would land the install at ~20MB).
- * Operators that want a true zip pipe `pugi chain export` through
- * `zip -j chain.zip` or similar; the markdown form covers 95% of the
- * "share with my CTO" workflow without the dep.
- *
- * Module contract:
- *
- *  - `renderMarkdownReport` is pure. Pass it a snapshot + a map of
- *    filename → contents and it returns the rendered report. The
- *    CLI handler does the disk read; the spec drives the renderer
- *    with synthetic content so it never touches the filesystem.
- *
- *  - `exportChain` does the disk dance — reads every artifact that
- *    exists, skips missing ones (a partially-finished chain still
- *    exports cleanly), and returns the report + the list of
- *    skipped steps so the renderer can warn the operator.
- */
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { chainDir, readChain } from './state.js';
-import { CHAIN_STEPS } from './steps.js';
-/**
- * Render the markdown report. The format is intentionally stable so
- * downstream tools can grep it; do NOT reformat without bumping the
- * report version comment in the header.
- *
- * Report layout:
- *
- *  # Pugi artifact chain: <chain id>
- *
- *  - **Intent**: ...
- *  - **Created**: ...
- *  - **Finalised**: ... (or "in progress")
- *
- *  ## 1. PRD — Olivia (PM)
- *  <contents>
- *
- *  ## 2. ADR — Marcus (CTO)
- *  <contents>
- *
- *  ... (one section per step)
- */
-export function renderMarkdownReport(envelope) {
-    const lines = [];
-    lines.push(`# Pugi artifact chain: ${envelope.chainId}`);
-    lines.push('');
-    lines.push(`- **Intent**: ${envelope.intent}`);
-    lines.push(`- **Created**: ${envelope.createdAt}`);
-    lines.push(`- **Finalised**: ${envelope.finalisedAt ?? 'in progress'}`);
-    if (envelope.missingSteps.length > 0) {
-        lines.push(`- **Missing steps**: ${envelope.missingSteps.join(', ')}`);
-    }
-    lines.push('');
-    for (const entry of envelope.artifacts) {
-        lines.push(`## ${entry.step.ordinal}. ${entry.step.id.toUpperCase()} — ${entry.step.personaLabel}`);
-        lines.push('');
-        if (entry.contents === null) {
-            lines.push(`_artifact not yet produced (${entry.step.artifactFilename})_`);
-        }
-        else {
-            const trimmed = entry.contents.trimEnd();
-            lines.push(trimmed.length === 0 ? '_empty artifact_' : trimmed);
-        }
-        lines.push('');
-    }
-    return lines.join('\n');
-}
-/**
- * Render a deterministic JSON envelope. Same shape as
- * `ChainExportEnvelope` minus the descriptor object (we serialise the
- * step id + ordinal + persona so the consumer does not need access to
- * the in-process descriptor table).
- */
-export function renderJsonReport(envelope) {
-    const serialisable = {
-        chainId: envelope.chainId,
-        intent: envelope.intent,
-        createdAt: envelope.createdAt,
-        finalisedAt: envelope.finalisedAt,
-        missingSteps: envelope.missingSteps,
-        artifacts: envelope.artifacts.map((entry) => ({
-            stepId: entry.step.id,
-            ordinal: entry.step.ordinal,
-            persona: entry.step.persona,
-            personaLabel: entry.step.personaLabel,
-            filename: entry.step.artifactFilename,
-            bytes: entry.bytes,
-            contents: entry.contents,
-        })),
-    };
-    return `${JSON.stringify(serialisable, null, 2)}\n`;
-}
-/**
- * Read the chain + every artifact on disk, build the envelope, and
- * render either markdown OR JSON. Returns BOTH the envelope and the
- * rendered string so callers can route to stdout, a file, or both.
- *
- * Non-throwing per the artifact-chain module contract — every failure
- * mode (chain not found, malformed state) returns a structured
- * `ok: false` result so callers can map to an exit code without a
- * try/catch wrapper.
- */
-export function exportChain(options) {
-    const state = readChain(options.workspaceCwd, options.chainId);
-    if (!state) {
-        return {
-            ok: false,
-            error: `chain ${options.chainId} not found`,
-            reason: 'chain_not_found',
-        };
-    }
-    const envelope = buildEnvelope(state, options.workspaceCwd);
-    const format = options.format ?? 'markdown';
-    const rendered = format === 'json' ? renderJsonReport(envelope) : renderMarkdownReport(envelope);
-    return { ok: true, envelope, rendered };
-}
-/**
- * Build the export envelope from a chain snapshot + the workspace
- * directory. Exported so the spec can drive the renderer against a
- * fixture state without an explicit disk read.
- */
-export function buildEnvelope(state, workspaceCwd, options = {}) {
-    const dir = chainDir(workspaceCwd, state.id);
-    const readArtifact = options.readArtifact ?? defaultReadArtifact;
-    const artifacts = [];
-    const missing = [];
-    for (const step of CHAIN_STEPS) {
-        const path = join(dir, step.artifactFilename);
-        const contents = readArtifact(path);
-        if (contents === null) {
-            missing.push(step.id);
-        }
-        artifacts.push({
-            step,
-            contents,
-            bytes: contents === null ? 0 : Buffer.byteLength(contents, 'utf8'),
-        });
-    }
-    const finalisedAt = state.nextStep === null ? state.updatedAt : null;
-    return {
-        chainId: state.id,
-        intent: state.intent,
-        createdAt: state.createdAt,
-        finalisedAt,
-        artifacts,
-        missingSteps: missing,
-    };
-}
-function defaultReadArtifact(path) {
-    if (!existsSync(path))
-        return null;
-    return readFileSync(path, 'utf8');
-}
-//# sourceMappingURL=exporter.js.map

package/dist/core/artifact-chain/state.js

@@ -1,243 +0,0 @@
-/**
- * Artifact chain state machine — Pugi  .
- *
- * Owns the on-disk persisted state for a single chain
- * (`.pugi/chains/<chain-id>/chain.json`). A chain is a deterministic
- * 7-step pipeline: each step is `pending` → `dispatched` → `complete`
- * (terminal). The machine never auto-advances; operator review between
- * steps is the gate. This file is pure with respect to the network and
- * stays small enough to import from the REPL hot path without dragging
- * the dispatcher graph along.
- *
- * Concurrency: the CLI is single-process per invocation; the on-disk
- * format tolerates two simultaneous readers (snapshot is atomic via
- * write-then-rename) but writers MUST take the per-chain directory as
- * an implicit lock. Multi-writer races are out-of-scope — the operator
- * runs one `pugi chain next` at a time.
- *
- * Backwards-compat: `schemaVersion` is pinned. Older chains with no
- * version field default to `1`. Bump + add migration logic when the
- * persisted shape changes.
- */
-import { mkdirSync, readFileSync, writeFileSync, existsSync, renameSync, readdirSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-import { randomBytes } from 'node:crypto';
-import { CHAIN_STEPS, CHAIN_STEP_IDS, CHAIN_STEP_COUNT, findStep, } from './steps.js';
-/**
- * Generate a new chain id. Format: `chn_<8 lowercase hex>`. Short
- * enough to fit on one terminal column; collision probability is fine
- * for the operator-scale workload (chains per workspace per session).
- */
-export function generateChainId(rng = () => randomBytes(4)) {
-    return `chn_${rng().toString('hex')}`;
-}
-/**
- * Resolve the directory that holds a single chain. Encapsulates the
- * `.pugi/chains/<id>/` convention so every caller agrees.
- */
-export function chainDir(workspaceCwd, chainId) {
-    return resolve(workspaceCwd, '.pugi', 'chains', chainId);
-}
-/**
- * Path to the chain's state JSON. Atomic writes go through a sibling
- * `chain.json.tmp` + rename so a crashed CLI cannot leave a truncated
- * state file behind.
- */
-export function chainStatePath(workspaceCwd, chainId) {
-    return join(chainDir(workspaceCwd, chainId), 'chain.json');
-}
-/**
- * Initialise on-disk state for a fresh chain. Returns the persisted
- * snapshot. Throws when the chain id already exists on disk so the
- * caller is forced to handle the collision explicitly.
- */
-export function createChain(workspaceCwd, intent, options = {}) {
-    const now = options.now ?? (() => new Date());
-    const id = options.chainId ?? generateChainId();
-    const dir = chainDir(workspaceCwd, id);
-    if (existsSync(dir)) {
-        throw new Error(`chain ${id} already exists at ${dir}`);
-    }
-    mkdirSync(dir, { recursive: true });
-    const createdAt = now().toISOString();
-    const trimmedIntent = intent.trim();
-    if (trimmedIntent.length === 0) {
-        throw new Error('chain intent must be non-empty');
-    }
-    const steps = CHAIN_STEPS.map((descriptor) => ({
-        id: descriptor.id,
-        status: 'pending',
-        updatedAt: createdAt,
-        dispatchId: null,
-        errorMessage: null,
-    }));
-    const state = {
-        schemaVersion: 1,
-        id,
-        intent: trimmedIntent,
-        createdAt,
-        updatedAt: createdAt,
-        nextStep: CHAIN_STEP_IDS[0] ?? null,
-        steps,
-    };
-    writeStateAtomic(workspaceCwd, state);
-    return Object.freeze(state);
-}
-/**
- * Read the persisted state for a chain. Returns `null` when the chain
- * does not exist on disk — callers render a friendly "no such chain"
- * message instead of throwing.
- */
-export function readChain(workspaceCwd, chainId) {
-    const path = chainStatePath(workspaceCwd, chainId);
-    if (!existsSync(path))
-        return null;
-    const raw = readFileSync(path, 'utf8');
-    const parsed = JSON.parse(raw);
-    if (parsed.schemaVersion !== 1 || typeof parsed.id !== 'string') {
-        throw new Error(`chain ${chainId} state is malformed (schemaVersion mismatch)`);
-    }
-    // Migrate any missing optional fields to defaults so a partially-
-    // hand-edited state file still loads.
-    const steps = Array.isArray(parsed.steps) ? parsed.steps : [];
-    if (steps.length !== CHAIN_STEP_COUNT) {
-        throw new Error(`chain ${chainId} state has ${steps.length} steps; expected ${CHAIN_STEP_COUNT}`);
-    }
-    return Object.freeze({
-        schemaVersion: 1,
-        id: parsed.id,
-        intent: parsed.intent ?? '',
-        createdAt: parsed.createdAt ?? new Date(0).toISOString(),
-        updatedAt: parsed.updatedAt ?? new Date(0).toISOString(),
-        nextStep: parsed.nextStep ?? null,
-        steps: steps.map((s) => ({
-            id: s.id,
-            status: (s.status ?? 'pending'),
-            updatedAt: s.updatedAt ?? parsed.updatedAt ?? new Date(0).toISOString(),
-            dispatchId: s.dispatchId ?? null,
-            errorMessage: s.errorMessage ?? null,
-        })),
-    });
-}
-/**
- * List every chain id present under `.pugi/chains/`. Returns an empty
- * array when the directory does not exist — operators rarely call this
- * before `pugi chain new`.
- */
-export function listChainIds(workspaceCwd) {
-    const root = join(workspaceCwd, '.pugi', 'chains');
-    if (!existsSync(root))
-        return [];
-    return readdirSync(root, { withFileTypes: true })
-        .filter((entry) => entry.isDirectory() && entry.name.startsWith('chn_'))
-        .map((entry) => entry.name)
-        .sort();
-}
-/**
- * Mark a step as dispatched. Idempotent re-dispatch is allowed (the
- * operator may re-run a step after a transient failure); the previous
- * dispatchId is overwritten.
- */
-export function markDispatched(workspaceCwd, chainId, stepId, dispatchId, options = {}) {
-    return transition(workspaceCwd, chainId, options.now ?? (() => new Date()), (state) => {
-        const step = state.steps.find((s) => s.id === stepId);
-        if (!step) {
-            throw new Error(`chain ${chainId}: unknown step ${stepId}`);
-        }
-        if (step.status === 'complete') {
-            throw new Error(`chain ${chainId}: step ${stepId} already complete`);
-        }
-        step.status = 'dispatched';
-        step.dispatchId = dispatchId;
-        step.errorMessage = null;
-    });
-}
-/**
- * Mark a step as complete. Operator approves between steps so this is
- * the final gate — when the operator runs `pugi chain next` AFTER the
- * artifact lands, the dispatcher first flips the current step to
- * complete then advances the cursor.
- */
-export function markComplete(workspaceCwd, chainId, stepId, options = {}) {
-    return transition(workspaceCwd, chainId, options.now ?? (() => new Date()), (state) => {
-        const step = state.steps.find((s) => s.id === stepId);
-        if (!step) {
-            throw new Error(`chain ${chainId}: unknown step ${stepId}`);
-        }
-        step.status = 'complete';
-        step.errorMessage = null;
-        state.nextStep = firstPendingStep(state.steps);
-    });
-}
-/**
- * Capture an error against the current step without flipping it to
- * complete. The step stays in `dispatched` so the operator can re-run.
- */
-export function markError(workspaceCwd, chainId, stepId, errorMessage, options = {}) {
-    return transition(workspaceCwd, chainId, options.now ?? (() => new Date()), (state) => {
-        const step = state.steps.find((s) => s.id === stepId);
-        if (!step) {
-            throw new Error(`chain ${chainId}: unknown step ${stepId}`);
-        }
-        step.errorMessage = errorMessage;
-    });
-}
-/**
- * Compute the next pending step. Returns `null` when every step is
- * complete (chain finalised).
- */
-export function firstPendingStep(steps) {
-    for (const id of CHAIN_STEP_IDS) {
-        const record = steps.find((s) => s.id === id);
-        if (!record || record.status !== 'complete')
-            return id;
-    }
-    return null;
-}
-/**
- * Resolve the descriptor for the current cursor. Returns `null` when
- * the chain is finalised. Convenience wrapper so renderers do not need
- * to handle the lookup themselves.
- */
-export function currentStepDescriptor(state) {
-    if (!state.nextStep)
-        return null;
-    return findStep(state.nextStep) ?? null;
-}
-/* ------------------------------------------------------------------ */
-/* Internal: transactional mutate helper                             */
-/* ------------------------------------------------------------------ */
-function transition(workspaceCwd, chainId, now, mutate) {
-    const current = readChain(workspaceCwd, chainId);
-    if (!current) {
-        throw new Error(`chain ${chainId} not found at ${chainStatePath(workspaceCwd, chainId)}`);
-    }
-    // Deep clone so the frozen snapshot is never mutated.
-    const draft = JSON.parse(JSON.stringify(current));
-    mutate(draft);
-    draft.updatedAt = now().toISOString();
-    // Update step-level timestamp for whichever step the mutation
-    // touched. We diff status / dispatchId / errorMessage against the
-    // previous snapshot — any change bumps the step's updatedAt.
-    for (const draftStep of draft.steps) {
-        const previousStep = current.steps.find((s) => s.id === draftStep.id);
-        if (!previousStep)
-            continue;
-        if (draftStep.status !== previousStep.status ||
-            draftStep.dispatchId !== previousStep.dispatchId ||
-            draftStep.errorMessage !== previousStep.errorMessage) {
-            draftStep.updatedAt = draft.updatedAt;
-        }
-    }
-    writeStateAtomic(workspaceCwd, draft);
-    return Object.freeze(draft);
-}
-function writeStateAtomic(workspaceCwd, state) {
-    const dir = chainDir(workspaceCwd, state.id);
-    mkdirSync(dir, { recursive: true });
-    const finalPath = chainStatePath(workspaceCwd, state.id);
-    const tmpPath = `${finalPath}.tmp`;
-    writeFileSync(tmpPath, `${JSON.stringify(state, null, 2)}\n`, 'utf8');
-    renameSync(tmpPath, finalPath);
-}
-//# sourceMappingURL=state.js.map

package/dist/core/artifact-chain/steps.js

@@ -1,169 +0,0 @@
-/**
- * Artifact chain step definitions — Pugi  .
- *
- * The chain encodes Pugi's moat: an operator drops one high-level intent
- * (`pugi chain new "<intent>"`) and the CLI walks a deterministic 7-step
- * pipeline that produces verifiable artifacts at each stage. Every step
- * dispatches to a specialist persona via the existing `pugi delegate`
- * surface so the same Tier 1 roster powers both ad-hoc dispatch and the
- * artifact chain.
- *
- * The pipeline:
- *
- *  1. prd      — Olivia (PM):      structured PRD (goals / users /
- *                                    acceptance criteria / scope)
- *  2. adr      — Marcus (CTO):     architectural decision record
- *                                    against the team ADR template
- *  3. mindmap  — Marcus (CTO):     mermaid mindmap of the solution
- *                                    surface (modules + boundaries)
- *  4. er       — Hiroshi (Lead Dev):entity-relationship mermaid for
- *                                    the data model the design implies
- *  5. sequence — Hiroshi (Lead Dev):mermaid sequence diagram covering
- *                                    the critical happy + sad paths
- *  6. tests    — Vera (QA):        spec scaffolding mapped from the
- *                                    PRD acceptance criteria
- *  7. code     — Hiroshi (Lead Dev):implementation diff against the
- *                                    scaffolded specs
- *
- * Persona slugs are lowercase ASCII to satisfy the server-side delegate
- * grammar (`^[a-z]+$`, mirrors `PUGI_DELEGATE_REGEX` in
- * `apps/admin-api/src/pugi/sessions.controller.ts`). The chain never
- * invents new personas — it only orchestrates the existing roster.
- *
- * Module contract:
- *
- *  - This file is PURE data. No fs, no network, no side effects.
- *    Importing it from a hot path (REPL keystroke handler) is safe.
- *  - The step ORDER is authoritative; downstream consumers MUST iterate
- *    `CHAIN_STEPS` instead of hand-rolling their own arrays so future
- *    re-ordering lands in exactly one place.
- *  - Personas are looked up by slug at dispatch time so a roster change
- *    does not silently break the chain — the dispatcher surfaces an
- *    `unknown_persona` outcome the operator can see.
- */
-/**
- * Ordered, frozen table of the seven steps. The chain state machine
- * advances through this array exactly once; re-ordering OR insertion
- * is a breaking change for any chain currently on disk.
- */
-export const CHAIN_STEPS = Object.freeze([
-    {
-        id: 'prd',
-        ordinal: 1,
-        persona: 'olivia',
-        personaLabel: 'Olivia (PM)',
-        artifactFilename: 'PRD.md',
-        briefTemplate: 'Produce a structured PRD for chain {{chainId}}. ' +
-            'Operator intent: "{{intent}}". ' +
-            'Cover: goals, target users, success metrics, ' +
-            'numbered acceptance criteria (## Acceptance Criteria), scope + non-scope, ' +
-            'risks. Output markdown ready for prd-check ingestion.',
-        gloss: 'Structured PRD — goals, users, acceptance criteria, scope',
-    },
-    {
-        id: 'adr',
-        ordinal: 2,
-        persona: 'marcus',
-        personaLabel: 'Marcus (CTO)',
-        artifactFilename: 'ADR.md',
-        briefTemplate: 'Produce an architectural decision record for chain {{chainId}}. ' +
-            'Read the PRD at .pugi/chains/{{chainId}}/PRD.md verbatim. ' +
-            'Follow the team ADR template: Status, Context, Decision, ' +
-            'Consequences, Alternatives Considered. ' +
-            'Be explicit about boundary changes the decision implies.',
-        gloss: 'Architectural decision record per team ADR template',
-    },
-    {
-        id: 'mindmap',
-        ordinal: 3,
-        persona: 'marcus',
-        personaLabel: 'Marcus (CTO)',
-        artifactFilename: 'MINDMAP.mmd',
-        briefTemplate: 'Produce a mermaid mindmap of the solution surface for chain {{chainId}}. ' +
-            'Read PRD + ADR at .pugi/chains/{{chainId}}/PRD.md and ADR.md. ' +
-            'Root node = the feature name; first-level branches = subsystems; ' +
-            'leaves = concrete modules / endpoints / tables. ' +
-            'Output ONE mermaid `mindmap` fenced block — no prose.',
-        gloss: 'Mermaid mindmap — solution surface (subsystems + modules)',
-    },
-    {
-        id: 'er',
-        ordinal: 4,
-        persona: 'hiroshi',
-        personaLabel: 'Hiroshi (Lead Dev)',
-        artifactFilename: 'ER.mmd',
-        briefTemplate: 'Produce a mermaid entity-relationship diagram for chain {{chainId}}. ' +
-            'Source: PRD + ADR + MINDMAP under .pugi/chains/{{chainId}}/. ' +
-            'Use `erDiagram` syntax. Cover every persisted entity the ' +
-            'design implies; mark PK / FK relationships explicitly.',
-        gloss: 'Mermaid ER diagram — persisted entities + relationships',
-    },
-    {
-        id: 'sequence',
-        ordinal: 5,
-        persona: 'hiroshi',
-        personaLabel: 'Hiroshi (Lead Dev)',
-        artifactFilename: 'SEQUENCE.mmd',
-        briefTemplate: 'Produce mermaid sequence diagrams for chain {{chainId}}. ' +
-            'Cover the critical happy path + at least one sad path. ' +
-            'Source: PRD acceptance criteria + ER diagram. ' +
-            'Use `sequenceDiagram` syntax; one diagram per fenced block.',
-        gloss: 'Mermaid sequence diagrams — happy + sad path flows',
-    },
-    {
-        id: 'tests',
-        ordinal: 6,
-        persona: 'vera',
-        personaLabel: 'Vera (QA)',
-        artifactFilename: 'TESTS.md',
-        briefTemplate: 'Produce spec scaffolding for chain {{chainId}}. ' +
-            'Map every numbered PRD acceptance criterion (under ## Acceptance Criteria) ' +
-            'to one or more concrete test descriptions using node:test + node:assert. ' +
-            'Format: criterion-id → test file path → `it(...)` blocks. ' +
-            'Output markdown only — no executable code.',
-        gloss: 'Spec scaffolding — PRD criteria mapped to test descriptions',
-    },
-    {
-        id: 'code',
-        ordinal: 7,
-        persona: 'hiroshi',
-        personaLabel: 'Hiroshi (Lead Dev)',
-        artifactFilename: 'CODE.md',
-        briefTemplate: 'Produce an implementation plan + diff references for chain {{chainId}}. ' +
-            'Read PRD, ADR, MINDMAP, ER, SEQUENCE, TESTS under .pugi/chains/{{chainId}}/. ' +
-            'Output: file-by-file changes (path, change kind, summary), ' +
-            'with each change tied back to a PRD criterion id. ' +
-            'NO inline patches — patches land via `pugi patch apply` after operator review.',
-        gloss: 'Implementation plan — file changes mapped to PRD criteria',
-    },
-]);
-/**
- * Resolve a step descriptor by id. Returns `undefined` for unknown ids
- * so callers can surface a structured error instead of panicking.
- */
-export function findStep(id) {
-    return CHAIN_STEPS.find((step) => step.id === id);
-}
-/**
- * Index of step ids in chain order. Exported so the state machine can
- * answer "what is the next step after X?" without re-scanning the
- * table on every transition.
- */
-export const CHAIN_STEP_IDS = Object.freeze(CHAIN_STEPS.map((s) => s.id));
-/**
- * Total number of steps in the chain. Hard-coded constant exported so
- * downstream renderers can size their progress bars without iterating.
- */
-export const CHAIN_STEP_COUNT = CHAIN_STEPS.length;
-/**
- * Interpolate the brief template with chain context. The template
- * grammar is intentionally minimal — only `{{chainId}}` and `{{intent}}`
- * are honoured. Unknown placeholders are left verbatim so a template
- * typo surfaces in the dispatched brief instead of silently dropping.
- */
-export function renderBrief(template, ctx) {
-    return template
-        .replace(/\{\{chainId\}\}/g, ctx.chainId)
-        .replace(/\{\{intent\}\}/g, ctx.intent);
-}
-//# sourceMappingURL=steps.js.map

package/dist/core/ask-user/question.js

@@ -1,92 +0,0 @@
-const MIN_QUESTIONS = 1;
-const MAX_QUESTIONS = 4;
-const MIN_OPTIONS = 2;
-const MAX_OPTIONS = 4;
-const MAX_HEADER_LENGTH = 12;
-export function validateBatch(batch) {
-    const errors = [];
-    if (!Array.isArray(batch.questions)) {
-        errors.push({
-            field: 'questions',
-            message: 'questions must be an array',
-        });
-        return errors;
-    }
-    if (batch.questions.length < MIN_QUESTIONS || batch.questions.length > MAX_QUESTIONS) {
-        errors.push({
-            field: 'questions',
-            message: 'questions must contain 1 to 4 items',
-        });
-    }
-    for (const [questionIndex, question] of batch.questions.entries()) {
-        const questionPath = `questions[${questionIndex}]`;
-        if (typeof question.question !== 'string' || !question.question.endsWith('?')) {
-            errors.push({
-                field: `${questionPath}.question`,
-                message: 'question must end with ?',
-            });
-        }
-        if (typeof question.header !== 'string' || question.header.length < 1 || question.header.length > MAX_HEADER_LENGTH) {
-            errors.push({
-                field: `${questionPath}.header`,
-                message: 'header must be 1 to 12 characters',
-            });
-        }
-        if (typeof question.multiSelect !== 'boolean') {
-            errors.push({
-                field: `${questionPath}.multiSelect`,
-                message: 'multiSelect must be a boolean',
-            });
-        }
-        if (!Array.isArray(question.options)) {
-            errors.push({
-                field: `${questionPath}.options`,
-                message: 'options must be an array',
-            });
-            continue;
-        }
-        if (question.options.length < MIN_OPTIONS || question.options.length > MAX_OPTIONS) {
-            errors.push({
-                field: `${questionPath}.options`,
-                message: 'options must contain 2 to 4 items',
-            });
-        }
-        for (const [optionIndex, option] of question.options.entries()) {
-            const optionPath = `${questionPath}.options[${optionIndex}]`;
-            if (typeof option.label !== 'string' || option.label.length < 1) {
-                errors.push({
-                    field: `${optionPath}.label`,
-                    message: 'label must be a non-empty string',
-                });
-            }
-            if (typeof option.description !== 'string' || option.description.length < 1) {
-                errors.push({
-                    field: `${optionPath}.description`,
-                    message: 'description must be a non-empty string',
-                });
-            }
-            if (option.preview !== undefined && (typeof option.preview !== 'string' || option.preview.length < 1)) {
-                errors.push({
-                    field: `${optionPath}.preview`,
-                    message: 'preview must be a non-empty string when set',
-                });
-            }
-            if (option.recommended !== undefined && typeof option.recommended !== 'boolean') {
-                errors.push({
-                    field: `${optionPath}.recommended`,
-                    message: 'recommended must be a boolean when set',
-                });
-            }
-        }
-    }
-    return errors;
-}
-export function formatHeader(header) {
-    if (header.length <= MAX_HEADER_LENGTH)
-        return header;
-    return `${header.slice(0, MAX_HEADER_LENGTH - 3)}...`;
-}
-export function findRecommended(options) {
-    return options.find(option => option.recommended === true) ?? null;
-}
-//# sourceMappingURL=question.js.map