@devtrack-solution/codesdd 1.2.2

package/dist/commands/workflow/status.js

@@ -0,0 +1,76 @@
+/**
+ * Status Command
+ *
+ * Displays artifact completion status for a change.
+ */
+import ora from 'ora';
+import chalk from 'chalk';
+import { loadChangeContext, formatChangeStatus, } from '../../core/artifact-graph/index.js';
+import { validateChangeExists, validateSchemaExists, getAvailableChanges, getStatusIndicator, getStatusColor, } from './shared.js';
+import { CLI_NAME } from '../../core/branding.js';
+// -----------------------------------------------------------------------------
+// Command Implementation
+// -----------------------------------------------------------------------------
+export async function statusCommand(options) {
+    const spinner = ora('Loading change status...').start();
+    try {
+        const projectRoot = process.cwd();
+        // Handle no-changes case gracefully — status is informational,
+        // so "no changes" is a valid state, not an error.
+        if (!options.change) {
+            const available = await getAvailableChanges(projectRoot);
+            if (available.length === 0) {
+                spinner.stop();
+                if (options.json) {
+                    console.log(JSON.stringify({ changes: [], message: 'No active changes.' }, null, 2));
+                    return;
+                }
+                console.log(`No active changes. Create one with: ${CLI_NAME} new change <name>`);
+                return;
+            }
+            // Changes exist but --change not provided
+            spinner.stop();
+            throw new Error(`Missing required option --change. Available changes:\n  ${available.join('\n  ')}`);
+        }
+        const changeName = await validateChangeExists(options.change, projectRoot);
+        // Validate schema if explicitly provided
+        if (options.schema) {
+            validateSchemaExists(options.schema, projectRoot);
+        }
+        // loadChangeContext will auto-detect schema from metadata if not provided
+        const context = loadChangeContext(projectRoot, changeName, options.schema);
+        const status = formatChangeStatus(context);
+        spinner.stop();
+        if (options.json) {
+            console.log(JSON.stringify(status, null, 2));
+            return;
+        }
+        printStatusText(status);
+    }
+    catch (error) {
+        spinner.stop();
+        throw error;
+    }
+}
+export function printStatusText(status) {
+    const doneCount = status.artifacts.filter((a) => a.status === 'done').length;
+    const total = status.artifacts.length;
+    console.log(`Change: ${status.changeName}`);
+    console.log(`Schema: ${status.schemaName}`);
+    console.log(`Progress: ${doneCount}/${total} artifacts complete`);
+    console.log();
+    for (const artifact of status.artifacts) {
+        const indicator = getStatusIndicator(artifact.status);
+        const color = getStatusColor(artifact.status);
+        let line = `${indicator} ${artifact.id}`;
+        if (artifact.status === 'blocked' && artifact.missingDeps && artifact.missingDeps.length > 0) {
+            line += color(` (blocked by: ${artifact.missingDeps.join(', ')})`);
+        }
+        console.log(line);
+    }
+    if (status.isComplete) {
+        console.log();
+        console.log(chalk.green('All artifacts complete!'));
+    }
+}
+//# sourceMappingURL=status.js.map

package/dist/commands/workflow/templates.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Templates Command
+ *
+ * Shows resolved template paths for all artifacts in a schema.
+ */
+export interface TemplatesOptions {
+    schema?: string;
+    json?: boolean;
+}
+export interface TemplateInfo {
+    artifactId: string;
+    templatePath: string;
+    source: 'project' | 'user' | 'package';
+}
+export declare function templatesCommand(options: TemplatesOptions): Promise<void>;
+//# sourceMappingURL=templates.d.ts.map

package/dist/commands/workflow/templates.js

