@kbdavis07/openspec 1.5.0-nov.1

package/dist/core/parsers/requirement-blocks.d.ts

@@ -0,0 +1,48 @@
+export interface RequirementBlock {
+    headerLine: string;
+    name: string;
+    raw: string;
+}
+export interface RequirementsSectionParts {
+    before: string;
+    headerLine: string;
+    preamble: string;
+    bodyBlocks: RequirementBlock[];
+    after: string;
+}
+export declare function normalizeRequirementName(name: string): string;
+/**
+ * Extracts the Requirements section from a spec file and parses requirement blocks.
+ */
+export declare function extractRequirementsSection(content: string): RequirementsSectionParts;
+/**
+ * A level-3 header inside `## ADDED`/`## MODIFIED Requirements` that is not a
+ * canonical `### Requirement:` header, recorded at the moment the delta reader
+ * skips over it. Surfaced as an INFO note by `validate <change>` (#498).
+ */
+export interface SkippedHeader {
+    header: string;
+    section: string;
+    line: number;
+}
+export interface DeltaPlan {
+    added: RequirementBlock[];
+    modified: RequirementBlock[];
+    removed: string[];
+    renamed: Array<{
+        from: string;
+        to: string;
+    }>;
+    skippedHeaders: SkippedHeader[];
+    sectionPresence: {
+        added: boolean;
+        modified: boolean;
+        removed: boolean;
+        renamed: boolean;
+    };
+}
+/**
+ * Parse a delta-formatted spec change file content into a DeltaPlan with raw blocks.
+ */
+export declare function parseDeltaSpec(content: string): DeltaPlan;
+//# sourceMappingURL=requirement-blocks.d.ts.map

package/dist/core/parsers/requirement-blocks.js

