@open-agent-toolkit/cli 0.1.31 → 0.1.33

package/dist/commands/decision/index.js

@@ -0,0 +1,177 @@
+import { resolve } from 'node:path';
+import { buildCommandContext } from '../../app/command-context.js';
+import { readGlobalOptions } from '../shared/shared.utils.js';
+import { resolveAssetsRoot } from '../../fs/assets.js';
+import { resolveProjectRoot } from '../../fs/paths.js';
+import { Command } from 'commander';
+import { initializeDecisionRecords } from './init.js';
+import { migrateDecisionRecords } from './migrate.js';
+import { createDecisionRecord } from './new.js';
+import { regenerateDecisionIndex } from './regenerate-index.js';
+const DEFAULT_DEPENDENCIES = {
+    buildCommandContext,
+    resolveProjectRoot,
+    resolveAssetsRoot,
+    initializeDecisionRecords,
+    regenerateDecisionIndex,
+    createDecisionRecord,
+    migrateDecisionRecords,
+};
+async function resolveDecisionsRoot(context, projectRoot, configuredRoot) {
+    if (configuredRoot) {
+        return resolve(context.cwd, configuredRoot);
+    }
+    return resolve(projectRoot, '.oat', 'repo', 'reference', 'decisions');
+}
+async function resolveReferenceRoot(context, projectRoot, configuredRoot) {
+    if (configuredRoot) {
+        return resolve(context.cwd, configuredRoot);
+    }
+    return resolve(projectRoot, '.oat', 'repo', 'reference');
+}
+function reportError(context, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (context.json) {
+        context.logger.json({ status: 'error', message });
+    }
+    else {
+        context.logger.error(message);
+    }
+    process.exitCode = 1;
+}
+export function createDecisionCommand(overrides = {}) {
+    const dependencies = {
+        ...DEFAULT_DEPENDENCIES,
+        ...overrides,
+    };
+    const cmd = new Command('decision').description('Manage file-backed decision records and indexes');
+    cmd
+        .command('init')
+        .description('Scaffold the canonical decision directory and index')
+        .option('--decisions-root <path>', 'Decisions root directory (defaults to .oat/repo/reference/decisions)')
+        .action(async (options, command) => {
+        const context = dependencies.buildCommandContext(readGlobalOptions(command));
+        try {
+            const projectRoot = await dependencies.resolveProjectRoot(context.cwd);
+            const decisionsRoot = await resolveDecisionsRoot(context, projectRoot, options.decisionsRoot);
+            const result = await dependencies.initializeDecisionRecords(decisionsRoot);
+            if (context.json) {
+                context.logger.json({ status: 'ok', ...result });
+            }
+            else {
+                context.logger.info(`Initialized decision scaffold at ${result.decisionsRoot}`);
+                if (result.created.length > 0) {
+                    context.logger.info(`Created: ${result.created.join(', ')}`);
+                }
+                if (result.skipped.length > 0) {
+                    context.logger.info(`Skipped existing: ${result.skipped.join(', ')}`);
+                }
+            }
+            process.exitCode = 0;
+        }
+        catch (error) {
+            reportError(context, error);
+        }
+    });
+    cmd
+        .command('regenerate-index')
+        .description('Regenerate the managed decision index table')
+        .option('--decisions-root <path>', 'Decisions root directory (defaults to .oat/repo/reference/decisions)')
+        .action(async (options, command) => {
+        const context = dependencies.buildCommandContext(readGlobalOptions(command));
+        try {
+            const projectRoot = await dependencies.resolveProjectRoot(context.cwd);
+            const decisionsRoot = await resolveDecisionsRoot(context, projectRoot, options.decisionsRoot);
+            await dependencies.regenerateDecisionIndex(decisionsRoot);
+            if (context.json) {
+                context.logger.json({ status: 'ok', decisionsRoot });
+            }
+            else {
+                context.logger.info(`Regenerated decision index at ${decisionsRoot}`);
+            }
+            process.exitCode = 0;
+        }
+        catch (error) {
+            reportError(context, error);
+        }
+    });
+    cmd
+        .command('new')
+        .description('Create a new file-backed decision record')
+        .argument('<title>', 'Decision title')
+        .option('--decisions-root <path>', 'Decisions root directory (defaults to .oat/repo/reference/decisions)')
+        .option('--status <status>', 'Decision status', 'proposed')
+        .option('--context <text>', 'Initial context body text')
+        .option('--created-at <timestamp>', 'Creation timestamp seed for reproducible ID generation')
+        .action(async (title, options, command) => {
+        const context = dependencies.buildCommandContext(readGlobalOptions(command));
+        try {
+            const projectRoot = await dependencies.resolveProjectRoot(context.cwd);
+            const decisionsRoot = await resolveDecisionsRoot(context, projectRoot, options.decisionsRoot);
+            const assetsRoot = await dependencies.resolveAssetsRoot();
+            const result = await dependencies.createDecisionRecord({
+                decisionsRoot,
+                assetsRoot,
+                templatesRoot: resolve(projectRoot, '.oat', 'templates'),
+                title,
+                status: options.status,
+                context: options.context,
+                createdAt: options.createdAt,
+            });
+            if (context.json) {
+                context.logger.json({ status: 'ok', ...result });
+            }
+            else {
+                context.logger.info(`Created decision record ${result.id}`);
+                context.logger.info(`Wrote ${result.filePath}`);
+            }
+            process.exitCode = 0;
+        }
+        catch (error) {
+            reportError(context, error);
+        }
+    });
+    cmd
+        .command('migrate')
+        .description('Migrate legacy decision-record.md into decision records')
+        .option('--reference-root <path>', 'Reference root directory (defaults to .oat/repo/reference)')
+        .option('--dry-run', 'Print legacy-to-new mappings without writing files')
+        .option('--delete-legacy', 'Delete decision-record.md after a verified migration')
+        .action(async (options, command) => {
+        const context = dependencies.buildCommandContext(readGlobalOptions(command));
+        try {
+            const projectRoot = await dependencies.resolveProjectRoot(context.cwd);
+            const referenceRoot = await resolveReferenceRoot(context, projectRoot, options.referenceRoot);
+            const result = await dependencies.migrateDecisionRecords({
+                referenceRoot,
+                dryRun: options.dryRun ?? false,
+                deleteLegacy: options.deleteLegacy ?? false,
+            });
+            if (context.json) {
+                context.logger.json({ status: 'ok', ...result });
+            }
+            else if (!result.legacyPresent) {
+                // Absent-file no-op (F4): a prior `pjm migrate` already migrated and
+                // removed decision-record.md. Report a friendly no-op, not a throw.
+                context.logger.info(result.message ??
+                    'Nothing to migrate; no legacy decision-record.md found.');
+            }
+            else {
+                context.logger.info(result.dryRun
+                    ? `Decision migration dry run for ${result.referenceRoot}`
+                    : `Migrated decisions into ${result.decisionsRoot}`);
+                for (const mapping of result.mappings) {
+                    context.logger.info(`${mapping.legacyId} -> ${mapping.id} (${mapping.filePath})`);
+                }
+                if (result.deletedLegacy) {
+                    context.logger.info('Deleted legacy decision-record.md');
+                }
+            }
+            process.exitCode = 0;
+        }
+        catch (error) {
+            reportError(context, error);
+        }
+    });
+    return cmd;
+}

