@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.17

package/dist/src/quality/feedback-tracker.js

@@ -0,0 +1,123 @@
+/**
+ * Feedback Tracker — record before/after quality scores and accuracy
+ *
+ * Tracks quality score deltas from feedback iterations, calculates
+ * accuracy (% positive deltas), and false positive rate.
+ * Persists to `.aiwg/metrics/feedback/`.
+ *
+ * @module quality/feedback-tracker
+ * @issue #148
+ */
+import { promises as fs } from 'fs';
+import path from 'path';
+// ============================================================================
+// Constants
+// ============================================================================
+const FEEDBACK_DIR = '.aiwg/metrics/feedback';
+const RECORDS_FILE = 'records.json';
+// ============================================================================
+// FeedbackTracker
+// ============================================================================
+export class FeedbackTracker {
+    feedbackDir;
+    records;
+    nextId;
+    constructor(projectPath) {
+        this.feedbackDir = path.join(projectPath, FEEDBACK_DIR);
+        this.records = [];
+        this.nextId = 1;
+    }
+    async recordFeedback(artifactPath, agent, scoreBefore, scoreAfter, category) {
+        const delta = scoreAfter - scoreBefore;
+        const record = {
+            id: `fb-${String(this.nextId++).padStart(4, '0')}`,
+            artifactPath,
+            agent,
+            scoreBefore,
+            scoreAfter,
+            delta,
+            improved: delta > 0,
+            timestamp: new Date().toISOString(),
+            category,
+        };
+        this.records.push(record);
+        await this.persist();
+        return record;
+    }
+    calculateAccuracy(options) {
+        let filtered = [...this.records];
+        if (options?.agent) {
+            const agentLower = options.agent.toLowerCase();
+            filtered = filtered.filter((r) => r.agent.toLowerCase() === agentLower);
+        }
+        if (options?.category) {
+            filtered = filtered.filter((r) => r.category === options.category);
+        }
+        if (filtered.length === 0) {
+            return {
+                totalRecords: 0,
+                positiveDeltas: 0,
+                negativeDeltas: 0,
+                zeroDeltas: 0,
+                accuracy: 0,
+                falsePositiveRate: 0,
+                averageDelta: 0,
+                medianDelta: 0,
+            };
+        }
+        const positiveDeltas = filtered.filter((r) => r.delta > 0).length;
+        const negativeDeltas = filtered.filter((r) => r.delta < 0).length;
+        const zeroDeltas = filtered.filter((r) => r.delta === 0).length;
+        const deltas = filtered.map((r) => r.delta);
+        const averageDelta = deltas.reduce((sum, d) => sum + d, 0) / deltas.length;
+        const sortedDeltas = [...deltas].sort((a, b) => a - b);
+        const medianDelta = sortedDeltas.length % 2 === 0
+            ? (sortedDeltas[sortedDeltas.length / 2 - 1] + sortedDeltas[sortedDeltas.length / 2]) / 2
+            : sortedDeltas[Math.floor(sortedDeltas.length / 2)];
+        return {
+            totalRecords: filtered.length,
+            positiveDeltas,
+            negativeDeltas,
+            zeroDeltas,
+            accuracy: Math.round((positiveDeltas / filtered.length) * 10000) / 100,
+            falsePositiveRate: Math.round((negativeDeltas / filtered.length) * 10000) / 100,
+            averageDelta: Math.round(averageDelta * 100) / 100,
+            medianDelta: Math.round(medianDelta * 100) / 100,
+        };
+    }
+    getAgentAccuracy() {
+        const agents = new Set(this.records.map((r) => r.agent));
+        const result = new Map();
+        for (const agent of agents) {
+            result.set(agent, this.calculateAccuracy({ agent }));
+        }
+        return result;
+    }
+    async load() {
+        try {
+            const filePath = path.join(this.feedbackDir, RECORDS_FILE);
+            const content = await fs.readFile(filePath, 'utf-8');
+            const data = JSON.parse(content);
+            this.records = data.records || [];
+            this.nextId = data.nextId || this.records.length + 1;
+        }
+        catch {
+            this.records = [];
+            this.nextId = 1;
+        }
+    }
+    async persist() {
+        try {
+            await fs.mkdir(this.feedbackDir, { recursive: true });
+            const filePath = path.join(this.feedbackDir, RECORDS_FILE);
+            await fs.writeFile(filePath, JSON.stringify({ records: this.records, nextId: this.nextId }, null, 2), 'utf-8');
+        }
+        catch {
+            // Non-critical
+        }
+    }
+    getAllRecords() {
+        return [...this.records];
+    }
+}
+//# sourceMappingURL=feedback-tracker.js.map

