@open-agent-toolkit/cli 0.1.31 → 0.1.33

package/dist/commands/pjm/migrate.js

@@ -0,0 +1,393 @@
+import { access, mkdir, readdir, readFile, rename, stat, writeFile, } from 'node:fs/promises';
+import { basename, dirname, join } from 'node:path';
+import { initializeBacklog } from '../backlog/init.js';
+import { regenerateBacklogIndex } from '../backlog/regenerate-index.js';
+import { generateBacklogId } from '../backlog/shared/generate-id.js';
+import { initializeDecisionRecords } from '../decision/init.js';
+import { migrateDecisionRecords, } from '../decision/migrate.js';
+import { stripTemplateFrontmatter } from '../shared/strip-template-frontmatter.js';
+import YAML from 'yaml';
+import { initializeRepoReference } from './init.js';
+const ACTIVE_MOVES = [
+    { source: 'reference/current-state.md', target: 'pjm/current-state.md' },
+    { source: 'reference/roadmap.md', target: 'pjm/roadmap.md' },
+    { source: 'reference/backlog', target: 'pjm/backlog' },
+];
+const JUDGMENT_TARGETS = [
+    'reference/backlog.md',
+    'reference/backlog-completed.md',
+];
+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 listMarkdownFiles(path) {
+    try {
+        const entries = await readdir(path, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith('.md'))
+            .map((entry) => join(path, entry.name))
+            .sort();
+    }
+    catch (error) {
+        const code = error && typeof error === 'object' && 'code' in error
+            ? String(error.code)
+            : null;
+        if (code !== 'ENOENT') {
+            throw error;
+        }
+        return [];
+    }
+}
+function stripMarkdownExtension(path) {
+    return basename(path, '.md');
+}
+function relativeToRepo(repoRoot, path) {
+    return path.startsWith(`${repoRoot}/`)
+        ? path.slice(repoRoot.length + 1)
+        : path;
+}
+function parseFrontmatter(content, filePath) {
+    const match = content.match(/^---\n([\s\S]*?)\n---(\r?\n[\s\S]*)?$/);
+    if (!match) {
+        return null;
+    }
+    const parsed = YAML.parse(match[1] ?? '');
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`Frontmatter in ${filePath} must be a YAML object.`);
+    }
+    return {
+        frontmatter: parsed,
+        body: match[2] ?? '\n',
+    };
+}
+function renderFrontmatterRecord(frontmatter, body) {
+    return `---\n${YAML.stringify(frontmatter).trimEnd()}\n---${body}`;
+}
+async function createdAtForBacklogRecord(frontmatter, filePath) {
+    const created = frontmatter.created;
+    if (typeof created === 'string' && created.trim()) {
+        return created;
+    }
+    return (await stat(filePath)).mtime.toISOString();
+}
+function withNumericSuffix(id, suffix) {
+    return `${id}-${suffix}`;
+}
+async function allocateBacklogId(initialId, currentPath, targetDir, plannedTargets) {
+    let id = initialId;
+    let suffix = 2;
+    let targetPath = join(targetDir, `${id}.md`);
+    while (plannedTargets.has(targetPath) ||
+        (targetPath !== currentPath && (await pathExists(targetPath)))) {
+        id = withNumericSuffix(initialId, suffix);
+        targetPath = join(targetDir, `${id}.md`);
+        suffix += 1;
+    }
+    plannedTargets.add(targetPath);
+    return { id, targetPath };
+}
+async function prepareBacklogMigrations(backlogRoot) {
+    const prepared = [];
+    const plannedTargets = new Set();
+    for (const bucket of ['items', 'archived']) {
+        const bucketRoot = join(backlogRoot, bucket);
+        const files = await listMarkdownFiles(bucketRoot);
+        for (const sourcePath of files) {
+            const content = await readFile(sourcePath, 'utf8');
+            const parsed = parseFrontmatter(content, sourcePath);
+            if (!parsed) {
+                continue;
+            }
+            const legacyId = String(parsed.frontmatter.id ?? stripMarkdownExtension(sourcePath));
+            const title = String(parsed.frontmatter.title ?? legacyId);
+            const createdAt = await createdAtForBacklogRecord(parsed.frontmatter, sourcePath);
+            const initialId = generateBacklogId(title, createdAt);
+            const { id, targetPath } = await allocateBacklogId(initialId, sourcePath, bucketRoot, plannedTargets);
+            if (id === legacyId && targetPath === sourcePath) {
+                continue;
+            }
+            const nextFrontmatter = {
+                ...parsed.frontmatter,
+                id,
+            };
+            // Migrated items are instantiated records, never raw templates. Drop the
+            // template-marker keys a legacy item may still carry so `pjm doctor`
+            // (prev2-t05) does not flag the migrated record. The shared
+            // `stripTemplateFrontmatter` defines which markers identify a raw
+            // template; mirror that key set here rather than re-parsing.
+            delete nextFrontmatter.oat_template;
+            delete nextFrontmatter.oat_template_name;
+            if (nextFrontmatter.legacy_id === undefined) {
+                nextFrontmatter.legacy_id = legacyId;
+            }
+            // Defense-in-depth: run the rebuilt record through the shared helper so any
+            // residual template frontmatter is stripped with the same rules doctor and
+            // `decision new` use. It is a no-op once the marker keys above are removed.
+            const migratedContent = stripTemplateFrontmatter(renderFrontmatterRecord(nextFrontmatter, parsed.body));
+            prepared.push({
+                sourcePath,
+                targetPath,
+                content: migratedContent,
+                mapping: {
+                    legacyId,
+                    id,
+                    title,
+                    filePath: targetPath,
+                },
+            });
+        }
+    }
+    return prepared;
+}
+async function applyBacklogMigrations(preparedMigrations) {
+    const written = [];
+    for (const migration of preparedMigrations) {
+        await mkdir(dirname(migration.targetPath), { recursive: true });
+        await writeFile(migration.sourcePath, migration.content, 'utf8');
+        if (migration.sourcePath !== migration.targetPath) {
+            await rename(migration.sourcePath, migration.targetPath);
+        }
+        written.push(migration.targetPath);
+    }
+    return written;
+}
+async function planActiveMoves(repoRoot) {
+    const actions = [];
+    for (const move of ACTIVE_MOVES) {
+        const sourcePath = join(repoRoot, move.source);
+        const targetPath = join(repoRoot, move.target);
+        const sourceExists = await pathExists(sourcePath);
+        const targetExists = await pathExists(targetPath);
+        if (sourceExists && !targetExists) {
+            actions.push({ type: 'move', ...move, result: 'planned' });
+        }
+        else if (sourceExists && targetExists) {
+            actions.push({
+                type: 'move',
+                ...move,
+                result: 'skipped',
+                reason: 'target already exists; leaving source for manual review',
+            });
+        }
+    }
+    return actions;
+}
+async function applyActiveMoves(repoRoot, actions) {
+    const moved = [];
+    for (const action of actions) {
+        if (action.type !== 'move' ||
+            action.result !== 'planned' ||
+            !action.source ||
+            !action.target) {
+            continue;
+        }
+        const sourcePath = join(repoRoot, action.source);
+        const targetPath = join(repoRoot, action.target);
+        await mkdir(dirname(targetPath), { recursive: true });
+        await rename(sourcePath, targetPath);
+        action.result = 'applied';
+        moved.push(targetPath);
+    }
+    return moved;
+}
+async function collectJudgmentProposals(repoRoot) {
+    const actions = [];
+    for (const target of JUDGMENT_TARGETS) {
+        if (await pathExists(join(repoRoot, target))) {
+            actions.push({
+                type: 'propose',
+                source: target,
+                result: 'planned',
+                reason: 'legacy backlog file retirement requires explicit review',
+            });
+        }
+    }
+    const referenceRoot = join(repoRoot, 'reference');
+    for (const filePath of await listMarkdownFiles(referenceRoot)) {
+        const name = basename(filePath);
+        if (name !== 'roadmap.md' && name.toLowerCase().includes('roadmap')) {
+            actions.push({
+                type: 'propose',
+                source: relativeToRepo(repoRoot, filePath),
+                result: 'planned',
+                reason: 'second roadmap disposition requires explicit review',
+            });
+        }
+    }
+    return actions;
+}
+async function isAlreadyMigrated(repoRoot) {
+    const hasPjm = await pathExists(join(repoRoot, 'pjm'));
+    const hasDecisions = await pathExists(join(repoRoot, 'reference', 'decisions'));
+    if (!hasPjm || !hasDecisions) {
+        return false;
+    }
+    for (const legacyPath of [
+        'reference/current-state.md',
+        'reference/roadmap.md',
+        'reference/backlog',
+        'reference/decision-record.md',
+    ]) {
+        if (await pathExists(join(repoRoot, legacyPath))) {
+            return false;
+        }
+    }
+    return true;
+}
+async function collectDecisionMappings(repoRoot) {
+    const referenceRoot = join(repoRoot, 'reference');
+    const legacyPath = join(referenceRoot, 'decision-record.md');
+    if (!(await pathExists(legacyPath))) {
+        return [];
+    }
+    return (await migrateDecisionRecords({
+        referenceRoot,
+        dryRun: true,
+    })).mappings;
+}
+/**
+ * Preflights the decision-migration step without mutating anything.
+ *
+ * Runs the same guards the apply step will run, including the destructive
+ * delete-safety guard (`deleteLegacy: true`), but in dry-run mode so it writes
+ * and deletes nothing. This is the failure-prone precondition surfaced by
+ * dogfooding: an unparseable `decision-record.md` previously aborted only after
+ * mechanical moves had already happened. Validating it up front keeps
+ * `--apply` atomic — any decision-parse problem fails before the tree changes.
+ */
+async function preflightDecisionMigration(repoRoot) {
+    const referenceRoot = join(repoRoot, 'reference');
+    const legacyPath = join(referenceRoot, 'decision-record.md');
+    if (!(await pathExists(legacyPath))) {
+        return;
+    }
+    await migrateDecisionRecords({
+        referenceRoot,
+        deleteLegacy: true,
+        dryRun: true,
+    });
+}
+async function migrateDecisions(repoRoot) {
+    const referenceRoot = join(repoRoot, 'reference');
+    const legacyPath = join(referenceRoot, 'decision-record.md');
+    if (!(await pathExists(legacyPath))) {
+        await initializeDecisionRecords(join(referenceRoot, 'decisions'));
+        return { mappings: [], written: [] };
+    }
+    const result = await migrateDecisionRecords({
+        referenceRoot,
+        deleteLegacy: true,
+    });
+    return { mappings: result.mappings, written: result.written };
+}
+function buildEmptyResult(options, status, reason) {
+    return {
+        repoRoot: options.repoRoot,
+        status,
+        reason,
+        dryRun: !options.apply,
+        actions: [],
+        backlogMappings: [],
+        decisionMappings: [],
+        written: [],
+    };
+}
+export async function migratePjmRepo(options) {
+    if (!options.projectManagementEnabled) {
+        return buildEmptyResult(options, 'skipped', 'project-management pack is disabled');
+    }
+    if (await isAlreadyMigrated(options.repoRoot)) {
+        return buildEmptyResult(options, 'already-migrated');
+    }
+    const apply = options.apply ?? false;
+    const activeMoves = await planActiveMoves(options.repoRoot);
+    const judgmentProposals = await collectJudgmentProposals(options.repoRoot);
+    const legacyBacklogRoot = join(options.repoRoot, 'reference', 'backlog');
+    const pjmBacklogRoot = join(options.repoRoot, 'pjm', 'backlog');
+    const backlogRoot = (await pathExists(legacyBacklogRoot))
+        ? legacyBacklogRoot
+        : pjmBacklogRoot;
+    const preparedBacklogMigrations = await prepareBacklogMigrations(backlogRoot);
+    const decisionMappings = await collectDecisionMappings(options.repoRoot);
+    const backlogMappings = preparedBacklogMigrations.map((migration) => migration.mapping);
+    const migrationActions = [];
+    if (backlogMappings.length > 0) {
+        migrationActions.push({
+            type: 'migrate-backlog',
+            source: relativeToRepo(options.repoRoot, backlogRoot),
+            target: 'pjm/backlog',
+            result: 'planned',
+        });
+    }
+    if (decisionMappings.length > 0) {
+        migrationActions.push({
+            type: 'migrate-decisions',
+            source: 'reference/decision-record.md',
+            target: 'reference/decisions',
+            result: 'planned',
+        });
+    }
+    const actions = [...activeMoves, ...migrationActions, ...judgmentProposals];
+    if (!apply) {
+        return {
+            repoRoot: options.repoRoot,
+            status: 'dry-run',
+            dryRun: true,
+            actions,
+            backlogMappings,
+            decisionMappings,
+            written: [],
+        };
+    }
+    // Preflight every failure-prone precondition BEFORE any mechanical mutation so
+    // `--apply` is atomic: if a step would fail, we abort here with the tree
+    // unchanged. The decision-record parse is the dogfood-surfaced failure mode —
+    // an unparseable source previously aborted only after files had already moved,
+    // leaving a half-migrated tree.
+    await preflightDecisionMigration(options.repoRoot);
+    const written = [];
+    written.push(...(await applyActiveMoves(options.repoRoot, activeMoves)));
+    await initializeRepoReference({
+        repoRoot: options.repoRoot,
+        assetsRoot: options.assetsRoot,
+        templatesRoot: options.templatesRoot,
+    });
+    const preparedAfterMove = await prepareBacklogMigrations(pjmBacklogRoot);
+    written.push(...(await applyBacklogMigrations(preparedAfterMove)));
+    if (await pathExists(join(pjmBacklogRoot, 'index.md'))) {
+        await regenerateBacklogIndex(pjmBacklogRoot);
+        written.push(join(pjmBacklogRoot, 'index.md'));
+    }
+    else {
+        await initializeBacklog(pjmBacklogRoot);
+    }
+    const decisionResult = await migrateDecisions(options.repoRoot);
+    written.push(...decisionResult.written);
+    for (const action of migrationActions) {
+        action.result = 'applied';
+    }
+    return {
+        repoRoot: options.repoRoot,
+        status: 'migrated',
+        dryRun: false,
+        actions: [...activeMoves, ...migrationActions, ...judgmentProposals],
+        backlogMappings: preparedAfterMove.map((migration) => migration.mapping),
+        decisionMappings: decisionResult.mappings,
+        written,
+    };
+}
+export async function readPjmMigrationPrompt(assetsRoot) {
+    return readFile(join(assetsRoot, 'migration', 'pjm-restructure.md'), 'utf8');
+}

