@fission-ai/openspec 1.3.0 → 1.4.0

package/dist/core/context-store/registry.js

@@ -0,0 +1,229 @@
+import * as fs from 'node:fs/promises';
+import { getContextStoreMetadataPath, getContextStoreMetadataDir, listContextStoreRegistryEntries, readContextStoreRegistryState, readOptionalContextStoreMetadataState, resolveGitContextStoreBackendConfig, updateContextStoreRegistryState, validateContextStoreId, writeContextStoreMetadataState, } from './foundation.js';
+import { ContextStoreError } from './errors.js';
+import { FileSystemUtils } from '../../utils/file-system.js';
+export function getStoreRootForBackend(backend) {
+    switch (backend.type) {
+        case 'git':
+            return backend.local_path;
+    }
+}
+function normalizePathForComparison(targetPath) {
+    try {
+        return FileSystemUtils.canonicalizeExistingPath(targetPath);
+    }
+    catch {
+        return targetPath;
+    }
+}
+export function assertNoRegisteredStoreConflict(registry, id, backend) {
+    const nextPath = normalizePathForComparison(getStoreRootForBackend(backend));
+    for (const entry of listContextStoreRegistryEntries(registry ?? { version: 1, stores: {} })) {
+        const entryPath = normalizePathForComparison(getStoreRootForBackend(entry.backend));
+        if (entry.id === id && entryPath === nextPath) {
+            continue;
+        }
+        if (entry.id === id) {
+            throw new ContextStoreError(`Context store '${id}' is already registered at ${getStoreRootForBackend(entry.backend)}.`, 'context_store_id_conflict', {
+                target: 'context_store.id',
+                fix: 'Use the existing registration or choose a different context store id.',
+            });
+        }
+        if (entryPath === nextPath) {
+            throw new ContextStoreError(`Context store path is already registered as '${entry.id}'.`, 'context_store_path_conflict', {
+                target: 'context_store.root',
+                fix: `Use the existing '${entry.id}' registration or choose a different path.`,
+            });
+        }
+    }
+}
+function withRegisteredStore(registry, id, backend) {
+    assertNoRegisteredStoreConflict(registry, id, backend);
+    const stores = {
+        ...(registry?.stores ?? {}),
+        [id]: {
+            backend,
+        },
+    };
+    return {
+        version: 1,
+        stores: Object.fromEntries(Object.entries(stores).sort(([leftId], [rightId]) => leftId.localeCompare(rightId))),
+    };
+}
+function getRegisteredStoreOrThrow(registry, id) {
+    const entry = registry?.stores[id];
+    if (!entry) {
+        throw new ContextStoreError(`Unknown context store '${id}'`, 'context_store_not_found', {
+            target: 'context_store.id',
+            fix: 'Run openspec context-store list to see registered stores.',
+        });
+    }
+    return {
+        id,
+        backend: entry.backend,
+    };
+}
+function contextStoreBackendsMatch(actual, expected) {
+    return (actual.type === expected.type &&
+        normalizePathForComparison(actual.local_path) ===
+            normalizePathForComparison(expected.local_path) &&
+        actual.remote === expected.remote &&
+        actual.branch === expected.branch);
+}
+function assertExpectedRegisteredBackend(id, actual, expected) {
+    if (!expected || contextStoreBackendsMatch(actual, expected))
+        return;
+    throw new ContextStoreError(`Context store '${id}' changed before cleanup completed.`, 'context_store_registry_changed', {
+        target: 'context_store.registry',
+        fix: 'Retry the cleanup command after reviewing the current context-store registration.',
+    });
+}
+function withoutRegisteredStore(registry, id, expectedBackend) {
+    const removed = getRegisteredStoreOrThrow(registry, id);
+    assertExpectedRegisteredBackend(id, removed.backend, expectedBackend);
+    const stores = { ...(registry?.stores ?? {}) };
+    delete stores[id];
+    return {
+        removed,
+        next: {
+            version: 1,
+            stores: Object.fromEntries(Object.entries(stores).sort(([leftId], [rightId]) => leftId.localeCompare(rightId))),
+        },
+    };
+}
+async function ensureStoreMetadata(storeRoot, id, options) {
+    const metadata = await readOptionalContextStoreMetadataState(storeRoot);
+    if (!metadata) {
+        if (!options.writeIfMissing) {
+            throw new ContextStoreError(`Registered context store '${id}' is missing metadata at ${getContextStoreMetadataPath(storeRoot)}`, 'context_store_metadata_missing', {
+                target: 'context_store.metadata',
+                fix: `Create ${getContextStoreMetadataPath(storeRoot)} or rerun context-store register.`,
+            });
+        }
+        await writeContextStoreMetadataState(storeRoot, {
+            version: 1,
+            id,
+        });
+        return true;
+    }
+    if (metadata.id !== id) {
+        throw new ContextStoreError(`Context store metadata id '${metadata.id}' does not match registered id '${id}'`, 'context_store_metadata_id_mismatch', {
+            target: 'context_store.metadata',
+            fix: 'Repair the local registry or store metadata so the ids match.',
+        });
+    }
+    return false;
+}
+export async function commitContextStoreRegistration(input) {
+    const id = validateContextStoreId(input.id);
+    const backend = input.backend;
+    const storeRoot = getStoreRootForBackend(backend);
+    let metadataCreated = false;
+    try {
+        metadataCreated = await ensureStoreMetadata(storeRoot, id, {
+            writeIfMissing: input.writeMetadataIfMissing,
+        });
+        await updateContextStoreRegistryState((registry) => withRegisteredStore(registry, id, backend), { globalDataDir: input.globalDataDir });
+    }
+    catch (error) {
+        if (metadataCreated) {
+            await fs.rm(getContextStoreMetadataPath(storeRoot), { force: true });
+            await fs.rmdir(getContextStoreMetadataDir(storeRoot)).catch(() => undefined);
+        }
+        throw error;
+    }
+    return {
+        id,
+        storeRoot,
+        backend,
+        metadataCreated,
+    };
+}
+export async function registerContextStore(input) {
+    const id = validateContextStoreId(input.id);
+    const backend = await resolveGitContextStoreBackendConfig({
+        localPath: input.localPath,
+        ...(input.remote !== undefined ? { remote: input.remote } : {}),
+        ...(input.branch !== undefined ? { branch: input.branch } : {}),
+    }, input.cwd);
+    const storeRoot = getStoreRootForBackend(backend);
+    const committed = await commitContextStoreRegistration({
+        id,
+        backend,
+        writeMetadataIfMissing: true,
+        ...(input.globalDataDir ? { globalDataDir: input.globalDataDir } : {}),
+    });
+    return {
+        id: committed.id,
+        storeRoot: committed.storeRoot,
+        backend: committed.backend,
+    };
+}
+export async function listRegisteredContextStores(options = {}) {
+    const registry = await readContextStoreRegistryState(options);
+    if (!registry) {
+        return [];
+    }
+    return listContextStoreRegistryEntries(registry).map((entry) => ({
+        ...entry,
+        storeRoot: getStoreRootForBackend(entry.backend),
+    }));
+}
+export async function getRegisteredContextStore(input) {
+    const id = validateContextStoreId(input.id);
+    const registry = await readContextStoreRegistryState({
+        globalDataDir: input.globalDataDir,
+    });
+    const entry = getRegisteredStoreOrThrow(registry, id);
+    assertExpectedRegisteredBackend(id, entry.backend, input.expectedBackend);
+    return {
+        ...entry,
+        storeRoot: getStoreRootForBackend(entry.backend),
+    };
+}
+export async function unregisterContextStoreRegistration(input) {
+    const id = validateContextStoreId(input.id);
+    let removed;
+    await updateContextStoreRegistryState(async (registry) => {
+        const result = withoutRegisteredStore(registry, id, input.expectedBackend);
+        const removedEntry = {
+            ...result.removed,
+            storeRoot: getStoreRootForBackend(result.removed.backend),
+        };
+        await input.beforeCommit?.(removedEntry);
+        removed = result.removed;
+        return result.next;
+    }, { globalDataDir: input.globalDataDir });
+    if (!removed) {
+        throw new ContextStoreError(`Unknown context store '${id}'`, 'context_store_not_found', {
+            target: 'context_store.id',
+            fix: 'Run openspec context-store list to see registered stores.',
+        });
+    }
+    return {
+        ...removed,
+        storeRoot: getStoreRootForBackend(removed.backend),
+    };
+}
+export async function resolveRegisteredContextStore(input) {
+    const id = validateContextStoreId(input.id);
+    const registry = await readContextStoreRegistryState({
+        globalDataDir: input.globalDataDir,
+    });
+    if (!registry) {
+        throw new ContextStoreError('No context store registry found', 'no_context_store_registry', {
+            target: 'context_store.id',
+            fix: 'Register a context store before using --store, or pass --store-path <path>.',
+        });
+    }
+    const entry = getRegisteredStoreOrThrow(registry, id);
+    const backend = entry.backend;
+    const storeRoot = getStoreRootForBackend(backend);
+    await ensureStoreMetadata(storeRoot, id, { writeIfMissing: false });
+    return {
+        id,
+        storeRoot,
+        backend,
+    };
+}
+//# sourceMappingURL=registry.js.map