@@ -0,0 +1,235 @@
+import { buildCodeFenceMask } from './requirement-text.js';
+export function normalizeRequirementName(name) {
+    return name.trim();
+}
+/** The canonical requirement header the delta reader recognizes. */
+const REQUIREMENT_HEADER_REGEX = /^###\s*Requirement:\s*(.+)\s*$/i;
+/**
+ * Extracts the Requirements section from a spec file and parses requirement blocks.
+ */
+export function extractRequirementsSection(content) {
+    const normalized = normalizeLineEndings(content);
+    const lines = normalized.split('\n');
+    const reqHeaderIndex = lines.findIndex(l => /^##\s+Requirements\s*$/i.test(l));
+    if (reqHeaderIndex === -1) {
+        // No requirements section; create an empty one at the end
+        const before = content.trimEnd();
+        const headerLine = '## Requirements';
+        return {
+            before: before ? before + '\n\n' : '',
+            headerLine,
+            preamble: '',
+            bodyBlocks: [],
+            after: '\n',
+        };
+    }
+    // Find end of this section: next line that starts with '## ' at same or higher level
+    let endIndex = lines.length;
+    for (let i = reqHeaderIndex + 1; i < lines.length; i++) {
+        if (/^##\s+/.test(lines[i])) {
+            endIndex = i;
+            break;
+        }
+    }
+    const before = lines.slice(0, reqHeaderIndex).join('\n');
+    const headerLine = lines[reqHeaderIndex];
+    const sectionBodyLines = lines.slice(reqHeaderIndex + 1, endIndex);
+    // Parse requirement blocks within section body
+    const blocks = [];
+    let cursor = 0;
+    let preambleLines = [];
+    // Collect preamble lines until first requirement header
+    while (cursor < sectionBodyLines.length && !REQUIREMENT_HEADER_REGEX.test(sectionBodyLines[cursor])) {
+        preambleLines.push(sectionBodyLines[cursor]);
+        cursor++;
+    }
+    while (cursor < sectionBodyLines.length) {
+        const headerStart = cursor;
+        const headerLineCandidate = sectionBodyLines[cursor];
+        const headerMatch = headerLineCandidate.match(REQUIREMENT_HEADER_REGEX);
+        if (!headerMatch) {
+            // Not a requirement header; skip line defensively
+            cursor++;
+            continue;
+        }
+        const name = normalizeRequirementName(headerMatch[1]);
+        cursor++;
+        // Gather lines until next requirement header or end of section
+        const bodyLines = [headerLineCandidate];
+        while (cursor < sectionBodyLines.length && !REQUIREMENT_HEADER_REGEX.test(sectionBodyLines[cursor]) && !/^##\s+/.test(sectionBodyLines[cursor])) {
+            bodyLines.push(sectionBodyLines[cursor]);
+            cursor++;
+        }
+        const raw = bodyLines.join('\n').trimEnd();
+        blocks.push({ headerLine: headerLineCandidate, name, raw });
+    }
+    const after = lines.slice(endIndex).join('\n');
+    const preamble = preambleLines.join('\n').trimEnd();
+    return {
+        before: before.trimEnd() ? before + '\n' : before,
+        headerLine,
+        preamble,
+        bodyBlocks: blocks,
+        after: after.startsWith('\n') ? after : '\n' + after,
+    };
+}
+function normalizeLineEndings(content) {
+    return content.replace(/\r\n?/g, '\n');
+}
+/**
+ * Parse a delta-formatted spec change file content into a DeltaPlan with raw blocks.
+ */
+export function parseDeltaSpec(content) {
+    const normalized = normalizeLineEndings(content);
+    const sections = splitTopLevelSections(normalized);
+    const addedLookup = getSectionCaseInsensitive(sections, 'ADDED Requirements');
+    const modifiedLookup = getSectionCaseInsensitive(sections, 'MODIFIED Requirements');
+    const removedLookup = getSectionCaseInsensitive(sections, 'REMOVED Requirements');
+    const renamedLookup = getSectionCaseInsensitive(sections, 'RENAMED Requirements');
+    const skippedHeaders = [];
+    const added = parseRequirementBlocksFromSection(addedLookup.body, {
+        section: addedLookup.title,
+        bodyStartLine: addedLookup.bodyStartLine,
+        sink: skippedHeaders,
+    });
+    const modified = parseRequirementBlocksFromSection(modifiedLookup.body, {
+        section: modifiedLookup.title,
+        bodyStartLine: modifiedLookup.bodyStartLine,
+        sink: skippedHeaders,
+    });
+    const removedNames = parseRemovedNames(removedLookup.body);
+    const renamedPairs = parseRenamedPairs(renamedLookup.body);
+    skippedHeaders.sort((a, b) => a.line - b.line);
+    return {
+        added,
+        modified,
+        removed: removedNames,
+        renamed: renamedPairs,
+        skippedHeaders,
+        sectionPresence: {
+            added: addedLookup.found,
+            modified: modifiedLookup.found,
+            removed: removedLookup.found,
+            renamed: renamedLookup.found,
+        },
+    };
+}
+function splitTopLevelSections(content) {
+    const lines = content.split('\n');
+    const result = {};
+    const indices = [];
+    for (let i = 0; i < lines.length; i++) {
+        const m = lines[i].match(/^(##)\s+(.+)$/);
+        if (m) {
+            const level = m[1].length; // only care for '##'
+            indices.push({ title: m[2].trim(), index: i, level });
+        }
+    }
+    for (let i = 0; i < indices.length; i++) {
+        const current = indices[i];
+        const next = indices[i + 1];
+        const body = lines.slice(current.index + 1, next ? next.index : lines.length).join('\n');
+        // First body line, 1-based: the header is at 0-based current.index.
+        result[current.title] = { body, bodyStartLine: current.index + 2 };
+    }
+    return result;
+}
+function getSectionCaseInsensitive(sections, desired) {
+    const target = desired.toLowerCase();
+    for (const [title, { body, bodyStartLine }] of Object.entries(sections)) {
+        if (title.toLowerCase() === target)
+            return { title, body, bodyStartLine, found: true };
+    }
+    return { title: desired, body: '', bodyStartLine: 0, found: false };
+}
+function parseRequirementBlocksFromSection(sectionBody, skipped) {
+    if (!sectionBody)
+        return [];
+    const lines = normalizeLineEndings(sectionBody).split('\n');
+    // Record the non-canonical level-3 headers this reader skips, at the moment
+    // it skips them, so the INFO note describes the reader's real boundaries.
+    // Fence-masked lines are excluded: the body reader treats them as fenced
+    // content, not as headers.
+    const fenceMask = skipped ? buildCodeFenceMask(lines) : undefined;
+    const recordIfSkippedHeader = (index) => {
+        if (!skipped || fenceMask[index])
+            return;
+        const h3 = lines[index].match(/^###\s+(.+?)\s*$/);
+        if (h3 && !REQUIREMENT_HEADER_REGEX.test(lines[index])) {
+            skipped.sink.push({
+                header: h3[1].trim(),
+                section: skipped.section,
+                line: skipped.bodyStartLine + index,
+            });
+        }
+    };
+    const blocks = [];
+    let i = 0;
+    while (i < lines.length) {
+        // Seek next requirement header
+        while (i < lines.length && !REQUIREMENT_HEADER_REGEX.test(lines[i])) {
+            recordIfSkippedHeader(i);
+            i++;
+        }
+        if (i >= lines.length)
+            break;
+        const headerLine = lines[i];
+        const m = headerLine.match(REQUIREMENT_HEADER_REGEX);
+        if (!m) {
+            i++;
+            continue;
+        }
+        const name = normalizeRequirementName(m[1]);
+        const buf = [headerLine];
+        i++;
+        while (i < lines.length && !REQUIREMENT_HEADER_REGEX.test(lines[i]) && !/^##\s+/.test(lines[i])) {
+            recordIfSkippedHeader(i);
+            buf.push(lines[i]);
+            i++;
+        }
+        blocks.push({ headerLine, name, raw: buf.join('\n').trimEnd() });
+    }
+    return blocks;
+}
+function parseRemovedNames(sectionBody) {
+    if (!sectionBody)
+        return [];
+    const names = [];
+    const lines = normalizeLineEndings(sectionBody).split('\n');
+    for (const line of lines) {
+        const m = line.match(REQUIREMENT_HEADER_REGEX);
+        if (m) {
+            names.push(normalizeRequirementName(m[1]));
+            continue;
+        }
+        // Also support bullet list of headers
+        const bullet = line.match(/^\s*-\s*`?###\s*Requirement:\s*(.+?)`?\s*$/);
+        if (bullet) {
+            names.push(normalizeRequirementName(bullet[1]));
+        }
+    }
+    return names;
+}
+function parseRenamedPairs(sectionBody) {
+    if (!sectionBody)
+        return [];
+    const pairs = [];
+    const lines = normalizeLineEndings(sectionBody).split('\n');
+    let current = {};
+    for (const line of lines) {
+        const fromMatch = line.match(/^\s*-?\s*FROM:\s*`?###\s*Requirement:\s*(.+?)`?\s*$/);
+        const toMatch = line.match(/^\s*-?\s*TO:\s*`?###\s*Requirement:\s*(.+?)`?\s*$/);
+        if (fromMatch) {
+            current.from = normalizeRequirementName(fromMatch[1]);
+        }
+        else if (toMatch) {
+            current.to = normalizeRequirementName(toMatch[1]);
+            if (current.from && current.to) {
+                pairs.push({ from: current.from, to: current.to });
+                current = {};
+            }
+        }
+    }
+    return pairs;
+}
+//# sourceMappingURL=requirement-blocks.js.map

package/dist/core/parsers/requirement-text.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Shared, fence-aware requirement-reading helpers.
+ *
+ * The requirement reader used to be implemented twice — once for main specs
+ * (`MarkdownParser.parseRequirements`) and once for change deltas
+ * (`Validator.extractRequirementText` / `countScenarios`) — and the two drifted
+ * apart. These helpers are the single source of truth for requirement-body
+ * extraction, scenario counting, and `SHALL`/`MUST` detection in
+ * `validate <change>`, `validate <spec>`, and `archive`.
+ */
+/**
+ * Build a per-line mask marking lines that fall inside a fenced code block
+ * (``` ``` ``` or ``` ~~~ ```), including the fence lines themselves. Mirrors the
+ * fence rules markdown uses: a fence opens on the first ```` ```/~~~ ```` of
+ * length >= 3 and closes on a line of the same marker whose length is >= the
+ * opening length, with nothing but whitespace after it.
+ */
+export declare function buildCodeFenceMask(lines: string[]): boolean[];
+/**
+ * The one predicate for normative-keyword detection. Matches `SHALL` or `MUST`
+ * as whole words so the change-delta reader and the schema-based reader accept
+ * and reject identical text.
+ */
+export declare function containsShallOrMust(text: string): boolean;
+/**
+ * Extract the full requirement body from the lines that follow a
+ * `### Requirement:` header (the lines may include scenarios and fenced code).
+ *
+ * Captures every body line from the start up to the first header found on a
+ * non-fenced line — usually the first `#### Scenario:`, but also a stray `###`
+ * divider the delta reader absorbed into the block — skipping blank lines and
+ * any line inside a fenced code block. `**metadata**:` lines are skipped only
+ * when other body text remains: a requirement written entirely as
+ * `**Constraint**: The system MUST ...` keeps that line as its body. Captured
+ * lines are trimmed and joined with newlines so a requirement whose text wraps
+ * across lines — or whose `SHALL`/`MUST` lands on a later line — is read in
+ * full.
+ */
+export declare function extractRequirementBody(bodyLines: string[]): string;
+/**
+ * Parser/display fallback for a requirement block with no body text. This is
+ * what lets a bare `### The system SHALL ...` header remain readable on the
+ * spec path (the title is the requirement). Validator body-keyword checks for
+ * canonical `### Requirement:` blocks use `extractRequirementBody` directly so
+ * a keyword that appears only in the header still receives the #1156/#1280
+ * body-keyword hint.
+ */
+export declare function extractRequirementText(headerTitle: string, bodyLines: string[]): string;
+/**
+ * Count the real scenarios in a requirement block: `#### ` headers on non-fenced
+ * lines. A `#### Scenario:` that lives inside a fenced example is not a real
+ * scenario and is not counted.
+ */
+export declare function countScenarios(bodyLines: string[]): number;
+//# sourceMappingURL=requirement-text.d.ts.map

package/dist/core/parsers/requirement-text.js

@@ -0,0 +1,136 @@
+/**
+ * Shared, fence-aware requirement-reading helpers.
+ *
+ * The requirement reader used to be implemented twice — once for main specs
+ * (`MarkdownParser.parseRequirements`) and once for change deltas
+ * (`Validator.extractRequirementText` / `countScenarios`) — and the two drifted
+ * apart. These helpers are the single source of truth for requirement-body
+ * extraction, scenario counting, and `SHALL`/`MUST` detection in
+ * `validate <change>`, `validate <spec>`, and `archive`.
+ */
+/**
+ * Build a per-line mask marking lines that fall inside a fenced code block
+ * (``` ``` ``` or ``` ~~~ ```), including the fence lines themselves. Mirrors the
+ * fence rules markdown uses: a fence opens on the first ```` ```/~~~ ```` of
+ * length >= 3 and closes on a line of the same marker whose length is >= the
+ * opening length, with nothing but whitespace after it.
+ */
+export function buildCodeFenceMask(lines) {
+    const mask = new Array(lines.length).fill(false);
+    let activeFence = null;
+    for (let i = 0; i < lines.length; i++) {
+        const fence = getFenceMarker(lines[i]);
+        if (!activeFence) {
+            if (fence) {
+                activeFence = fence;
+                mask[i] = true;
+            }
+            continue;
+        }
+        mask[i] = true;
+        if (isClosingFence(lines[i], activeFence)) {
+            activeFence = null;
+        }
+    }
+    return mask;
+}
+function getFenceMarker(line) {
+    const fenceMatch = line.match(/^\s*(`{3,}|~{3,})/);
+    if (!fenceMatch) {
+        return null;
+    }
+    return {
+        marker: fenceMatch[1][0],
+        length: fenceMatch[1].length,
+    };
+}
+function isClosingFence(line, activeFence) {
+    const fenceMatch = line.match(/^\s*(`{3,}|~{3,})\s*$/);
+    return Boolean(fenceMatch &&
+        fenceMatch[1][0] === activeFence.marker &&
+        fenceMatch[1].length >= activeFence.length);
+}
+/** Lines that look like `**ID**: ...` / `**Priority**: ...` metadata. */
+const METADATA_LINE = /^\*\*[^*]+\*\*:/;
+/** Any markdown header line — the boundary where a requirement body ends. */
+const HEADER_LINE = /^#{1,6}\s/;
+/**
+ * A level-4 header. Deliberately matches ANY `####` header, not only
+ * `#### Scenario:` — the spec path treats every level-4 child of a requirement
+ * as a scenario, so the delta counter must too (parity). Don't tighten this to
+ * `Scenario:` without changing both paths together.
+ */
+const SCENARIO_HEADER = /^####\s+/;
+/**
+ * The one predicate for normative-keyword detection. Matches `SHALL` or `MUST`
+ * as whole words so the change-delta reader and the schema-based reader accept
+ * and reject identical text.
+ */
+export function containsShallOrMust(text) {
+    return /\b(SHALL|MUST)\b/.test(text);
+}
+/**
+ * Extract the full requirement body from the lines that follow a
+ * `### Requirement:` header (the lines may include scenarios and fenced code).
+ *
+ * Captures every body line from the start up to the first header found on a
+ * non-fenced line — usually the first `#### Scenario:`, but also a stray `###`
+ * divider the delta reader absorbed into the block — skipping blank lines and
+ * any line inside a fenced code block. `**metadata**:` lines are skipped only
+ * when other body text remains: a requirement written entirely as
+ * `**Constraint**: The system MUST ...` keeps that line as its body. Captured
+ * lines are trimmed and joined with newlines so a requirement whose text wraps
+ * across lines — or whose `SHALL`/`MUST` lands on a later line — is read in
+ * full.
+ */
+export function extractRequirementBody(bodyLines) {
+    const mask = buildCodeFenceMask(bodyLines);
+    const captured = [];
+    const metadata = [];
+    for (let i = 0; i < bodyLines.length; i++) {
+        if (mask[i])
+            continue; // inside a fenced code block
+        const line = bodyLines[i];
+        if (HEADER_LINE.test(line))
+            break; // first scenario or stray divider
+        const trimmed = line.trim();
+        if (trimmed.length === 0)
+            continue; // blank
+        if (METADATA_LINE.test(trimmed)) {
+            metadata.push(trimmed); // **ID**: / **Priority**: ...
+            continue;
+        }
+        captured.push(trimmed);
+    }
+    if (captured.length > 0)
+        return captured.join('\n');
+    return metadata.join('\n'); // metadata-only body: the metadata IS the body
+}
+/**
+ * Parser/display fallback for a requirement block with no body text. This is
+ * what lets a bare `### The system SHALL ...` header remain readable on the
+ * spec path (the title is the requirement). Validator body-keyword checks for
+ * canonical `### Requirement:` blocks use `extractRequirementBody` directly so
+ * a keyword that appears only in the header still receives the #1156/#1280
+ * body-keyword hint.
+ */
+export function extractRequirementText(headerTitle, bodyLines) {
+    return extractRequirementBody(bodyLines) || headerTitle.trim();
+}
+/**
+ * Count the real scenarios in a requirement block: `#### ` headers on non-fenced
+ * lines. A `#### Scenario:` that lives inside a fenced example is not a real
+ * scenario and is not counted.
+ */
+export function countScenarios(bodyLines) {
+    const mask = buildCodeFenceMask(bodyLines);
+    let count = 0;
+    for (let i = 0; i < bodyLines.length; i++) {
+        if (mask[i])
+            continue;
+        if (SCENARIO_HEADER.test(bodyLines[i]))
+            count++;
+    }
+    return count;
+}
+//# sourceMappingURL=requirement-text.js.map

package/dist/core/parsers/spec-structure.d.ts

@@ -0,0 +1,9 @@
+export interface MainSpecStructureIssue {
+    kind: 'delta-header' | 'requirement-outside-requirements';
+    line: number;
+    header: string;
+    message: string;
+}
+export declare function findMainSpecStructureIssues(content: string): MainSpecStructureIssue[];
+export declare function stripFencedCodeBlocksPreservingLines(content: string): string;
+//# sourceMappingURL=spec-structure.d.ts.map

package/dist/core/parsers/spec-structure.js

@@ -0,0 +1,88 @@
+const REQUIREMENTS_SECTION_HEADER = /^##\s+Requirements\s*$/i;
+const TOP_LEVEL_SECTION_HEADER = /^##\s+/;
+const DELTA_HEADER = /^##\s+(ADDED|MODIFIED|REMOVED|RENAMED)\s+Requirements\s*$/i;
+const REQUIREMENT_HEADER = /^###\s+Requirement:\s*(.+)\s*$/i;
+export function findMainSpecStructureIssues(content) {
+    const normalized = content.replace(/\r\n?/g, '\n');
+    const stripped = stripFencedCodeBlocksPreservingLines(normalized);
+    const lines = stripped.split('\n');
+    const issues = [];
+    const requirementsHeaderIndex = lines.findIndex(line => REQUIREMENTS_SECTION_HEADER.test(line));
+    let requirementsEndIndex = lines.length;
+    if (requirementsHeaderIndex !== -1) {
+        for (let i = requirementsHeaderIndex + 1; i < lines.length; i++) {
+            if (TOP_LEVEL_SECTION_HEADER.test(lines[i])) {
+                requirementsEndIndex = i;
+                break;
+            }
+        }
+    }
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        if (!trimmed) {
+            continue;
+        }
+        if (DELTA_HEADER.test(line)) {
+            issues.push({
+                kind: 'delta-header',
+                line: i + 1,
+                header: trimmed,
+                message: `Main spec contains delta header "${trimmed}". ` +
+                    'Delta headers are only valid inside openspec/changes/<name>/specs/<capability>/spec.md ' +
+                    'and truncate the parsed ## Requirements section.',
+            });
+            continue;
+        }
+        const requirementMatch = line.match(REQUIREMENT_HEADER);
+        if (!requirementMatch) {
+            continue;
+        }
+        const insideRequirements = requirementsHeaderIndex !== -1 &&
+            i > requirementsHeaderIndex &&
+            i < requirementsEndIndex;
+        if (!insideRequirements) {
+            issues.push({
+                kind: 'requirement-outside-requirements',
+                line: i + 1,
+                header: trimmed,
+                message: `Requirement header "${trimmed}" appears outside the main ## Requirements section. ` +
+                    'Main specs only parse requirements inside that section, so this requirement is currently invisible to validate, list, and archive.',
+            });
+        }
+    }
+    return issues;
+}
+export function stripFencedCodeBlocksPreservingLines(content) {
+    const lines = content.split('\n');
+    const output = [];
+    let activeFence = null;
+    for (const line of lines) {
+        const fenceMatch = line.match(/^\s*(`{3,}|~{3,})(.*)$/);
+        if (!activeFence) {
+            if (fenceMatch) {
+                activeFence = {
+                    marker: fenceMatch[1][0],
+                    length: fenceMatch[1].length,
+                };
+                output.push('');
+            }
+            else {
+                output.push(line);
+            }
+            continue;
+        }
+        output.push('');
+        if (isClosingFence(line, activeFence)) {
+            activeFence = null;
+        }
+    }
+    return output.join('\n');
+}
+function isClosingFence(line, activeFence) {
+    const fenceMatch = line.match(/^\s*(`{3,}|~{3,})\s*$/);
+    return Boolean(fenceMatch &&
+        fenceMatch[1][0] === activeFence.marker &&
+        fenceMatch[1].length >= activeFence.length);
+}
+//# sourceMappingURL=spec-structure.js.map

package/dist/core/planning-home.d.ts

@@ -0,0 +1,16 @@
+export type PlanningHomeKind = 'repo';
+export interface PlanningHome {
+    kind: PlanningHomeKind;
+    root: string;
+    changesDir: string;
+    defaultSchema: string;
+}
+export interface ResolvePlanningHomeOptions {
+    startPath?: string;
+    allowImplicitRepoRoot?: boolean;
+}
+export declare function findRepoPlanningRootSync(startPath?: string): string | null;
+export declare function resolveCurrentPlanningHomeSync(options?: ResolvePlanningHomeOptions): PlanningHome;
+export declare function getChangeDir(planningHome: PlanningHome, changeName: string): string;
+export declare function formatChangeLocation(planningHome: PlanningHome, changeName: string): string;
+//# sourceMappingURL=planning-home.d.ts.map

package/dist/core/planning-home.js

@@ -0,0 +1,67 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { FileSystemUtils } from '../utils/file-system.js';
+const REPO_DEFAULT_SCHEMA = 'spec-driven';
+function pathExistsAsDirectory(candidatePath) {
+    try {
+        return fs.statSync(candidatePath).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function getSearchStartDirectory(startPath) {
+    const resolved = path.resolve(startPath);
+    try {
+        const stats = fs.statSync(resolved);
+        const searchStart = stats.isDirectory() ? resolved : path.dirname(resolved);
+        return FileSystemUtils.canonicalizeExistingPath(searchStart);
+    }
+    catch {
+        return resolved;
+    }
+}
+function findNearestAncestor(startPath, predicate) {
+    let currentDir = getSearchStartDirectory(startPath);
+    while (true) {
+        if (predicate(currentDir)) {
+            return FileSystemUtils.canonicalizeExistingPath(currentDir);
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            return null;
+        }
+        currentDir = parentDir;
+    }
+}
+export function findRepoPlanningRootSync(startPath = process.cwd()) {
+    return findNearestAncestor(startPath, (dirPath) => pathExistsAsDirectory(path.join(dirPath, 'openspec')));
+}
+function repoPlanningHome(repoRoot) {
+    return {
+        kind: 'repo',
+        root: repoRoot,
+        changesDir: path.join(repoRoot, 'openspec', 'changes'),
+        defaultSchema: REPO_DEFAULT_SCHEMA,
+    };
+}
+export function resolveCurrentPlanningHomeSync(options = {}) {
+    const startPath = options.startPath ?? process.cwd();
+    const searchStart = getSearchStartDirectory(startPath);
+    const repoRoot = findRepoPlanningRootSync(searchStart);
+    if (repoRoot) {
+        return repoPlanningHome(repoRoot);
+    }
+    if (options.allowImplicitRepoRoot === false) {
+        throw new Error('No OpenSpec planning home found from the current directory.');
+    }
+    return repoPlanningHome(FileSystemUtils.canonicalizeExistingPath(searchStart));
+}
+export function getChangeDir(planningHome, changeName) {
+    return FileSystemUtils.joinPath(planningHome.changesDir, changeName);
+}
+export function formatChangeLocation(planningHome, changeName) {
+    // Repo homes always nest changesDir under the root.
+    return path.relative(planningHome.root, getChangeDir(planningHome, changeName));
+}
+//# sourceMappingURL=planning-home.js.map