@@ -0,0 +1,68 @@
+/**
+ * Templates Command
+ *
+ * Shows resolved template paths for all artifacts in a schema.
+ */
+import ora from 'ora';
+import path from 'path';
+import { resolveSchema, getSchemaDir, ArtifactGraph, } from '../../core/artifact-graph/index.js';
+import { validateSchemaExists, DEFAULT_SCHEMA } from './shared.js';
+// -----------------------------------------------------------------------------
+// Command Implementation
+// -----------------------------------------------------------------------------
+export async function templatesCommand(options) {
+    const spinner = ora('Loading templates...').start();
+    try {
+        const projectRoot = process.cwd();
+        const schemaName = validateSchemaExists(options.schema ?? DEFAULT_SCHEMA, projectRoot);
+        const schema = resolveSchema(schemaName, projectRoot);
+        const graph = ArtifactGraph.fromSchema(schema);
+        const schemaDir = getSchemaDir(schemaName, projectRoot);
+        // Determine the source (project, user, or package)
+        const { getUserSchemasDir, getProjectSchemasDir, } = await import('../../core/artifact-graph/resolver.js');
+        const projectSchemasDir = getProjectSchemasDir(projectRoot);
+        const userSchemasDir = getUserSchemasDir();
+        // Determine source by checking if schemaDir is inside each base directory
+        // Using path.relative is more robust than startsWith for path comparisons
+        const isInsideDir = (child, parent) => {
+            const relative = path.relative(parent, child);
+            return !relative.startsWith('..') && !path.isAbsolute(relative);
+        };
+        let source;
+        if (isInsideDir(schemaDir, projectSchemasDir)) {
+            source = 'project';
+        }
+        else if (isInsideDir(schemaDir, userSchemasDir)) {
+            source = 'user';
+        }
+        else {
+            source = 'package';
+        }
+        const templates = graph.getAllArtifacts().map((artifact) => ({
+            artifactId: artifact.id,
+            templatePath: path.join(schemaDir, 'templates', artifact.template),
+            source,
+        }));
+        spinner.stop();
+        if (options.json) {
+            const output = {};
+            for (const t of templates) {
+                output[t.artifactId] = { path: t.templatePath, source: t.source };
+            }
+            console.log(JSON.stringify(output, null, 2));
+            return;
+        }
+        console.log(`Schema: ${schemaName}`);
+        console.log(`Source: ${source}`);
+        console.log();
+        for (const t of templates) {
+            console.log(`${t.artifactId}:`);
+            console.log(`  ${t.templatePath}`);
+        }
+    }
+    catch (error) {
+        spinner.stop();
+        throw error;
+    }
+}
+//# sourceMappingURL=templates.js.map

package/dist/core/archive.d.ts

@@ -0,0 +1,16 @@
+export declare class ArchiveCommand {
+    execute(changeName?: string, options?: {
+        yes?: boolean;
+        skipSpecs?: boolean;
+        noValidate?: boolean;
+        validate?: boolean;
+    }): Promise<void>;
+    private selectChange;
+    private getArchiveDate;
+    private validateFingerprintsAgainstLiveSpec;
+    private buildFingerprintLookup;
+    private collectTouchedRequirements;
+    private mapRequirementBlocks;
+    private inferLastEditorForRequirement;
+}
+//# sourceMappingURL=archive.d.ts.map

package/dist/core/archive.js