package/dist/src/quality/patterns/adr.json

@@ -0,0 +1,24 @@
+{
+  "id": "adr",
+  "name": "Architecture Decision Record",
+  "description": "Quality patterns for ADR artifacts",
+  "required": [
+    { "id": "adr-title", "pattern": "^#\\s+ADR-\\d+", "description": "ADR ID and title heading" },
+    { "id": "adr-status", "pattern": "(?i)status\\s*:", "description": "Decision status" },
+    { "id": "adr-context", "pattern": "(?i)context\\s*:", "description": "Context/problem statement" },
+    { "id": "adr-decision", "pattern": "(?i)decision\\s*:", "description": "Decision statement" },
+    { "id": "adr-consequences", "pattern": "(?i)consequences?\\s*:", "description": "Consequences of the decision" }
+  ],
+  "recommended": [
+    { "id": "adr-alternatives", "pattern": "(?i)(alternatives?|options?)\\s*(considered)?\\s*:", "description": "Alternatives considered" },
+    { "id": "adr-rationale", "pattern": "(?i)rationale\\s*:", "description": "Decision rationale" },
+    { "id": "adr-date", "pattern": "(?i)date\\s*:", "description": "Decision date" },
+    { "id": "adr-refs", "pattern": "@[\\w./\\-]+", "description": "@-mention traceability links" },
+    { "id": "adr-supersedes", "pattern": "(?i)supersed(es|ed by)", "description": "Supersession chain" }
+  ],
+  "antipatterns": [
+    { "id": "adr-no-context", "pattern": "(?i)\\bwe decided\\b(?!.*\\bbecause\\b)", "weight": 0.1, "description": "Decision without justification" },
+    { "id": "adr-todo", "pattern": "(?i)\\bTODO\\b|\\bTBD\\b|\\bFIXME\\b", "weight": 0.05, "description": "Unresolved TODOs" },
+    { "id": "adr-vague", "pattern": "(?i)\\bsomehow\\b|\\bprobably\\b|\\bmaybe\\b", "weight": 0.05, "description": "Vague language in decisions" }
+  ]
+}

package/dist/src/quality/patterns/sad.json

@@ -0,0 +1,24 @@
+{
+  "id": "sad",
+  "name": "Software Architecture Document",
+  "description": "Quality patterns for SAD artifacts",
+  "required": [
+    { "id": "sad-overview", "pattern": "(?i)(overview|introduction|purpose)\\s*:", "description": "Architecture overview" },
+    { "id": "sad-constraints", "pattern": "(?i)constraints?\\s*:", "description": "Architecture constraints" },
+    { "id": "sad-components", "pattern": "(?i)(component|module|service)s?\\s*(diagram|overview|architecture)", "description": "Component/module descriptions" },
+    { "id": "sad-decisions", "pattern": "(?i)(decision|ADR|rationale)s?", "description": "Key architectural decisions" },
+    { "id": "sad-quality", "pattern": "(?i)(quality|non-?functional|NFR)\\s*(attribute|requirement)s?", "description": "Quality attributes/NFRs" }
+  ],
+  "recommended": [
+    { "id": "sad-views", "pattern": "(?i)(logical|physical|deployment|process)\\s*view", "description": "Multiple architecture views (4+1)" },
+    { "id": "sad-interfaces", "pattern": "(?i)(interface|API|contract)s?\\s*(definition|spec)?", "description": "Interface definitions" },
+    { "id": "sad-security", "pattern": "(?i)security\\s*(architecture|model|considerations?)", "description": "Security architecture" },
+    { "id": "sad-deployment", "pattern": "(?i)deployment\\s*(model|topology|diagram)", "description": "Deployment model" },
+    { "id": "sad-trace", "pattern": "@[\\w./\\-]+", "description": "@-mention traceability links" }
+  ],
+  "antipatterns": [
+    { "id": "sad-no-rationale", "pattern": "(?i)\\bwe use\\b(?!.*\\bbecause\\b)", "weight": 0.1, "description": "Technology choice without rationale" },
+    { "id": "sad-todo", "pattern": "(?i)\\bTODO\\b|\\bTBD\\b|\\bFIXME\\b", "weight": 0.05, "description": "Unresolved TODOs" },
+    { "id": "sad-monolith", "pattern": "(?i)\\bsingle\\s*point\\s*of\\s*failure\\b", "weight": 0.1, "description": "Acknowledged SPOF without mitigation" }
+  ]
+}