package/dist/commands/shared/date-id.d.ts

@@ -0,0 +1,2 @@
+export declare function yymmdd(isoOrDate: string | Date): string;
+//# sourceMappingURL=date-id.d.ts.map

package/dist/commands/shared/date-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-id.d.ts","sourceRoot":"","sources":["../../../src/commands/shared/date-id.ts"],"names":[],"mappings":"AAAA,wBAAgB,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAavD"}

package/dist/commands/shared/date-id.js

@@ -0,0 +1,10 @@
+export function yymmdd(isoOrDate) {
+    const date = isoOrDate instanceof Date ? new Date(isoOrDate) : new Date(isoOrDate);
+    if (Number.isNaN(date.getTime())) {
+        throw new Error(`Invalid date for OAT identifier: ${String(isoOrDate)}`);
+    }
+    const year = String(date.getUTCFullYear() % 100).padStart(2, '0');
+    const month = String(date.getUTCMonth() + 1).padStart(2, '0');
+    const day = String(date.getUTCDate()).padStart(2, '0');
+    return `${year}${month}${day}`;
+}

package/dist/commands/shared/managed-index.d.ts

@@ -0,0 +1,22 @@
+export interface ManagedIndexUpdate {
+    /**
+     * The full file content to write, or `null` when the existing managed block
+     * is already content-equal to the target (callers must skip the write to
+     * preserve the on-disk bytes, including any external formatter's padding).
+     */
+    content: string | null;
+}
+/**
+ * Compute the content-idempotent result of regenerating a managed index block.
+ *
+ * @param existingContent Current on-disk file content (already known to contain
+ *   the marker pair; bounds are passed in to avoid re-scanning).
+ * @param startIndex Index of the start marker within `existingContent`.
+ * @param endMarkerEnd Index just past the end marker within `existingContent`.
+ * @param renderedBlock Freshly rendered managed block (start marker ... end
+ *   marker) built from the record files.
+ * @returns `{ content: null }` when the logical rows match (skip the write), or
+ *   `{ content: <full file text> }` when the block must be rewritten.
+ */
+export declare function computeManagedIndexUpdate(existingContent: string, startIndex: number, endMarkerEnd: number, renderedBlock: string): ManagedIndexUpdate;
+//# sourceMappingURL=managed-index.d.ts.map