package/dist/commands/decision/init.d.ts

@@ -0,0 +1,7 @@
+export interface DecisionInitResult {
+    decisionsRoot: string;
+    created: string[];
+    skipped: string[];
+}
+export declare function initializeDecisionRecords(decisionsRoot: string): Promise<DecisionInitResult>;
+//# sourceMappingURL=init.d.ts.map

package/dist/commands/decision/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../src/commands/decision/init.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,kBAAkB;IACjC,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAsCD,wBAAsB,yBAAyB,CAC7C,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,kBAAkB,CAAC,CAkB7B"}

package/dist/commands/decision/init.js

@@ -0,0 +1,53 @@
+import { access, mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { renderDecisionManagedSection } from './regenerate-index.js';
+const STARTER_INDEX = [
+    '# OAT Decision Index',
+    '',
+    '> Generated decision table lives inside the managed section below. Keep curated narrative updates outside the marker pair so CLI regeneration stays safe.',
+    '',
+    '## Curated Overview',
+    '',
+    '- Add brief narrative summaries here as decisions are created and migrated.',
+    '',
+    renderDecisionManagedSection([]),
+    '',
+    '## Notes',
+    '',
+    '- Decision records live as file-per-record Markdown files in this directory.',
+    '- Regenerate this index with `oat decision regenerate-index` after resolving conflicts.',
+    '',
+].join('\n');
+async function pathExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch (error) {
+        const code = error && typeof error === 'object' && 'code' in error
+            ? String(error.code)
+            : null;
+        if (code !== 'ENOENT') {
+            throw error;
+        }
+        return false;
+    }
+}
+export async function initializeDecisionRecords(decisionsRoot) {
+    const created = [];
+    const skipped = [];
+    await mkdir(decisionsRoot, { recursive: true });
+    const indexPath = join(decisionsRoot, 'index.md');
+    if (await pathExists(indexPath)) {
+        skipped.push('index.md');
+    }
+    else {
+        await writeFile(indexPath, STARTER_INDEX, 'utf8');
+        created.push('index.md');
+    }
+    return {
+        decisionsRoot,
+        created,
+        skipped,
+    };
+}