package/dist/src/quality/patterns/test-plan.json

@@ -0,0 +1,24 @@
+{
+  "id": "test-plan",
+  "name": "Test Plan",
+  "description": "Quality patterns for test plan artifacts",
+  "required": [
+    { "id": "tp-scope", "pattern": "(?i)(scope|objective)s?\\s*:", "description": "Test scope/objectives" },
+    { "id": "tp-strategy", "pattern": "(?i)(strategy|approach)\\s*:", "description": "Test strategy/approach" },
+    { "id": "tp-cases", "pattern": "(?i)test\\s*(case|scenario)s?", "description": "Test cases or scenarios" },
+    { "id": "tp-criteria", "pattern": "(?i)(pass|exit|completion)\\s*criteria", "description": "Pass/exit criteria" },
+    { "id": "tp-env", "pattern": "(?i)(environment|infrastructure|setup)\\s*:", "description": "Test environment description" }
+  ],
+  "recommended": [
+    { "id": "tp-coverage", "pattern": "(?i)coverage\\s*(target|goal|matrix)?\\s*:", "description": "Coverage targets" },
+    { "id": "tp-risk", "pattern": "(?i)(risk|priority)\\s*(based)?\\s*(testing)?", "description": "Risk-based testing approach" },
+    { "id": "tp-schedule", "pattern": "(?i)(schedule|timeline|milestone)s?\\s*:", "description": "Test schedule" },
+    { "id": "tp-data", "pattern": "(?i)test\\s*data\\s*:", "description": "Test data requirements" },
+    { "id": "tp-trace", "pattern": "@[\\w./\\-]+", "description": "@-mention traceability links" }
+  ],
+  "antipatterns": [
+    { "id": "tp-no-negative", "pattern": "(?i)\\b(only|just)\\s*(happy|positive)\\s*path", "weight": 0.1, "description": "Only happy path testing" },
+    { "id": "tp-todo", "pattern": "(?i)\\bTODO\\b|\\bTBD\\b|\\bFIXME\\b", "weight": 0.05, "description": "Unresolved TODOs" },
+    { "id": "tp-manual-only", "pattern": "(?i)\\bmanual\\s*only\\b|\\bno\\s*automation\\b", "weight": 0.05, "description": "No automation consideration" }
+  ]
+}

package/dist/src/quality/patterns/use-case.json

@@ -0,0 +1,24 @@
+{
+  "id": "use-case",
+  "name": "Use Case",
+  "description": "Quality patterns for SDLC use case artifacts",
+  "required": [
+    { "id": "uc-title", "pattern": "^#\\s+UC-\\d+", "description": "Use case ID and title heading" },
+    { "id": "uc-actors", "pattern": "(?i)(actor|stakeholder)s?\\s*:", "description": "Actors/stakeholders section" },
+    { "id": "uc-preconditions", "pattern": "(?i)pre-?conditions?\\s*:", "description": "Preconditions section" },
+    { "id": "uc-flow", "pattern": "(?i)(main|basic|normal)\\s*(flow|scenario|path)", "description": "Main flow/scenario" },
+    { "id": "uc-postconditions", "pattern": "(?i)post-?conditions?\\s*:", "description": "Postconditions section" }
+  ],
+  "recommended": [
+    { "id": "uc-alt-flows", "pattern": "(?i)(alternative|alternate|exception)\\s*(flow|scenario|path)", "description": "Alternative flows" },
+    { "id": "uc-priority", "pattern": "(?i)priority\\s*:", "description": "Priority assignment" },
+    { "id": "uc-nfr-refs", "pattern": "(?i)(NFR|non-functional)", "description": "NFR cross-references" },
+    { "id": "uc-acceptance", "pattern": "(?i)acceptance\\s*criteria", "description": "Acceptance criteria" },
+    { "id": "uc-trace", "pattern": "@[\\w./\\-]+", "description": "@-mention traceability links" }
+  ],
+  "antipatterns": [
+    { "id": "uc-no-impl", "pattern": "(?i)(implementation|code|function|class|method)\\s+details?", "weight": 0.1, "description": "Implementation details in use case" },
+    { "id": "uc-vague-actor", "pattern": "(?i)\\bsomeone\\b|\\bthe user\\b", "weight": 0.05, "description": "Vague actor references" },
+    { "id": "uc-todo", "pattern": "(?i)\\bTODO\\b|\\bTBD\\b|\\bFIXME\\b", "weight": 0.05, "description": "Unresolved TODOs" }
+  ]
+}