package/dist/commands/shared/managed-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"managed-index.d.ts","sourceRoot":"","sources":["../../../src/commands/shared/managed-index.ts"],"names":[],"mappings":"AA8EA,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CACvC,eAAe,EAAE,MAAM,EACvB,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,GACpB,kBAAkB,CAYpB"}

package/dist/commands/shared/managed-index.js

@@ -0,0 +1,92 @@
+// Shared helper for content-idempotent managed-index regeneration.
+//
+// Managed index files (decision + backlog) contain a CLI-managed block bounded
+// by a start/end marker pair. The block holds a markdown table whose rows are
+// rebuilt from the per-record files on each `regenerate-index` run.
+//
+// External formatters (oxfmt/prettier/etc.) frequently re-pad the table cells
+// to align columns. Without an idempotence gate, the next `regenerate-index`
+// rewrites the formatter's padding back to CLI padding, producing churn and
+// noise in the "resolve a merge conflict by re-running regenerate" story.
+//
+// This helper compares the EXISTING managed block against the freshly rendered
+// target block by their LOGICAL content (each table cell trimmed of surrounding
+// whitespace), ignoring column padding. When the logical content matches it
+// preserves the on-disk bytes verbatim; only a genuine content change (added,
+// removed, reordered, or changed record) triggers a rewrite. It makes no
+// assumptions about any specific formatter.
+// A markdown table delimiter cell (e.g. `---`, `:---`, `:---:`, `-----`).
+// Formatters freely re-pad the dash count, so any delimiter cell normalizes to
+// a single canonical token and dash-width differences never count as a change.
+//
+// Require at least three dashes so the single-`-` data placeholder (the empty
+// cell value rendered by the index formatters, e.g. `| - |`) is NOT collapsed to
+// the delimiter token. A real markdown delimiter cell always has >= 3 dashes
+// (the existing formatter-repad test uses `---` and `-----`), and formatters
+// only ever widen the dash count, never shrink it below three. Without the lower
+// bound, a data cell whose literal value is `-`/`--`/`:-:` would be
+// indistinguishable from a delimiter cell, so a genuine change between two
+// dash-shaped values could be masked as a no-op and the rewrite skipped.
+const DELIMITER_CELL = /^:?-{3,}:?$/;
+function normalizeCell(cell) {
+    const trimmed = cell.trim();
+    return DELIMITER_CELL.test(trimmed) ? '---' : trimmed;
+}
+/**
+ * Parse a managed block's text into a normalized list of rows, where each row
+ * is a list of cells trimmed of surrounding whitespace. The marker lines and
+ * any blank lines are ignored so that formatter-introduced blank lines or
+ * column padding never count as a logical difference.
+ */
+function parseManagedRows(blockText) {
+    return blockText
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .filter((line) => !line.startsWith('<!--'))
+        .map((line) => {
+        // A markdown table row is `| cell | cell | ... |`. Drop the leading and
+        // trailing pipe, then split on unescaped pipes and normalize each cell.
+        const inner = line.replace(/^\|/, '').replace(/\|$/, '');
+        return inner.split('|').map((cell) => normalizeCell(cell));
+    });
+}
+function rowsEqual(a, b) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    for (let rowIndex = 0; rowIndex < a.length; rowIndex += 1) {
+        const rowA = a[rowIndex];
+        const rowB = b[rowIndex];
+        if (rowA.length !== rowB.length) {
+            return false;
+        }
+        for (let cellIndex = 0; cellIndex < rowA.length; cellIndex += 1) {
+            if (rowA[cellIndex] !== rowB[cellIndex]) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+/**
+ * Compute the content-idempotent result of regenerating a managed index block.
+ *
+ * @param existingContent Current on-disk file content (already known to contain
+ *   the marker pair; bounds are passed in to avoid re-scanning).
+ * @param startIndex Index of the start marker within `existingContent`.
+ * @param endMarkerEnd Index just past the end marker within `existingContent`.
+ * @param renderedBlock Freshly rendered managed block (start marker ... end
+ *   marker) built from the record files.
+ * @returns `{ content: null }` when the logical rows match (skip the write), or
+ *   `{ content: <full file text> }` when the block must be rewritten.
+ */
+export function computeManagedIndexUpdate(existingContent, startIndex, endMarkerEnd, renderedBlock) {
+    const existingBlock = existingContent.slice(startIndex, endMarkerEnd);
+    if (rowsEqual(parseManagedRows(existingBlock), parseManagedRows(renderedBlock))) {
+        return { content: null };
+    }
+    const before = existingContent.slice(0, startIndex);
+    const after = existingContent.slice(endMarkerEnd);
+    return { content: `${before}${renderedBlock}${after}` };
+}

package/dist/commands/shared/slug.d.ts

@@ -0,0 +1,2 @@
+export declare function slugify(input: string): string;
+//# sourceMappingURL=slug.d.ts.map

package/dist/commands/shared/slug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slug.d.ts","sourceRoot":"","sources":["../../../src/commands/shared/slug.ts"],"names":[],"mappings":"AAiDA,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAmB7C"}

package/dist/commands/shared/slug.js

@@ -0,0 +1,57 @@
+const MAX_SLUG_LENGTH = 30;
+const STOP_WORDS = new Set([
+    'a',
+    'an',
+    'the',
+    'of',
+    'for',
+    'and',
+    'to',
+    'in',
+    'on',
+    'as',
+    'with',
+]);
+function truncateToWordBoundary(slug) {
+    if (slug.length <= MAX_SLUG_LENGTH) {
+        return slug;
+    }
+    const [first, ...rest] = slug.split('-');
+    const firstWord = first ?? '';
+    // Edge case: the first word alone exceeds the limit. Hard-truncate it.
+    if (firstWord.length > MAX_SLUG_LENGTH) {
+        return firstWord.slice(0, MAX_SLUG_LENGTH);
+    }
+    let result = firstWord;
+    for (const word of rest) {
+        const candidate = `${result}-${word}`;
+        if (candidate.length > MAX_SLUG_LENGTH) {
+            break;
+        }
+        result = candidate;
+    }
+    return result;
+}
+function stripTrailingStopWords(slug) {
+    const words = slug.split('-');
+    while (words.length > 0 && STOP_WORDS.has(words[words.length - 1] ?? '')) {
+        words.pop();
+    }
+    return words.join('-');
+}
+export function slugify(input) {
+    const normalized = input
+        .normalize('NFKD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .toLowerCase();
+    const slug = normalized
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .replace(/-+/g, '-');
+    if (slug.length === 0) {
+        return 'untitled';
+    }
+    const truncated = truncateToWordBoundary(slug);
+    const trimmed = stripTrailingStopWords(truncated);
+    return trimmed || 'untitled';
+}

package/dist/commands/shared/strip-template-frontmatter.d.ts

@@ -0,0 +1,2 @@
+export declare function stripTemplateFrontmatter(content: string): string;
+//# sourceMappingURL=strip-template-frontmatter.d.ts.map

package/dist/commands/shared/strip-template-frontmatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strip-template-frontmatter.d.ts","sourceRoot":"","sources":["../../../src/commands/shared/strip-template-frontmatter.ts"],"names":[],"mappings":"AAAA,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAoBhE"}

package/dist/commands/shared/strip-template-frontmatter.js

@@ -0,0 +1,16 @@
+export function stripTemplateFrontmatter(content) {
+    if (!content.startsWith('---\n')) {
+        return content;
+    }
+    const end = content.indexOf('\n---', 4);
+    if (end === -1) {
+        return content;
+    }
+    const frontmatter = content.slice(4, end);
+    if (!/\boat_template\s*:/i.test(frontmatter) &&
+        !/\boat_template_name\s*:/i.test(frontmatter)) {
+        return content;
+    }
+    const afterFrontmatter = content.slice(end + '\n---'.length);
+    return afterFrontmatter.replace(/^\r?\n+/, '');
+}

package/dist/commands/sync/apply.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"apply.d.ts","sourceRoot":"","sources":["../../../src/commands/sync/apply.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D,OAAO,KAAK,EACV,aAAa,EACb,uBAAuB,EAExB,MAAM,cAAc,CAAC;AAgEtB,wBAAsB,YAAY,CAChC,OAAO,EAAE,cAAc,EACvB,UAAU,EAAE,aAAa,EAAE,EAC3B,YAAY,EAAE,uBAAuB,GACpC,OAAO,CAAC,IAAI,CAAC,CAwEf"}
+{"version":3,"file":"apply.d.ts","sourceRoot":"","sources":["../../../src/commands/sync/apply.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAG3D,OAAO,KAAK,EACV,aAAa,EACb,uBAAuB,EAExB,MAAM,cAAc,CAAC;AAgEtB,wBAAsB,YAAY,CAChC,OAAO,EAAE,cAAc,EACvB,UAAU,EAAE,aAAa,EAAE,EAC3B,YAAY,EAAE,uBAAuB,GACpC,OAAO,CAAC,IAAI,CAAC,CA8Ef"}

package/dist/commands/sync/apply.js

@@ -1,3 +1,4 @@
+import { OAT_VERSION } from '../../shared/oat-version.js';
 import { countPlannedOperations } from './sync.utils.js';
 function countSkippedEntries(scopePlans) {
     return scopePlans.reduce((total, scopePlan) => {
@@ -45,10 +46,13 @@ export async function runSyncApply(context, scopePlans, dependencies) {
     for (const scopePlan of scopePlans) {
         const hasSyncEntries = scopePlan.plan.entries.length > 0 || scopePlan.plan.removals.length > 0;
         const hasCodexPlannedOperations = scopePlan.codexExtensionPlan?.operations.some((operation) => operation.action !== 'skip') ?? false;
-        if (!hasSyncEntries && !hasCodexPlannedOperations) {
+        const shouldRefreshManifestVersion = scopePlan.manifest.oatVersion !== OAT_VERSION;
+        if (!hasSyncEntries &&
+            !hasCodexPlannedOperations &&
+            !shouldRefreshManifestVersion) {
             continue;
         }
-        if (hasSyncEntries) {
+        if (hasSyncEntries || shouldRefreshManifestVersion) {
             const result = await dependencies.executeSyncPlan(scopePlan.plan, scopePlan.manifest, scopePlan.manifestPath);
             applied += result.applied;
             failed += result.failed;

package/dist/manifest/manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../src/manifest/manager.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,aAAa,EAEnB,MAAM,kBAAkB,CAAC;AAa1B,wBAAgB,mBAAmB,IAAI,QAAQ,CAO9C;AAED,wBAAsB,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CA6C1E;AAED,wBAAsB,YAAY,CAChC,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,QAAQ,GACjB,OAAO,CAAC,IAAI,CAAC,CAQf;AAED,wBAAgB,SAAS,CACvB,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,MAAM,GACf,aAAa,GAAG,SAAS,CAK3B;AAED,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,aAAa,GAAG,QAAQ,CAc3E;AAED,wBAAgB,WAAW,CACzB,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,MAAM,GACf,QAAQ,CAeV"}
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../src/manifest/manager.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,aAAa,EAEnB,MAAM,kBAAkB,CAAC;AAa1B,wBAAgB,mBAAmB,IAAI,QAAQ,CAO9C;AAED,wBAAsB,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CA6C1E;AAED,wBAAsB,YAAY,CAChC,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,QAAQ,GACjB,OAAO,CAAC,IAAI,CAAC,CAWf;AAED,wBAAgB,SAAS,CACvB,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,MAAM,GACf,aAAa,GAAG,SAAS,CAK3B;AAED,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,aAAa,GAAG,QAAQ,CAc3E;AAED,wBAAgB,WAAW,CACzB,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,MAAM,GACf,QAAQ,CAeV"}

package/dist/manifest/manager.js

@@ -54,7 +54,10 @@ export async function loadManifest(manifestPath) {
     }
 }
 export async function saveManifest(manifestPath, manifest) {
-    const validated = ManifestSchema.parse(manifest);
+    const validated = ManifestSchema.parse({
+        ...manifest,
+        oatVersion: OAT_VERSION,
+    });
     const dir = dirname(manifestPath);
     const tempPath = `${manifestPath}.${randomUUID()}.tmp`;
     await mkdir(dir, { recursive: true });