package/dist/commands/decision/migrate.d.ts

@@ -0,0 +1,24 @@
+export interface DecisionMigrationOptions {
+    referenceRoot: string;
+    dryRun?: boolean;
+    deleteLegacy?: boolean;
+}
+export interface DecisionMigrationMapping {
+    legacyId: string;
+    id: string;
+    title: string;
+    date: string;
+    filePath: string;
+}
+export interface DecisionMigrationResult {
+    referenceRoot: string;
+    decisionsRoot: string;
+    dryRun: boolean;
+    deletedLegacy: boolean;
+    mappings: DecisionMigrationMapping[];
+    written: string[];
+    legacyPresent: boolean;
+    message?: string;
+}
+export declare function migrateDecisionRecords(options: DecisionMigrationOptions): Promise<DecisionMigrationResult>;
+//# sourceMappingURL=migrate.d.ts.map

package/dist/commands/decision/migrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate.d.ts","sourceRoot":"","sources":["../../../src/commands/decision/migrate.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,wBAAwB;IACvC,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,EAAE,MAAM,CAAC;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,uBAAuB;IACtC,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,OAAO,CAAC;IAChB,aAAa,EAAE,OAAO,CAAC;IACvB,QAAQ,EAAE,wBAAwB,EAAE,CAAC;IACrC,OAAO,EAAE,MAAM,EAAE,CAAC;IAIlB,aAAa,EAAE,OAAO,CAAC;IAEvB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AA4RD,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,wBAAwB,GAChC,OAAO,CAAC,uBAAuB,CAAC,CAgFlC"}

package/dist/commands/decision/migrate.js