package/dist/src/quality/scoring.js

@@ -0,0 +1,157 @@
+/**
+ * Pattern-based Quality Scoring Engine
+ *
+ * Scores SDLC artifacts against pattern definitions (required/recommended/antipattern).
+ * Scoring: required (60%) + recommended (40%) - antipattern penalty.
+ * Thresholds: excellent (90+), good (75+), acceptable (60+), needs-work (<60).
+ *
+ * @module quality/scoring
+ * @issue #192
+ */
+import { promises as fs } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+// ============================================================================
+// Constants
+// ============================================================================
+export const REQUIRED_WEIGHT = 0.60;
+export const RECOMMENDED_WEIGHT = 0.40;
+export const THRESHOLDS = {
+    excellent: 90,
+    good: 75,
+    acceptable: 60,
+};
+// ============================================================================
+// Scoring Engine
+// ============================================================================
+export function scoreContent(content, patterns, artifactPath = '') {
+    const requiredMatches = patterns.required.map((rule) => matchPattern(content, rule));
+    const requiredFound = requiredMatches.filter((m) => m.found).length;
+    const requiredScore = patterns.required.length > 0
+        ? (requiredFound / patterns.required.length) * 100
+        : 100;
+    const recommendedMatches = patterns.recommended.map((rule) => matchPattern(content, rule));
+    const recommendedFound = recommendedMatches.filter((m) => m.found).length;
+    const recommendedScore = patterns.recommended.length > 0
+        ? (recommendedFound / patterns.recommended.length) * 100
+        : 100;
+    const antipatternMatches = patterns.antipatterns.map((rule) => matchPattern(content, rule));
+    const antipatternPenalty = antipatternMatches.reduce((penalty, match) => {
+        if (match.found) {
+            const weight = match.rule.weight || 0.05;
+            return penalty + weight * 100;
+        }
+        return penalty;
+    }, 0);
+    const rawScore = requiredScore * REQUIRED_WEIGHT +
+        recommendedScore * RECOMMENDED_WEIGHT -
+        antipatternPenalty;
+    const score = Math.max(0, Math.min(100, Math.round(rawScore * 100) / 100));
+    const grade = getGrade(score);
+    return {
+        score,
+        grade,
+        breakdown: {
+            required: Math.round(requiredScore * 100) / 100,
+            recommended: Math.round(recommendedScore * 100) / 100,
+            antipatternPenalty: Math.round(antipatternPenalty * 100) / 100,
+        },
+        matches: {
+            required: requiredMatches,
+            recommended: recommendedMatches,
+            antipatterns: antipatternMatches,
+        },
+        patternId: patterns.id,
+        artifactPath,
+    };
+}
+export function matchPattern(content, rule) {
+    try {
+        let pattern = rule.pattern;
+        let flags = 'gm';
+        // Handle PCRE inline flag (?i) — strip it and add 'i' to RegExp flags
+        if (pattern.startsWith('(?i)')) {
+            pattern = pattern.slice(4);
+            flags = 'gmi';
+        }
+        const regex = new RegExp(pattern, flags);
+        const matches = content.match(regex);
+        return {
+            rule,
+            found: matches !== null && matches.length > 0,
+            matchCount: matches ? matches.length : 0,
+        };
+    }
+    catch {
+        return {
+            rule,
+            found: false,
+            matchCount: 0,
+        };
+    }
+}
+export function getGrade(score) {
+    if (score >= THRESHOLDS.excellent)
+        return 'excellent';
+    if (score >= THRESHOLDS.good)
+        return 'good';
+    if (score >= THRESHOLDS.acceptable)
+        return 'acceptable';
+    return 'needs-work';
+}
+// ============================================================================
+// Pattern Loading
+// ============================================================================
+export async function loadBuiltinPattern(artifactType) {
+    try {
+        const currentDir = path.dirname(fileURLToPath(import.meta.url));
+        const patternPath = path.join(currentDir, 'patterns', `${artifactType}.json`);
+        const content = await fs.readFile(patternPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+export async function loadPatternFromFile(filePath) {
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+export function getAvailablePatternTypes() {
+    return ['use-case', 'adr', 'test-plan', 'sad'];
+}
+export function detectArtifactType(content, filePath) {
+    const lower = content.toLowerCase();
+    const basename = path.basename(filePath).toLowerCase();
+    if (basename.startsWith('uc-') || /^#\s+UC-\d+/m.test(content)) {
+        return 'use-case';
+    }
+    if (basename.startsWith('adr-') || /^#\s+ADR-\d+/m.test(content)) {
+        return 'adr';
+    }
+    if (lower.includes('test plan') || lower.includes('test strategy')) {
+        return 'test-plan';
+    }
+    if (lower.includes('software architecture') ||
+        lower.includes('system architecture') ||
+        basename.includes('sad')) {
+        return 'sad';
+    }
+    return null;
+}
+export async function scoreArtifact(filePath, patternType) {
+    const content = await fs.readFile(filePath, 'utf-8');
+    const type = patternType || detectArtifactType(content, filePath);
+    if (!type)
+        return null;
+    const patterns = await loadBuiltinPattern(type);
+    if (!patterns)
+        return null;
+    return scoreContent(content, patterns, filePath);
+}
+//# sourceMappingURL=scoring.js.map

package/dist/src/reflections/cli.js

@@ -0,0 +1,15 @@
+/**
+ * Reflections CLI — `aiwg reflections <subcommand>`
+ *
+ * Thin subsystem wrapper around `runSubsystemCli('reflections', ...)`.
+ * Used by the ralph-reflect / reflection-injection skills (#967) so
+ * agent-loop reflections honor `.aiwg/storage.config` redirection.
+ *
+ * @issue #934
+ * @issue #967
+ */
+import { runSubsystemCli } from '../storage/subsystem-cli.js';
+export async function main(args) {
+    await runSubsystemCli('reflections', args);
+}
+//# sourceMappingURL=cli.js.map

package/dist/src/release/plan.js

@@ -0,0 +1,139 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import { parse as parseYaml } from 'yaml';
+import { projectAiwgPath } from '../config/project-artifacts.js';
+export const RELEASE_PLAN_DIR = path.join('.aiwg', 'releases');
+export const RELEASE_PLAN_EXTENSIONS = new Set(['.json', '.yaml', '.yml']);
+export class ReleasePlanError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ReleasePlanError';
+    }
+}
+export async function discoverReleasePlans(projectRoot) {
+    const releaseDir = projectAiwgPath(projectRoot, 'releases');
+    let entries;
+    try {
+        entries = await fs.readdir(releaseDir, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+    const candidates = entries
+        .filter((entry) => entry.isFile() && RELEASE_PLAN_EXTENSIONS.has(path.extname(entry.name)))
+        .map((entry) => path.join(releaseDir, entry.name))
+        .sort();
+    const plans = [];
+    for (const candidate of candidates) {
+        const plan = parseReleasePlan(await fs.readFile(candidate, 'utf8'), candidate);
+        plans.push({ path: candidate, plan });
+    }
+    const byId = new Map();
+    for (const { path: planPath, plan } of plans) {
+        byId.set(plan.id, [...(byId.get(plan.id) ?? []), planPath]);
+    }
+    const duplicates = [...byId.entries()].filter(([, paths]) => paths.length > 1);
+    if (duplicates.length > 0) {
+        const details = duplicates
+            .map(([id, paths]) => `${id}: ${paths.map((p) => path.relative(projectRoot, p)).join(', ')}`)
+            .join('; ');
+        throw new ReleasePlanError(`Conflicting release plans: duplicate plan id(s) found (${details}). Give each sidecar a unique id.`);
+    }
+    return plans;
+}
+export async function selectReleasePlan(projectRoot, options = {}) {
+    const plans = await discoverReleasePlans(projectRoot);
+    if (plans.length === 0) {
+        throw new ReleasePlanError(`No release plans found. Create ${RELEASE_PLAN_DIR}/<plan-id>.yaml or pass a project without release-plan sidecars.`);
+    }
+    let selected;
+    if (options.planId) {
+        selected = plans.find(({ plan }) => plan.id === options.planId);
+        if (!selected) {
+            throw new ReleasePlanError(`Release plan '${options.planId}' was not found. Available plans: ${plans.map(({ plan }) => plan.id).join(', ')}.`);
+        }
+    }
+    else if (plans.length === 1) {
+        selected = plans[0];
+    }
+    else {
+        throw new ReleasePlanError(`Multiple release plans are available (${plans.map(({ plan }) => plan.id).join(', ')}). Select one explicitly with --plan <id>.`);
+    }
+    return {
+        activePlan: selected.plan,
+        activePlanPath: selected.path,
+        effectiveDeliveryMode: selected.plan.delivery.mode,
+        projectDeliveryMode: options.projectDeliveryMode,
+        report: renderReleasePlanActivation(selected.plan, selected.path, projectRoot, options.projectDeliveryMode),
+    };
+}
+export function parseReleasePlan(content, sourcePath = '<memory>') {
+    let parsed;
+    if (sourcePath.endsWith('.json')) {
+        parsed = JSON.parse(content);
+    }
+    else {
+        parsed = parseYaml(content);
+    }
+    return validateReleasePlan(parsed, sourcePath);
+}
+export function validateReleasePlan(value, sourcePath = '<memory>') {
+    if (!isRecord(value)) {
+        throw new ReleasePlanError(`${sourcePath}: release plan must be an object.`);
+    }
+    if (value.version !== 1) {
+        throw new ReleasePlanError(`${sourcePath}: release plan version must be 1.`);
+    }
+    if (typeof value.id !== 'string' || !/^[a-z0-9][a-z0-9._-]*$/.test(value.id)) {
+        throw new ReleasePlanError(`${sourcePath}: release plan id must be a stable lowercase id.`);
+    }
+    if (!isRecord(value.target) || typeof value.target.name !== 'string' || value.target.name.trim() === '') {
+        throw new ReleasePlanError(`${sourcePath}: release plan target.name is required.`);
+    }
+    if (!isRecord(value.delivery) || typeof value.delivery.mode !== 'string') {
+        throw new ReleasePlanError(`${sourcePath}: release plan delivery.mode is required.`);
+    }
+    const allowedModes = ['direct', 'pr', 'pr-required', 'tag-only', 'dispatch-only', 'manual', 'custom'];
+    if (!allowedModes.includes(value.delivery.mode)) {
+        throw new ReleasePlanError(`${sourcePath}: release plan delivery.mode must be one of ${allowedModes.join(', ')}.`);
+    }
+    validateCommandList(value.build && isRecord(value.build) ? value.build.commands : undefined, `${sourcePath}: build.commands`);
+    validateCommandList(value.validation_gates, `${sourcePath}: validation_gates`);
+    validateCommandList(value.post_release_verification, `${sourcePath}: post_release_verification`);
+    return value;
+}
+export function buildReleasePlanExecutionFlow(plan) {
+    return [
+        ...(plan.build?.commands ?? []),
+        ...(plan.validation_gates ?? []),
+        ...(plan.post_release_verification ?? []),
+    ];
+}
+export function renderReleasePlanActivation(plan, planPath, projectRoot, projectDeliveryMode) {
+    const relativePath = path.relative(projectRoot, planPath) || planPath;
+    const projectMode = projectDeliveryMode ? ` (project default: ${projectDeliveryMode})` : '';
+    return [
+        `Active release plan: ${plan.id}${plan.name ? ` (${plan.name})` : ''}`,
+        `Plan file: ${relativePath}`,
+        `Target: ${plan.target.name}`,
+        `Delivery mode: ${plan.delivery.mode}${projectMode}`,
+    ].join('\n');
+}
+function validateCommandList(value, where) {
+    if (value === undefined)
+        return;
+    if (!Array.isArray(value)) {
+        throw new ReleasePlanError(`${where} must be an array.`);
+    }
+    for (const [index, command] of value.entries()) {
+        if (!isRecord(command) || typeof command.run !== 'string' || command.run.trim() === '') {
+            throw new ReleasePlanError(`${where}[${index}].run is required.`);
+        }
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=plan.js.map