@@ -0,0 +1,487 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { getTaskProgressForChange, formatTaskStatus } from '../utils/task-progress.js';
+import { Validator } from './validation/validator.js';
+import chalk from 'chalk';
+import { findSpecUpdates, buildUpdatedSpec, writeUpdatedSpec, } from './specs-apply.js';
+import { computeRequirementHash, readMeta, captureFingerprintsForChange, writeMeta, } from './sdd/fingerprint.js';
+import { extractRequirementsSection, normalizeRequirementName, parseDeltaSpec, } from './parsers/requirement-blocks.js';
+import { CLI_NAME } from './branding.js';
+import { trackFingerprintMismatch } from '../telemetry/index.js';
+import { resolveOpenSpecLiveSubpath } from './sdd/services/legacy-capability.service.js';
+const execFileAsync = promisify(execFile);
+function buildRequirementKey(capability, name) {
+    return `${capability}::${normalizeRequirementName(name)}`;
+}
+/**
+ * Recursively copy a directory. Used when fs.rename fails (e.g. EPERM on Windows).
+ */
+async function copyDirRecursive(src, dest) {
+    await fs.mkdir(dest, { recursive: true });
+    const entries = await fs.readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            await copyDirRecursive(srcPath, destPath);
+        }
+        else {
+            await fs.copyFile(srcPath, destPath);
+        }
+    }
+}
+/**
+ * Move a directory from src to dest. On Windows, fs.rename() often fails with
+ * EPERM when the directory is non-empty or another process has it open (IDE,
+ * file watcher, antivirus). Fall back to copy-then-remove when rename fails
+ * with EPERM or EXDEV.
+ */
+async function moveDirectory(src, dest) {
+    try {
+        await fs.rename(src, dest);
+    }
+    catch (err) {
+        const code = err?.code;
+        if (code === 'EPERM' || code === 'EXDEV') {
+            await copyDirRecursive(src, dest);
+            await fs.rm(src, { recursive: true, force: true });
+        }
+        else {
+            throw err;
+        }
+    }
+}
+export class ArchiveCommand {
+    async execute(changeName, options = {}) {
+        const targetPath = '.';
+        const changesDir = resolveOpenSpecLiveSubpath(targetPath, 'changes');
+        const archiveDir = path.join(changesDir, 'archive');
+        const mainSpecsDir = resolveOpenSpecLiveSubpath(targetPath, 'specs');
+        // Check if changes directory exists
+        try {
+            await fs.access(changesDir);
+        }
+        catch {
+            throw new Error(`No OpenSpec changes directory found. Run '${CLI_NAME} init' first.`);
+        }
+        // Get change name interactively if not provided
+        if (!changeName) {
+            const selectedChange = await this.selectChange(changesDir);
+            if (!selectedChange) {
+                console.log('No change selected. Aborting.');
+                return;
+            }
+            changeName = selectedChange;
+        }
+        const changeDir = path.join(changesDir, changeName);
+        // Verify change exists
+        try {
+            const stat = await fs.stat(changeDir);
+            if (!stat.isDirectory()) {
+                throw new Error(`Change '${changeName}' not found.`);
+            }
+        }
+        catch {
+            throw new Error(`Change '${changeName}' not found.`);
+        }
+        const skipValidation = options.validate === false || options.noValidate === true;
+        // Validate specs and change before archiving
+        if (!skipValidation) {
+            const validator = new Validator();
+            let hasValidationErrors = false;
+            // Validate proposal.md (non-blocking unless strict mode desired in future)
+            const changeFile = path.join(changeDir, 'proposal.md');
+            try {
+                await fs.access(changeFile);
+                const changeReport = await validator.validateChange(changeFile);
+                // Proposal validation is informative only (do not block archive)
+                if (!changeReport.valid) {
+                    console.log(chalk.yellow(`\nProposal warnings in proposal.md (non-blocking):`));
+                    for (const issue of changeReport.issues) {
+                        const symbol = issue.level === 'ERROR' ? '⚠' : (issue.level === 'WARNING' ? '⚠' : 'ℹ');
+                        console.log(chalk.yellow(`  ${symbol} ${issue.message}`));
+                    }
+                }
+            }
+            catch {
+                // Change file doesn't exist, skip validation
+            }
+            // Validate delta-formatted spec files under the change directory if present
+            const changeSpecsDir = path.join(changeDir, 'specs');
+            let hasDeltaSpecs = false;
+            try {
+                const candidates = await fs.readdir(changeSpecsDir, { withFileTypes: true });
+                for (const c of candidates) {
+                    if (c.isDirectory()) {
+                        try {
+                            const candidatePath = path.join(changeSpecsDir, c.name, 'spec.md');
+                            await fs.access(candidatePath);
+                            const content = await fs.readFile(candidatePath, 'utf-8');
+                            if (/^##\s+(ADDED|MODIFIED|REMOVED|RENAMED)\s+Requirements/m.test(content)) {
+                                hasDeltaSpecs = true;
+                                break;
+                            }
+                        }
+                        catch { }
+                    }
+                }
+            }
+            catch { }
+            if (hasDeltaSpecs) {
+                const deltaReport = await validator.validateChangeDeltaSpecs(changeDir);
+                if (!deltaReport.valid) {
+                    hasValidationErrors = true;
+                    console.log(chalk.red(`\nValidation errors in change delta specs:`));
+                    for (const issue of deltaReport.issues) {
+                        if (issue.level === 'ERROR') {
+                            console.log(chalk.red(`  ✗ ${issue.message}`));
+                        }
+                        else if (issue.level === 'WARNING') {
+                            console.log(chalk.yellow(`  ⚠ ${issue.message}`));
+                        }
+                    }
+                }
+            }
+            if (hasValidationErrors) {
+                console.log(chalk.red('\nValidation failed. Please fix the errors before archiving.'));
+                console.log(chalk.yellow('To skip validation (not recommended), use --no-validate flag.'));
+                return;
+            }
+        }
+        else {
+            // Log warning when validation is skipped
+            const timestamp = new Date().toISOString();
+            if (!options.yes) {
+                const { confirm } = await import('@inquirer/prompts');
+                const proceed = await confirm({
+                    message: chalk.yellow('⚠️  WARNING: Skipping validation may archive invalid specs. Continue? (y/N)'),
+                    default: false
+                });
+                if (!proceed) {
+                    console.log('Archive cancelled.');
+                    return;
+                }
+            }
+            else {
+                console.log(chalk.yellow(`\n⚠️  WARNING: Skipping validation may archive invalid specs.`));
+            }
+            console.log(chalk.yellow(`[${timestamp}] Validation skipped for change: ${changeName}`));
+            console.log(chalk.yellow(`Affected files: ${changeDir}`));
+        }
+        // Show progress and check for incomplete tasks
+        const progress = await getTaskProgressForChange(changesDir, changeName);
+        const status = formatTaskStatus(progress);
+        console.log(`Task status: ${status}`);
+        const incompleteTasks = Math.max(progress.total - progress.completed, 0);
+        if (incompleteTasks > 0) {
+            if (!options.yes) {
+                const { confirm } = await import('@inquirer/prompts');
+                const proceed = await confirm({
+                    message: `Warning: ${incompleteTasks} incomplete task(s) found. Continue?`,
+                    default: false
+                });
+                if (!proceed) {
+                    console.log('Archive cancelled.');
+                    return;
+                }
+            }
+            else {
+                console.log(`Warning: ${incompleteTasks} incomplete task(s) found. Continuing due to --yes flag.`);
+            }
+        }
+        // Handle spec updates unless skipSpecs flag is set
+        if (options.skipSpecs) {
+            console.log('Skipping spec updates (--skip-specs flag provided).');
+        }
+        else {
+            // Find specs to update
+            const specUpdates = await findSpecUpdates(changeDir, mainSpecsDir);
+            if (specUpdates.length > 0) {
+                console.log('\nSpecs to update:');
+                for (const update of specUpdates) {
+                    const status = update.exists ? 'update' : 'create';
+                    const capability = path.basename(path.dirname(update.target));
+                    console.log(`  ${capability}: ${status}`);
+                }
+                let shouldUpdateSpecs = true;
+                if (!options.yes) {
+                    const { confirm } = await import('@inquirer/prompts');
+                    shouldUpdateSpecs = await confirm({
+                        message: 'Proceed with spec updates?',
+                        default: true
+                    });
+                    if (!shouldUpdateSpecs) {
+                        console.log('Skipping spec updates. Proceeding with archive.');
+                    }
+                }
+                if (shouldUpdateSpecs) {
+                    if (!skipValidation) {
+                        try {
+                            await this.validateFingerprintsAgainstLiveSpec(changeName, changeDir, specUpdates);
+                        }
+                        catch (err) {
+                            console.log(String(err.message || err));
+                            console.log('Aborted. No files were changed.');
+                            return;
+                        }
+                    }
+                    // Prepare all updates first (validation pass, no writes)
+                    const prepared = [];
+                    try {
+                        for (const update of specUpdates) {
+                            const built = await buildUpdatedSpec(update, changeName);
+                            prepared.push({ update, rebuilt: built.rebuilt, counts: built.counts });
+                        }
+                    }
+                    catch (err) {
+                        console.log(String(err.message || err));
+                        console.log('Aborted. No files were changed.');
+                        return;
+                    }
+                    // All validations passed; pre-validate rebuilt full spec and then write files and display counts
+                    let totals = { added: 0, modified: 0, removed: 0, renamed: 0 };
+                    for (const p of prepared) {
+                        const specName = path.basename(path.dirname(p.update.target));
+                        if (!skipValidation) {
+                            const report = await new Validator().validateSpecContent(specName, p.rebuilt);
+                            if (!report.valid) {
+                                console.log(chalk.red(`\nValidation errors in rebuilt spec for ${specName} (will not write changes):`));
+                                for (const issue of report.issues) {
+                                    if (issue.level === 'ERROR')
+                                        console.log(chalk.red(`  ✗ ${issue.message}`));
+                                    else if (issue.level === 'WARNING')
+                                        console.log(chalk.yellow(`  ⚠ ${issue.message}`));
+                                }
+                                console.log('Aborted. No files were changed.');
+                                return;
+                            }
+                        }
+                        await writeUpdatedSpec(p.update, p.rebuilt, p.counts);
+                        totals.added += p.counts.added;
+                        totals.modified += p.counts.modified;
+                        totals.removed += p.counts.removed;
+                        totals.renamed += p.counts.renamed;
+                    }
+                    console.log(`Totals: + ${totals.added}, ~ ${totals.modified}, - ${totals.removed}, → ${totals.renamed}`);
+                    console.log('Specs updated successfully.');
+                }
+            }
+        }
+        // Create archive directory with date prefix
+        const archiveName = `${this.getArchiveDate()}-${changeName}`;
+        const archivePath = path.join(archiveDir, archiveName);
+        // Check if archive already exists
+        try {
+            await fs.access(archivePath);
+            throw new Error(`Archive '${archiveName}' already exists.`);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+        }
+        // Create archive directory if needed
+        await fs.mkdir(archiveDir, { recursive: true });
+        // Move change to archive (uses copy+remove on EPERM/EXDEV, e.g. Windows)
+        await moveDirectory(changeDir, archivePath);
+        console.log(`Change '${changeName}' archived as '${archiveName}'.`);
+    }
+    async selectChange(changesDir) {
+        const { select } = await import('@inquirer/prompts');
+        // Get all directories in changes (excluding archive)
+        const entries = await fs.readdir(changesDir, { withFileTypes: true });
+        const changeDirs = entries
+            .filter(entry => entry.isDirectory() && entry.name !== 'archive')
+            .map(entry => entry.name)
+            .sort();
+        if (changeDirs.length === 0) {
+            console.log('No active changes found.');
+            return null;
+        }
+        // Build choices with progress inline to avoid duplicate lists
+        let choices = changeDirs.map(name => ({ name, value: name }));
+        try {
+            const progressList = [];
+            for (const id of changeDirs) {
+                const progress = await getTaskProgressForChange(changesDir, id);
+                const status = formatTaskStatus(progress);
+                progressList.push({ id, status });
+            }
+            const nameWidth = Math.max(...progressList.map(p => p.id.length));
+            choices = progressList.map(p => ({
+                name: `${p.id.padEnd(nameWidth)}     ${p.status}`,
+                value: p.id
+            }));
+        }
+        catch {
+            // If anything fails, fall back to simple names
+            choices = changeDirs.map(name => ({ name, value: name }));
+        }
+        try {
+            const answer = await select({
+                message: 'Select a change to archive',
+                choices
+            });
+            return answer;
+        }
+        catch (error) {
+            // User cancelled (Ctrl+C)
+            return null;
+        }
+    }
+    getArchiveDate() {
+        // Returns date in YYYY-MM-DD format
+        return new Date().toISOString().split('T')[0];
+    }
+    async validateFingerprintsAgainstLiveSpec(changeName, changeDir, specUpdates) {
+        const mainSpecsDir = resolveOpenSpecLiveSubpath('.', 'specs');
+        let meta = await readMeta(changeDir);
+        if (!meta) {
+            meta = await captureFingerprintsForChange(changeDir, mainSpecsDir, {
+                sourceChangeId: changeName,
+                reconstructed: true,
+            });
+            await writeMeta(changeDir, meta);
+            console.log(chalk.yellow('Fingerprint metadata regenerated (reconstructed=true).'));
+        }
+        const fingerprintByRequirement = this.buildFingerprintLookup(meta);
+        for (const update of specUpdates) {
+            const capability = path.basename(path.dirname(update.target));
+            const sourceContent = await fs.readFile(update.source, 'utf-8');
+            const touched = this.collectTouchedRequirements(sourceContent, capability);
+            if (touched.length === 0) {
+                continue;
+            }
+            let liveSpecContent;
+            try {
+                liveSpecContent = await fs.readFile(update.target, 'utf-8');
+            }
+            catch {
+                throw new Error(`Unable to verify fingerprint for ${capability}: spec file not found. Re-run with --no-validate not recommended.`);
+            }
+            const currentBlocks = this.mapRequirementBlocks(liveSpecContent);
+            for (const touchedRequirement of touched) {
+                const fingerprintName = normalizeRequirementName(touchedRequirement.fingerprintRequirementId);
+                const key = buildRequirementKey(capability, fingerprintName);
+                const entry = fingerprintByRequirement.get(key);
+                const observedName = normalizeRequirementName(touchedRequirement.requirementId);
+                const blockRaw = currentBlocks.get(observedName) ?? currentBlocks.get(fingerprintName);
+                if (!blockRaw) {
+                    throw new Error(`Archive blocked for ${capability}: requirement "${touchedRequirement.requirementId}" is not present in current spec. Rebase this change against current specs.`);
+                }
+                if (!entry) {
+                    throw new Error(`Archive blocked for ${capability}: missing fingerprint for requirement "${touchedRequirement.requirementId}". Re-run "change validate" to recreate change metadata.`);
+                }
+                const currentHash = computeRequirementHash(blockRaw);
+                if (currentHash !== entry.base_hash) {
+                    const lastEditor = await this.inferLastEditorForRequirement(update.target, touchedRequirement.requirementId);
+                    await trackFingerprintMismatch({
+                        change_id: changeName,
+                        requirement_name: `${capability}::${touchedRequirement.requirementId}`,
+                        last_editor_change_id: lastEditor,
+                    });
+                    throw new Error(`Fingerprint mismatch for ${capability} "${touchedRequirement.requirementId}". ` +
+                        `Last editor: ${lastEditor}. Rebase this change onto current specs before archiving.`);
+                }
+            }
+        }
+    }
+    buildFingerprintLookup(meta) {
+        const map = new Map();
+        for (const entry of meta.requirements) {
+            map.set(buildRequirementKey(entry.capability, entry.requirement_id), entry);
+        }
+        return map;
+    }
+    collectTouchedRequirements(sourceContent, capability) {
+        const plan = parseDeltaSpec(sourceContent);
+        const renameToByFrom = new Map();
+        const renameFromByTo = new Map();
+        for (const rename of plan.renamed) {
+            const from = normalizeRequirementName(rename.from);
+            const to = normalizeRequirementName(rename.to);
+            renameToByFrom.set(from, to);
+            renameFromByTo.set(to, from);
+        }
+        const touched = [];
+        for (const modified of plan.modified) {
+            const fingerprintRequirementId = normalizeRequirementName(renameFromByTo.get(modified.name) ?? modified.name);
+            touched.push({
+                capability,
+                requirementId: normalizeRequirementName(modified.name),
+                fingerprintRequirementId,
+            });
+        }
+        for (const removed of plan.removed) {
+            touched.push({
+                capability,
+                requirementId: normalizeRequirementName(removed),
+                fingerprintRequirementId: normalizeRequirementName(removed),
+            });
+        }
+        for (const renamed of plan.renamed) {
+            const to = normalizeRequirementName(renameToByFrom.get(renamed.from) ?? renamed.to);
+            touched.push({
+                capability,
+                requirementId: normalizeRequirementName(renamed.from),
+                fingerprintRequirementId: normalizeRequirementName(renamed.from),
+            });
+            touched.push({
+                capability,
+                requirementId: to,
+                fingerprintRequirementId: normalizeRequirementName(renamed.from),
+            });
+        }
+        return touched;
+    }
+    mapRequirementBlocks(content) {
+        const map = new Map();
+        const parts = extractRequirementsSection(content);
+        for (const block of parts.bodyBlocks) {
+            map.set(normalizeRequirementName(block.name), block.raw);
+        }
+        return map;
+    }
+    async inferLastEditorForRequirement(specPath, requirementName) {
+        const specContent = await fs.readFile(specPath, 'utf-8');
+        const lines = specContent.split('\n');
+        const target = normalizeRequirementName(requirementName);
+        const line = lines.findIndex((candidate) => {
+            const match = candidate.match(/^###\s+Requirement:\s*(.+)\s*$/);
+            if (!match)
+                return false;
+            return normalizeRequirementName(match[1]) === target;
+        });
+        if (line === -1) {
+            return 'unknown';
+        }
+        const lineNumber = line + 1;
+        try {
+            const blameResult = await execFileAsync('git', [
+                'blame',
+                '-L',
+                `${lineNumber},${lineNumber}`,
+                '--line-porcelain',
+                '--',
+                specPath,
+            ], { cwd: path.dirname(specPath) });
+            const firstLine = `${blameResult.stdout}`.split('\n')[0];
+            const hashMatch = firstLine.match(/^([0-9a-f]{40})\s/);
+            if (!hashMatch) {
+                return 'unknown';
+            }
+            const logResult = await execFileAsync('git', ['log', '-1', '--format=%s', hashMatch[1]], {
+                cwd: path.dirname(specPath),
+            });
+            const message = `${logResult.stdout}`.trim();
+            const changeMatch = message.match(/FEAT-\d+/i);
+            return changeMatch ? changeMatch[0].toUpperCase() : 'unknown';
+        }
+        catch {
+            return 'unknown';
+        }
+    }
+}
+//# sourceMappingURL=archive.js.map