@@ -0,0 +1,270 @@
+import { readFile, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import YAML from 'yaml';
+import { initializeDecisionRecords } from './init.js';
+import { regenerateDecisionIndex } from './regenerate-index.js';
+import { generateDecisionId } from './shared/generate-id.js';
+const NOTHING_TO_MIGRATE_MESSAGE = 'Nothing to migrate; no legacy decision-record.md found.';
+// Real-world `decision-record.md` files use `### ADR-NNN: Title` headings (and
+// `## ADR-NNN: Title` in older fixtures), optionally without a trailing title.
+// The capture groups are: [1] legacy id (e.g. `ADR-001`), [2] optional title.
+const LEGACY_HEADING_PATTERN = /^#{2,3}\s+((?:ADR|DR)-\d+)(?::\s*(.+?))?\s*$/gim;
+const LEGACY_ID_PATTERN = /^(?:ADR|DR)-\d+$/i;
+function parseLegacyIndexRows(content) {
+    const rows = [];
+    for (const line of content.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('|')) {
+            continue;
+        }
+        const cells = trimmed
+            .split('|')
+            .slice(1, -1)
+            .map((cell) => cell.trim());
+        const id = cells[0];
+        if (!id || id === 'ID' || /^-+$/.test(id)) {
+            continue;
+        }
+        if (!LEGACY_ID_PATTERN.test(id)) {
+            continue;
+        }
+        // The real-world Decision Index is `| ID | Date | Status | Title |`. We use
+        // it both as a parity check and as a fallback source for Date/Status/Title.
+        rows.push({
+            id,
+            date: cells[1] || undefined,
+            status: cells[2] || undefined,
+            title: cells[3] || undefined,
+        });
+    }
+    return rows;
+}
+function parseLegacyIndexIds(content) {
+    return parseLegacyIndexRows(content).map((row) => row.id);
+}
+// Matches both the real-world bold form (`- **Date:** 2026-01-30`) and the
+// older plain form (`- Date: 2026-01-30`). The optional `**` markers wrap the
+// `Field:` label, so the colon stays inside the emphasis on the bold form.
+function parseLegacyField(section, field) {
+    const escapedField = field.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const regex = new RegExp(`^-\\s*\\*{0,2}${escapedField}:\\*{0,2}\\s*(.+?)\\s*$`, 'im');
+    return regex.exec(section)?.[1]?.trim() ?? null;
+}
+// A level-2 heading (exactly two `#`). Decision records are level-3
+// (`### ADR-NNN`) inside the `## Decisions` region and their bodies use level-4
+// (`#### …`) sub-headings, so any `^## ` heading after a record marks the end of
+// the decisions region — e.g. a trailing `## ADR Template` boilerplate block.
+const LEVEL_TWO_HEADING_PATTERN = /^##\s+(?!#)/gm;
+// Returns the offset of the first `^## ` (exactly two-hash) heading that starts
+// strictly after `afterIndex`, or `content.length` when none exists. Used to
+// bound a decision section's body at the end of the decisions region so trailing
+// `##`-level boilerplate is never absorbed into the last record.
+function nextLevelTwoHeadingIndex(content, afterIndex) {
+    LEVEL_TWO_HEADING_PATTERN.lastIndex = afterIndex;
+    const match = LEVEL_TWO_HEADING_PATTERN.exec(content);
+    return match ? match.index : content.length;
+}
+function parseLegacyDecisionSections(content) {
+    const indexRows = new Map(parseLegacyIndexRows(content).map((row) => [row.id, row]));
+    const matches = [...content.matchAll(LEGACY_HEADING_PATTERN)];
+    return matches.map((match, index) => {
+        const sectionStart = match.index ?? 0;
+        // Bound the body at whichever comes first after this section starts: the
+        // next ADR/DR heading, or the next `^## ` level-2 heading (which ends the
+        // decisions region, e.g. `## ADR Template`). Default to EOF when neither
+        // exists. This keeps trailing boilerplate out of the last record (F2).
+        const nextRecordStart = matches[index + 1]?.index ?? content.length;
+        const sectionEnd = Math.min(nextRecordStart, nextLevelTwoHeadingIndex(content, sectionStart + 1));
+        const section = content.slice(sectionStart, sectionEnd).trim();
+        const legacyId = match[1];
+        const indexRow = indexRows.get(legacyId);
+        const title = (match[2]?.trim() || indexRow?.title || legacyId).trim();
+        const date = parseLegacyField(section, 'Date') ?? indexRow?.date ?? null;
+        if (!date) {
+            throw new Error(`Legacy decision ${legacyId} is missing a Date field.`);
+        }
+        return {
+            legacyId,
+            title,
+            date,
+            status: parseLegacyField(section, 'Status') ?? indexRow?.status ?? 'proposed',
+            body: section,
+        };
+    });
+}
+function assertSafeLegacyDelete(legacyIndexIds, sections) {
+    if (sections.length === 0) {
+        throw new Error('Refusing to delete legacy decision source because no legacy decision sections were parsed.');
+    }
+    if (legacyIndexIds.length === 0) {
+        return;
+    }
+    const sectionIds = new Set(sections.map((section) => section.legacyId));
+    const missingSections = legacyIndexIds.filter((id) => !sectionIds.has(id));
+    if (legacyIndexIds.length !== sections.length || missingSections.length > 0) {
+        throw new Error(`Refusing to delete legacy decision source because parsed index count (${legacyIndexIds.length}) does not match parsed section count (${sections.length}). Missing sections: ${missingSections.join(', ') || 'none'}.`);
+    }
+}
+function renderMigratedRecord(section, id) {
+    const frontmatter = YAML.stringify({
+        id,
+        title: section.title,
+        date: section.date,
+        status: section.status,
+        legacy_id: section.legacyId,
+    }).trimEnd();
+    return `---\n${frontmatter}\n---\n\n${section.body.trimEnd()}\n`;
+}
+function prepareDecisionMigrations(sections, decisionsRoot) {
+    return sections.map((section) => {
+        const id = generateDecisionId(section.title, section.date);
+        const mapping = {
+            legacyId: section.legacyId,
+            id,
+            title: section.title,
+            date: section.date,
+            filePath: join(decisionsRoot, `${id}.md`),
+        };
+        return {
+            mapping,
+            content: renderMigratedRecord(section, id),
+        };
+    });
+}
+function assertUniqueMigrationTargets(preparedMigrations) {
+    const seen = new Map();
+    for (const prepared of preparedMigrations) {
+        const previousLegacyId = seen.get(prepared.mapping.filePath);
+        if (previousLegacyId) {
+            throw new Error(`Duplicate decision migration target ${prepared.mapping.filePath} generated for ${previousLegacyId} and ${prepared.mapping.legacyId}. Use unique date/title combinations before rerunning migration.`);
+        }
+        seen.set(prepared.mapping.filePath, prepared.mapping.legacyId);
+    }
+}
+async function readExistingTarget(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch (error) {
+        const code = error && typeof error === 'object' && 'code' in error
+            ? String(error.code)
+            : null;
+        if (code !== 'ENOENT') {
+            throw error;
+        }
+        return null;
+    }
+}
+// Reads the legacy `decision-record.md`, returning `null` when the file is
+// absent (rather than throwing ENOENT). The absent-file case is a legitimate
+// no-op: a prior `pjm migrate --apply` already migrated decisions end-to-end
+// and removed the legacy monolith, so a standalone `decision migrate` (or
+// `--dry-run`) afterward should degrade gracefully (F4).
+async function readLegacySource(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch (error) {
+        const code = error && typeof error === 'object' && 'code' in error
+            ? String(error.code)
+            : null;
+        if (code !== 'ENOENT') {
+            throw error;
+        }
+        return null;
+    }
+}
+async function findPendingWrites(preparedMigrations) {
+    const pendingWrites = [];
+    for (const prepared of preparedMigrations) {
+        const existingContent = await readExistingTarget(prepared.mapping.filePath);
+        if (existingContent === null) {
+            pendingWrites.push(prepared);
+            continue;
+        }
+        if (existingContent !== prepared.content) {
+            throw new Error(`Decision migration target ${prepared.mapping.filePath} already exists with different content. Resolve or move the conflicting file before rerunning migration.`);
+        }
+    }
+    return pendingWrites;
+}
+async function verifyMigratedTargets(preparedMigrations) {
+    for (const prepared of preparedMigrations) {
+        const existingContent = await readExistingTarget(prepared.mapping.filePath);
+        if (existingContent !== prepared.content) {
+            throw new Error(`Decision migration target ${prepared.mapping.filePath} was not verified after migration. Rerun without --delete-legacy after resolving the target record.`);
+        }
+    }
+}
+export async function migrateDecisionRecords(options) {
+    const legacyPath = join(options.referenceRoot, 'decision-record.md');
+    const decisionsRoot = join(options.referenceRoot, 'decisions');
+    const legacyContent = await readLegacySource(legacyPath);
+    // Absent-file no-op (F4): nothing to migrate. This is distinct from the
+    // present-but-empty/unparseable case (which still flows through parsing and
+    // keeps the zero-section delete-safety guard). Return a clean result for both
+    // dry-run and apply instead of throwing ENOENT.
+    if (legacyContent === null) {
+        return {
+            referenceRoot: options.referenceRoot,
+            decisionsRoot,
+            dryRun: options.dryRun ?? false,
+            deletedLegacy: false,
+            mappings: [],
+            written: [],
+            legacyPresent: false,
+            message: NOTHING_TO_MIGRATE_MESSAGE,
+        };
+    }
+    const legacyIndexIds = parseLegacyIndexIds(legacyContent);
+    const sections = parseLegacyDecisionSections(legacyContent);
+    if (options.deleteLegacy) {
+        assertSafeLegacyDelete(legacyIndexIds, sections);
+    }
+    const preparedMigrations = prepareDecisionMigrations(sections, decisionsRoot);
+    assertUniqueMigrationTargets(preparedMigrations);
+    const mappings = preparedMigrations.map((prepared) => prepared.mapping);
+    if (options.dryRun) {
+        return {
+            referenceRoot: options.referenceRoot,
+            decisionsRoot,
+            dryRun: true,
+            deletedLegacy: false,
+            mappings,
+            written: [],
+            legacyPresent: true,
+        };
+    }
+    const pendingWrites = await findPendingWrites(preparedMigrations);
+    await initializeDecisionRecords(decisionsRoot);
+    const written = [];
+    try {
+        for (const prepared of pendingWrites) {
+            await writeFile(prepared.mapping.filePath, prepared.content, {
+                encoding: 'utf8',
+                flag: 'wx',
+            });
+            written.push(prepared.mapping.filePath);
+        }
+        await regenerateDecisionIndex(decisionsRoot);
+        await verifyMigratedTargets(preparedMigrations);
+    }
+    catch (error) {
+        await Promise.all(written.map((path) => rm(path, { force: true })));
+        throw error;
+    }
+    let deletedLegacy = false;
+    if (options.deleteLegacy) {
+        await rm(legacyPath);
+        deletedLegacy = true;
+    }
+    return {
+        referenceRoot: options.referenceRoot,
+        decisionsRoot,
+        dryRun: false,
+        deletedLegacy,
+        mappings,
+        written,
+        legacyPresent: true,
+    };
+}