package/dist/core/global-config.d.ts

@@ -25,7 +25,12 @@ export declare function getGlobalConfigDir(): string;
  * - Unix/macOS fallback: ~/.local/share/openspec/
  * - Windows fallback: %LOCALAPPDATA%/openspec/
  */
-export declare function getGlobalDataDir(): string;
+export interface GlobalDataDirOptions {
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    homedir?: string;
+}
+export declare function getGlobalDataDir(options?: GlobalDataDirOptions): string;
 /**
  * Gets the path to the global config file.
  */

package/dist/core/global-config.js

@@ -36,32 +36,31 @@ export function getGlobalConfigDir() {
     // Unix/macOS fallback: ~/.config
     return path.join(os.homedir(), '.config', GLOBAL_CONFIG_DIR_NAME);
 }
-/**
- * Gets the global data directory path following XDG Base Directory Specification.
- * Used for user data like schema overrides.
- *
- * - All platforms: $XDG_DATA_HOME/openspec/ if XDG_DATA_HOME is set
- * - Unix/macOS fallback: ~/.local/share/openspec/
- * - Windows fallback: %LOCALAPPDATA%/openspec/
- */
-export function getGlobalDataDir() {
+function joinGlobalDataPath(platform, ...segments) {
+    return platform === 'win32'
+        ? path.win32.join(...segments)
+        : path.posix.join(...segments);
+}
+export function getGlobalDataDir(options = {}) {
+    const env = options.env ?? process.env;
+    const platform = options.platform ?? os.platform();
     // XDG_DATA_HOME takes precedence on all platforms when explicitly set
-    const xdgDataHome = process.env.XDG_DATA_HOME;
+    const xdgDataHome = env.XDG_DATA_HOME;
     if (xdgDataHome) {
-        return path.join(xdgDataHome, GLOBAL_DATA_DIR_NAME);
+        return joinGlobalDataPath(platform, xdgDataHome, GLOBAL_DATA_DIR_NAME);
     }
-    const platform = os.platform();
+    const homedir = options.homedir ?? os.homedir();
     if (platform === 'win32') {
         // Windows: use %LOCALAPPDATA%
-        const localAppData = process.env.LOCALAPPDATA;
+        const localAppData = env.LOCALAPPDATA;
         if (localAppData) {
-            return path.join(localAppData, GLOBAL_DATA_DIR_NAME);
+            return joinGlobalDataPath(platform, localAppData, GLOBAL_DATA_DIR_NAME);
         }
         // Fallback for Windows if LOCALAPPDATA is not set
-        return path.join(os.homedir(), 'AppData', 'Local', GLOBAL_DATA_DIR_NAME);
+        return joinGlobalDataPath(platform, homedir, 'AppData', 'Local', GLOBAL_DATA_DIR_NAME);
     }
     // Unix/macOS fallback: ~/.local/share
-    return path.join(os.homedir(), '.local', 'share', GLOBAL_DATA_DIR_NAME);
+    return joinGlobalDataPath(platform, homedir, '.local', 'share', GLOBAL_DATA_DIR_NAME);
 }
 /**
  * Gets the path to the global config file.

package/dist/core/index.d.ts

@@ -1,2 +1,6 @@
-export { GLOBAL_CONFIG_DIR_NAME, GLOBAL_CONFIG_FILE_NAME, GLOBAL_DATA_DIR_NAME, type GlobalConfig, getGlobalConfigDir, getGlobalConfigPath, getGlobalConfig, saveGlobalConfig, getGlobalDataDir } from './global-config.js';
+export { GLOBAL_CONFIG_DIR_NAME, GLOBAL_CONFIG_FILE_NAME, GLOBAL_DATA_DIR_NAME, type GlobalDataDirOptions, type GlobalConfig, getGlobalConfigDir, getGlobalConfigPath, getGlobalConfig, saveGlobalConfig, getGlobalDataDir } from './global-config.js';
+export * from './workspace/index.js';
+export * from './context-store/index.js';
+export * from './collections/index.js';
+export * from './planning-home.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/index.js

@@ -1,3 +1,7 @@
 // Core OpenSpec logic will be implemented here
 export { GLOBAL_CONFIG_DIR_NAME, GLOBAL_CONFIG_FILE_NAME, GLOBAL_DATA_DIR_NAME, getGlobalConfigDir, getGlobalConfigPath, getGlobalConfig, saveGlobalConfig, getGlobalDataDir } from './global-config.js';
+export * from './workspace/index.js';
+export * from './context-store/index.js';
+export * from './collections/index.js';
+export * from './planning-home.js';
 //# sourceMappingURL=index.js.map

package/dist/core/parsers/change-parser.js

@@ -148,15 +148,19 @@ export class ChangeParser extends MarkdownParser {
     parseSectionsFromContent(content) {
         const normalizedContent = ChangeParser.normalizeContent(content);
         const lines = normalizedContent.split('\n');
+        const codeFenceLineMask = ChangeParser.buildCodeFenceMask(lines);
         const sections = [];
         const stack = [];
         for (let i = 0; i < lines.length; i++) {
             const line = lines[i];
+            if (codeFenceLineMask[i]) {
+                continue;
+            }
             const headerMatch = line.match(/^(#{1,6})\s+(.+)$/);
             if (headerMatch) {
                 const level = headerMatch[1].length;
                 const title = headerMatch[2].trim();
-                const contentLines = this.getContentUntilNextHeaderFromLines(lines, i + 1, level);
+                const contentLines = this.getContentUntilNextHeaderFromLines(lines, codeFenceLineMask, i + 1, level);
                 const section = {
                     level,
                     title,
@@ -177,11 +181,11 @@ export class ChangeParser extends MarkdownParser {
         }
         return sections;
     }
-    getContentUntilNextHeaderFromLines(lines, startLine, currentLevel) {
+    getContentUntilNextHeaderFromLines(lines, codeFenceLineMask, startLine, currentLevel) {
         const contentLines = [];
         for (let i = startLine; i < lines.length; i++) {
             const line = lines[i];
-            const headerMatch = line.match(/^(#{1,6})\s+/);
+            const headerMatch = codeFenceLineMask[i] ? null : line.match(/^(#{1,6})\s+/);
             if (headerMatch && headerMatch[1].length <= currentLevel) {
                 break;
             }

package/dist/core/parsers/markdown-parser.d.ts

@@ -7,9 +7,13 @@ export interface Section {
 }
 export declare class MarkdownParser {
     private lines;
+    private codeFenceLineMask;
     private currentLine;
     constructor(content: string);
     protected static normalizeContent(content: string): string;
+    protected static buildCodeFenceMask(lines: string[]): boolean[];
+    private static getFenceMarker;
+    private static isClosingFence;
     parseSpec(name: string): Spec;
     parseChange(name: string): Change;
     protected parseSections(): Section[];

package/dist/core/parsers/markdown-parser.js

@@ -1,14 +1,51 @@
 export class MarkdownParser {
     lines;
+    codeFenceLineMask;
     currentLine;
     constructor(content) {
         const normalized = MarkdownParser.normalizeContent(content);
         this.lines = normalized.split('\n');
+        this.codeFenceLineMask = MarkdownParser.buildCodeFenceMask(this.lines);
         this.currentLine = 0;
     }
     static normalizeContent(content) {
         return content.replace(/\r\n?/g, '\n');
     }
+    static buildCodeFenceMask(lines) {
+        const mask = new Array(lines.length).fill(false);
+        let activeFence = null;
+        for (let i = 0; i < lines.length; i++) {
+            const fence = MarkdownParser.getFenceMarker(lines[i]);
+            if (!activeFence) {
+                if (fence) {
+                    activeFence = fence;
+                    mask[i] = true;
+                }
+                continue;
+            }
+            mask[i] = true;
+            if (MarkdownParser.isClosingFence(lines[i], activeFence)) {
+                activeFence = null;
+            }
+        }
+        return mask;
+    }
+    static getFenceMarker(line) {
+        const fenceMatch = line.match(/^\s*(`{3,}|~{3,})/);
+        if (!fenceMatch) {
+            return null;
+        }
+        return {
+            marker: fenceMatch[1][0],
+            length: fenceMatch[1].length,
+        };
+    }
+    static isClosingFence(line, activeFence) {
+        const fenceMatch = line.match(/^\s*(`{3,}|~{3,})\s*$/);
+        return Boolean(fenceMatch &&
+            fenceMatch[1][0] === activeFence.marker &&
+            fenceMatch[1].length >= activeFence.length);
+    }
     parseSpec(name) {
         const sections = this.parseSections();
         const purpose = this.findSection(sections, 'Purpose')?.content || '';
@@ -57,6 +94,9 @@ export class MarkdownParser {
         const stack = [];
         for (let i = 0; i < this.lines.length; i++) {
             const line = this.lines[i];
+            if (this.codeFenceLineMask[i]) {
+                continue;
+            }
             const headerMatch = line.match(/^(#{1,6})\s+(.+)$/);
             if (headerMatch) {
                 const level = headerMatch[1].length;
@@ -86,7 +126,7 @@ export class MarkdownParser {
         const contentLines = [];
         for (let i = startLine; i < this.lines.length; i++) {
             const line = this.lines[i];
-            const headerMatch = line.match(/^(#{1,6})\s+/);
+            const headerMatch = this.codeFenceLineMask[i] ? null : line.match(/^(#{1,6})\s+/);
             if (headerMatch && headerMatch[1].length <= currentLevel) {
                 break;
             }

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

@@ -1,7 +1,7 @@
 export function normalizeRequirementName(name) {
     return name.trim();
 }
-const REQUIREMENT_HEADER_REGEX = /^###\s*Requirement:\s*(.+)\s*$/;
+const REQUIREMENT_HEADER_REGEX = /^###\s*Requirement:\s*(.+)\s*$/i;
 /**
  * Extracts the Requirements section from a spec file and parses requirement blocks.
  */
@@ -37,7 +37,7 @@ export function extractRequirementsSection(content) {
     let cursor = 0;
     let preambleLines = [];
     // Collect preamble lines until first requirement header
-    while (cursor < sectionBodyLines.length && !/^###\s+Requirement:/.test(sectionBodyLines[cursor])) {
+    while (cursor < sectionBodyLines.length && !REQUIREMENT_HEADER_REGEX.test(sectionBodyLines[cursor])) {
         preambleLines.push(sectionBodyLines[cursor]);
         cursor++;
     }
@@ -54,7 +54,7 @@ export function extractRequirementsSection(content) {
         cursor++;
         // Gather lines until next requirement header or end of section
         const bodyLines = [headerLineCandidate];
-        while (cursor < sectionBodyLines.length && !/^###\s+Requirement:/.test(sectionBodyLines[cursor]) && !/^##\s+/.test(sectionBodyLines[cursor])) {
+        while (cursor < sectionBodyLines.length && !REQUIREMENT_HEADER_REGEX.test(sectionBodyLines[cursor]) && !/^##\s+/.test(sectionBodyLines[cursor])) {
             bodyLines.push(sectionBodyLines[cursor]);
             cursor++;
         }
@@ -136,7 +136,7 @@ function parseRequirementBlocksFromSection(sectionBody) {
     let i = 0;
     while (i < lines.length) {
         // Seek next requirement header
-        while (i < lines.length && !/^###\s+Requirement:/.test(lines[i]))
+        while (i < lines.length && !REQUIREMENT_HEADER_REGEX.test(lines[i]))
             i++;
         if (i >= lines.length)
             break;
@@ -149,7 +149,7 @@ function parseRequirementBlocksFromSection(sectionBody) {
         const name = normalizeRequirementName(m[1]);
         const buf = [headerLine];
         i++;
-        while (i < lines.length && !/^###\s+Requirement:/.test(lines[i]) && !/^##\s+/.test(lines[i])) {
+        while (i < lines.length && !REQUIREMENT_HEADER_REGEX.test(lines[i]) && !/^##\s+/.test(lines[i])) {
             buf.push(lines[i]);
             i++;
         }

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,21 @@
+export type PlanningHomeKind = 'repo' | 'workspace';
+export interface PlanningHome {
+    kind: PlanningHomeKind;
+    root: string;
+    changesDir: string;
+    defaultSchema: string;
+    workspace?: {
+        name: string;
+        links: string[];
+    };
+}
+export interface ResolvePlanningHomeOptions {
+    startPath?: string;
+    allowImplicitRepoRoot?: boolean;
+}
+export declare function findWorkspacePlanningRootSync(startPath?: string): string | null;
+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