package/dist/commands/decision/new.d.ts

@@ -0,0 +1,16 @@
+export interface CreateDecisionRecordOptions {
+    decisionsRoot: string;
+    assetsRoot: string;
+    templatesRoot?: string;
+    title: string;
+    status?: string;
+    context?: string;
+    createdAt?: string;
+}
+export interface CreateDecisionRecordResult {
+    id: string;
+    decisionsRoot: string;
+    filePath: string;
+}
+export declare function createDecisionRecord(options: CreateDecisionRecordOptions): Promise<CreateDecisionRecordResult>;
+//# sourceMappingURL=new.d.ts.map

package/dist/commands/decision/new.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"new.d.ts","sourceRoot":"","sources":["../../../src/commands/decision/new.ts"],"names":[],"mappings":"AAYA,MAAM,WAAW,2BAA2B;IAC1C,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,0BAA0B;IACzC,EAAE,EAAE,MAAM,CAAC;IACX,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;CAClB;AA0HD,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,2BAA2B,GACnC,OAAO,CAAC,0BAA0B,CAAC,CA8CrC"}

package/dist/commands/decision/new.js

@@ -0,0 +1,118 @@
+import { access, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { stripTemplateFrontmatter } from '../shared/strip-template-frontmatter.js';
+import YAML from 'yaml';
+import { assertDecisionIndexScaffold, regenerateDecisionIndex, } from './regenerate-index.js';
+import { generateDecisionId } from './shared/generate-id.js';
+async function pathExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch (error) {
+        const code = error && typeof error === 'object' && 'code' in error
+            ? String(error.code)
+            : null;
+        if (code !== 'ENOENT') {
+            throw error;
+        }
+        return false;
+    }
+}
+async function readIfExists(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch (error) {
+        const code = error && typeof error === 'object' && 'code' in error
+            ? String(error.code)
+            : null;
+        if (code !== 'ENOENT') {
+            throw error;
+        }
+        return null;
+    }
+}
+async function resolveDecisionTemplate(assetsRoot, templatesRoot) {
+    if (templatesRoot) {
+        const localTemplate = await readIfExists(join(templatesRoot, 'decision.md'));
+        if (localTemplate !== null) {
+            return localTemplate;
+        }
+    }
+    const bundledTemplate = await readIfExists(join(assetsRoot, 'templates', 'decision.md'));
+    if (bundledTemplate !== null) {
+        return bundledTemplate;
+    }
+    throw new Error('Template decision.md was not found in repo-local templates or bundled assets.');
+}
+function normalizeCreatedAt(createdAt) {
+    const date = new Date(createdAt);
+    if (Number.isNaN(date.getTime())) {
+        throw new Error(`Invalid decision creation timestamp: ${createdAt}`);
+    }
+    const timestamp = date.toISOString();
+    return {
+        timestamp,
+        date: timestamp.slice(0, 10),
+    };
+}
+function replaceTemplatePlaceholders(content, replacements) {
+    return content.replace(/\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g, (match, key) => replacements[key] ?? match);
+}
+function renderDecisionRecord(template, options) {
+    const bodyTemplate = stripTemplateFrontmatter(template).replace(/^\r?\n+/, '');
+    const body = replaceTemplatePlaceholders(bodyTemplate, {
+        id: options.id,
+        title: options.title,
+        date: options.date,
+        status: options.status,
+        context: options.context,
+        decision: 'TODO',
+        consequences: 'TODO',
+    });
+    const frontmatter = YAML.stringify({
+        id: options.id,
+        title: options.title,
+        date: options.date,
+        status: options.status,
+        legacy_id: null,
+    }).trimEnd();
+    return `---\n${frontmatter}\n---\n\n${body.trimEnd()}\n`;
+}
+export async function createDecisionRecord(options) {
+    const createdAt = normalizeCreatedAt(options.createdAt ?? new Date().toISOString());
+    const status = options.status ?? 'proposed';
+    const id = generateDecisionId(options.title, createdAt.timestamp);
+    const filePath = join(options.decisionsRoot, `${id}.md`);
+    if (await pathExists(filePath)) {
+        throw new Error(`Decision record ${id} already exists. Use a more specific title to disambiguate.`);
+    }
+    const template = await resolveDecisionTemplate(options.assetsRoot, options.templatesRoot);
+    const content = renderDecisionRecord(template, {
+        id,
+        title: options.title,
+        date: createdAt.date,
+        status,
+        context: options.context ?? 'TODO',
+    });
+    await assertDecisionIndexScaffold(options.decisionsRoot);
+    await mkdir(dirname(filePath), { recursive: true });
+    let wroteRecord = false;
+    try {
+        await writeFile(filePath, content, { encoding: 'utf8', flag: 'wx' });
+        wroteRecord = true;
+        await regenerateDecisionIndex(options.decisionsRoot);
+    }
+    catch (error) {
+        if (wroteRecord) {
+            await rm(filePath, { force: true });
+        }
+        throw error;
+    }
+    return {
+        id,
+        decisionsRoot: options.decisionsRoot,
+        filePath,
+    };
+}