@fission-ai/openspec 1.3.0 → 1.4.0

package/dist/core/collections/initiatives/operations.js

@@ -0,0 +1,175 @@
+import * as nodeFs from 'node:fs';
+import { INITIATIVE_COLLECTION_ID, INITIATIVE_FILE_NAME, parseInitiativeState, serializeInitiativeState, validateInitiativeId, } from './schema.js';
+import { buildDefaultInitiativeFiles, } from './templates.js';
+const fs = nodeFs.promises;
+const nodeFileSystem = {
+    async mkdir(dirPath, options) {
+        await fs.mkdir(dirPath, options);
+    },
+    async writeFile(filePath, content, options) {
+        await fs.writeFile(filePath, content, {
+            encoding: 'utf-8',
+            flag: options.flag ?? 'w',
+        });
+    },
+    async readFile(filePath) {
+        return fs.readFile(filePath, 'utf-8');
+    },
+    async readdir(dirPath, options) {
+        return fs.readdir(dirPath, options);
+    },
+    async rm(dirPath, options) {
+        await fs.rm(dirPath, options);
+    },
+};
+function getCurrentDate() {
+    return new Date().toISOString().split('T')[0];
+}
+function getFileSystem(fileSystem) {
+    return fileSystem ?? nodeFileSystem;
+}
+function isFileNotFoundError(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'code' in error &&
+        error.code === 'ENOENT');
+}
+function isPathExistsError(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'code' in error &&
+        error.code === 'EEXIST');
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function assertInitiativesCollection(collection) {
+    if (collection.collectionId !== INITIATIVE_COLLECTION_ID) {
+        throw new Error(`Expected mounted '${INITIATIVE_COLLECTION_ID}' collection, got '${collection.collectionId}'`);
+    }
+}
+function resolveInitiativeFilePath(collection, initiativeId, fileName) {
+    return collection.resolvePath(`${initiativeId}/${fileName}`);
+}
+function normalizeCreateState(input) {
+    return parseInitiativeState(serializeInitiativeState({
+        version: 1,
+        id: validateInitiativeId(input.id),
+        title: input.title,
+        summary: input.summary,
+        status: input.status ?? 'exploring',
+        created: (input.getCurrentDate ?? getCurrentDate)(),
+        owners: input.owners ?? [],
+        metadata: input.metadata ?? {},
+    }));
+}
+async function writeExclusiveFile(fileSystem, filePath, content) {
+    await fileSystem.writeFile(filePath, content, { flag: 'wx' });
+}
+async function cleanupCreatedInitiative(fileSystem, initiativeRoot, originalError, initiativeId) {
+    try {
+        await fileSystem.rm(initiativeRoot, { recursive: true, force: true });
+    }
+    catch (cleanupError) {
+        throw new Error(`Failed to create initiative '${initiativeId}' and cleanup failed: ${errorMessage(originalError)}; cleanup: ${errorMessage(cleanupError)}`);
+    }
+    throw new Error(`Failed to create initiative '${initiativeId}': ${errorMessage(originalError)}`);
+}
+export async function createInitiative(input) {
+    assertInitiativesCollection(input.collection);
+    const state = normalizeCreateState(input);
+    const fileSystem = getFileSystem(input.fileSystem);
+    const initiativeRoot = input.collection.resolvePath(state.id);
+    const buildTemplateFiles = input.buildTemplateFiles ?? buildDefaultInitiativeFiles;
+    try {
+        await fileSystem.mkdir(input.collection.resolvePath(), { recursive: true });
+        await fileSystem.mkdir(initiativeRoot, { recursive: false });
+    }
+    catch (error) {
+        if (isPathExistsError(error)) {
+            throw new Error(`Initiative '${state.id}' already exists at ${initiativeRoot}`);
+        }
+        throw new Error(`Failed to create initiative '${state.id}': ${errorMessage(error)}`);
+    }
+    try {
+        await writeExclusiveFile(fileSystem, resolveInitiativeFilePath(input.collection, state.id, INITIATIVE_FILE_NAME), serializeInitiativeState(state));
+        for (const templateFile of buildTemplateFiles(state)) {
+            await writeExclusiveFile(fileSystem, resolveInitiativeFilePath(input.collection, state.id, templateFile.fileName), templateFile.content);
+        }
+    }
+    catch (error) {
+        await cleanupCreatedInitiative(fileSystem, initiativeRoot, error, state.id);
+    }
+    return state;
+}
+export async function readInitiative(input) {
+    assertInitiativesCollection(input.collection);
+    const initiativeId = validateInitiativeId(input.id);
+    const fileSystem = getFileSystem(input.fileSystem);
+    const initiativeFilePath = resolveInitiativeFilePath(input.collection, initiativeId, INITIATIVE_FILE_NAME);
+    let content;
+    try {
+        content = await fileSystem.readFile(initiativeFilePath);
+    }
+    catch (error) {
+        if (isFileNotFoundError(error)) {
+            return null;
+        }
+        throw new Error(`Invalid initiative '${initiativeId}': failed to read ${INITIATIVE_FILE_NAME}: ${errorMessage(error)}`);
+    }
+    let state;
+    try {
+        state = parseInitiativeState(content);
+    }
+    catch (error) {
+        throw new Error(`Invalid initiative '${initiativeId}': ${errorMessage(error)}`);
+    }
+    if (state.id !== initiativeId) {
+        throw new Error(`Invalid initiative '${initiativeId}': ${INITIATIVE_FILE_NAME} id '${state.id}' must match folder name`);
+    }
+    return state;
+}
+export async function listInitiatives(input) {
+    assertInitiativesCollection(input.collection);
+    const fileSystem = getFileSystem(input.fileSystem);
+    let entries;
+    try {
+        entries = await fileSystem.readdir(input.collection.resolvePath(), { withFileTypes: true });
+    }
+    catch (error) {
+        if (isFileNotFoundError(error)) {
+            return [];
+        }
+        throw new Error(`Failed to list initiatives: ${errorMessage(error)}`);
+    }
+    const initiatives = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const initiativeFilePath = resolveInitiativeFilePath(input.collection, entry.name, INITIATIVE_FILE_NAME);
+        let content;
+        try {
+            content = await fileSystem.readFile(initiativeFilePath);
+        }
+        catch (error) {
+            if (isFileNotFoundError(error)) {
+                continue;
+            }
+            throw new Error(`Invalid initiative '${entry.name}': failed to read ${INITIATIVE_FILE_NAME}: ${errorMessage(error)}`);
+        }
+        let state;
+        try {
+            state = parseInitiativeState(content);
+        }
+        catch (error) {
+            throw new Error(`Invalid initiative '${entry.name}': ${errorMessage(error)}`);
+        }
+        if (state.id !== entry.name) {
+            throw new Error(`Invalid initiative '${entry.name}': ${INITIATIVE_FILE_NAME} id '${state.id}' must match folder name`);
+        }
+        initiatives.push(state);
+    }
+    return initiatives.sort((a, b) => a.id.localeCompare(b.id));
+}
+//# sourceMappingURL=operations.js.map

package/dist/core/collections/initiatives/resolution.d.ts

@@ -0,0 +1,87 @@
+import { formatContextStoreSelector, type ContextStoreSelectorOptions, type ContextStoreSelectorSource, type SelectedContextStore } from '../../context-store/index.js';
+import { type InitiativeState } from './schema.js';
+export interface InitiativeSelectorOptions extends ContextStoreSelectorOptions {
+    json?: boolean;
+}
+export type { ContextStoreSelectorSource, SelectedContextStore };
+export { formatContextStoreSelector };
+export interface InitiativeResolutionMatch {
+    context_store: {
+        id: string;
+        root: string;
+    };
+    initiative: {
+        id: string;
+        title: string;
+        root: string;
+    };
+}
+export interface InitiativeResolutionDetails extends Record<string, unknown> {
+    matches?: InitiativeResolutionMatch[];
+}
+export declare class InitiativeResolutionError extends Error {
+    readonly code: string;
+    readonly target?: string;
+    readonly fix?: string;
+    readonly details?: InitiativeResolutionDetails;
+    constructor(message: string, code: string, options?: {
+        target?: string;
+        fix?: string;
+        details?: InitiativeResolutionDetails;
+    });
+}
+export interface InitiativeViewReference {
+    store: string;
+    storeSource: ContextStoreSelectorSource;
+    storeRoot: string;
+    id: string;
+    title: string;
+    summary: string;
+    created: string;
+    root: string;
+    storePath: string;
+    metadataPath: string;
+}
+export interface ListedInitiativeReference extends InitiativeViewReference {
+    status: InitiativeState['status'];
+    owners: InitiativeState['owners'];
+    metadata: InitiativeState['metadata'];
+}
+export type InitiativeDiagnosticSeverity = 'error' | 'warning';
+export interface InitiativeDiagnostic {
+    severity: InitiativeDiagnosticSeverity;
+    code: string;
+    message: string;
+    target?: string;
+    fix?: string;
+    details?: InitiativeResolutionDetails;
+}
+export interface ContextStoreInitiativeListReference {
+    contextStore: SelectedContextStore;
+    initiatives: ListedInitiativeReference[];
+    status: InitiativeDiagnostic[];
+}
+export interface InitiativeListReferenceResult {
+    contextStore: SelectedContextStore | null;
+    contextStores: ContextStoreInitiativeListReference[];
+    initiatives: ListedInitiativeReference[];
+    status: InitiativeDiagnostic[];
+}
+export declare function initiativeDiagnosticFromError(error: unknown): InitiativeDiagnostic;
+export declare function parseInitiativeReference(reference: string | undefined, options: InitiativeSelectorOptions): {
+    initiativeId: string;
+    options: InitiativeSelectorOptions;
+};
+export declare function resolveRegisteredInitiativeContextStore(storeId: string): Promise<SelectedContextStore>;
+export declare function resolvePathInitiativeContextStore(storePath: string): Promise<SelectedContextStore>;
+export declare function selectContextStoreForInitiative(options: InitiativeSelectorOptions, commandName: 'create' | 'list' | 'show'): Promise<SelectedContextStore>;
+export declare function resolveSelectedInitiativeViewReference(selected: SelectedContextStore, initiativeId: string): Promise<InitiativeViewReference>;
+export declare function listSelectedInitiativeViewReferences(selected: SelectedContextStore): Promise<ContextStoreInitiativeListReference>;
+export declare function listInitiativeViewReferences(options?: InitiativeSelectorOptions): Promise<InitiativeListReferenceResult>;
+export declare function resolveInitiativeViewReference(reference: string | undefined, options?: InitiativeSelectorOptions): Promise<InitiativeViewReference>;
+export interface InitiativeLinkReference {
+    store: string;
+    id: string;
+}
+export declare function resolveInitiativeLinkReference(reference: string | undefined, options?: InitiativeSelectorOptions): Promise<InitiativeLinkReference>;
+//# sourceMappingURL=resolution.d.ts.map

package/dist/core/collections/initiatives/resolution.js

@@ -0,0 +1,374 @@
+import { ContextStoreError, formatContextStoreSelector, listRegisteredContextStores, resolveSelectedContextStore, } from '../../context-store/index.js';
+import { mountInitiativesCollection } from './collection.js';
+import { listInitiatives, readInitiative } from './operations.js';
+import { INITIATIVE_FILE_NAME } from './schema.js';
+export { formatContextStoreSelector };
+export class InitiativeResolutionError extends Error {
+    code;
+    target;
+    fix;
+    details;
+    constructor(message, code, options = {}) {
+        super(message);
+        this.code = code;
+        this.target = options.target;
+        this.fix = options.fix;
+        this.details = options.details;
+    }
+}
+function asErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function makeDiagnostic(severity, code, message, options = {}) {
+    return {
+        severity,
+        code,
+        message,
+        ...options,
+    };
+}
+const INITIATIVE_ALREADY_EXISTS_PREFIX = "Initiative '";
+const INITIATIVE_ALREADY_EXISTS_MARKER = "' already exists";
+export function initiativeDiagnosticFromError(error) {
+    if (error instanceof InitiativeResolutionError) {
+        return makeDiagnostic('error', error.code, error.message, {
+            target: error.target,
+            fix: error.fix,
+            details: error.details,
+        });
+    }
+    const message = asErrorMessage(error);
+    if (message.startsWith(INITIATIVE_ALREADY_EXISTS_PREFIX) &&
+        message.includes(INITIATIVE_ALREADY_EXISTS_MARKER, INITIATIVE_ALREADY_EXISTS_PREFIX.length)) {
+        return makeDiagnostic('error', 'initiative_already_exists', message, {
+            target: 'initiative.id',
+            fix: 'Choose a new initiative id or list existing initiatives first.',
+        });
+    }
+    if (message.startsWith('Initiative id ')) {
+        return makeDiagnostic('error', 'invalid_initiative_id', message, {
+            target: 'initiative.id',
+            fix: 'Use kebab-case with lowercase letters, numbers, and single hyphen separators.',
+        });
+    }
+    if (message.startsWith('Invalid initiative')) {
+        return makeDiagnostic('error', 'invalid_initiative', message, {
+            target: 'initiative',
+            fix: 'Fix the initiative folder state and retry.',
+        });
+    }
+    return makeDiagnostic('error', 'initiative_error', message);
+}
+function requireInitiativeId(id, commandName) {
+    if (id === undefined || id.trim().length === 0) {
+        throw new InitiativeResolutionError('Pass an initiative id.', 'initiative_id_required', {
+            target: 'initiative.id',
+            fix: `openspec initiative ${commandName} <id>`,
+        });
+    }
+    return id.trim();
+}
+export function parseInitiativeReference(reference, options) {
+    const initiativeId = requireInitiativeId(reference, 'show');
+    const parts = initiativeId.split('/');
+    if (parts.length === 1) {
+        return { initiativeId, options };
+    }
+    if (parts.length !== 2 || parts[0].length === 0 || parts[1].length === 0) {
+        throw new InitiativeResolutionError(`Invalid initiative reference '${initiativeId}'.`, 'invalid_initiative_reference', {
+            target: 'initiative.id',
+            fix: 'Use <initiative-id>, <store>/<initiative-id>, or <initiative-id> --store <store>.',
+        });
+    }
+    if (options.store !== undefined || options.storePath !== undefined) {
+        throw new InitiativeResolutionError('Pass either --initiative <store>/<id> or a context store selector, not both.', 'context_store_selector_conflict', {
+            target: 'context_store',
+            fix: 'Use --initiative <store>/<id> or --initiative <id> --store <store>.',
+        });
+    }
+    return {
+        initiativeId: parts[1],
+        options: {
+            ...options,
+            store: parts[0],
+        },
+    };
+}
+function contextStoreErrorAsInitiativeError(error) {
+    if (error instanceof ContextStoreError) {
+        return new InitiativeResolutionError(error.message, error.diagnostic.code, {
+            target: error.diagnostic.target,
+            fix: error.diagnostic.fix,
+        });
+    }
+    const message = asErrorMessage(error);
+    if (message.startsWith('Context store id ')) {
+        return new InitiativeResolutionError(message, 'invalid_context_store_id', {
+            target: 'context_store.id',
+            fix: 'Use kebab-case with lowercase letters, numbers, and single hyphen separators.',
+        });
+    }
+    return new InitiativeResolutionError(message, 'invalid_context_store', {
+        target: 'context_store',
+        fix: 'Fix the context store registry or pass --store-path <path>.',
+    });
+}
+export async function resolveRegisteredInitiativeContextStore(storeId) {
+    return selectContextStoreForInitiative({ store: storeId }, 'show');
+}
+export async function resolvePathInitiativeContextStore(storePath) {
+    return selectContextStoreForInitiative({ storePath }, 'show');
+}
+export async function selectContextStoreForInitiative(options, commandName) {
+    try {
+        return await resolveSelectedContextStore(options, `initiative ${commandName}`);
+    }
+    catch (error) {
+        throw contextStoreErrorAsInitiativeError(error);
+    }
+}
+function toInitiativeViewReference(selected, state) {
+    const collection = mountInitiativesCollection(selected.root);
+    return {
+        store: selected.id,
+        storeSource: selected.source,
+        storeRoot: selected.root,
+        id: state.id,
+        title: state.title,
+        summary: state.summary,
+        created: state.created,
+        root: collection.resolvePath(state.id),
+        storePath: collection.toStorePath(state.id),
+        metadataPath: collection.resolvePath(`${state.id}/${INITIATIVE_FILE_NAME}`),
+    };
+}
+function toResolutionMatch(selected, state) {
+    const reference = toInitiativeViewReference(selected, state);
+    return {
+        context_store: {
+            id: reference.store,
+            root: reference.storeRoot,
+        },
+        initiative: {
+            id: reference.id,
+            title: reference.title,
+            root: reference.root,
+        },
+    };
+}
+function toListedInitiativeReference(selected, state) {
+    return {
+        ...toInitiativeViewReference(selected, state),
+        status: state.status,
+        owners: state.owners,
+        metadata: state.metadata,
+    };
+}
+async function readSelectedInitiative(selected, initiativeId) {
+    return readInitiative({
+        collection: mountInitiativesCollection(selected.root),
+        id: initiativeId,
+    });
+}
+export async function resolveSelectedInitiativeViewReference(selected, initiativeId) {
+    const state = await readSelectedInitiative(selected, initiativeId);
+    if (!state) {
+        throw new InitiativeResolutionError(`Initiative '${initiativeId}' was not found in context store '${selected.id}'.`, 'initiative_not_found', {
+            target: 'initiative.id',
+            fix: `openspec initiative list ${formatContextStoreSelector(selected)}`,
+        });
+    }
+    return toInitiativeViewReference(selected, state);
+}
+export async function listSelectedInitiativeViewReferences(selected) {
+    const collection = mountInitiativesCollection(selected.root);
+    const initiatives = await listInitiatives({ collection });
+    return {
+        contextStore: selected,
+        initiatives: initiatives.map((initiative) => toListedInitiativeReference(selected, initiative)),
+        status: [],
+    };
+}
+async function scanRegisteredStoreForInitiativeList(entryId) {
+    let selected;
+    try {
+        selected = await resolveRegisteredInitiativeContextStore(entryId);
+    }
+    catch (error) {
+        return {
+            kind: 'store_unreadable',
+            entryId,
+            error,
+        };
+    }
+    try {
+        return {
+            kind: 'listed',
+            listed: await listSelectedInitiativeViewReferences(selected),
+        };
+    }
+    catch (error) {
+        return {
+            kind: 'initiative_collection_invalid',
+            selected,
+            error,
+            diagnostic: initiativeDiagnosticFromError(error),
+        };
+    }
+}
+async function scanRegisteredStoreForInitiative(entryId, initiativeId) {
+    let selected;
+    try {
+        selected = await resolveRegisteredInitiativeContextStore(entryId);
+    }
+    catch (error) {
+        return {
+            kind: 'store_unreadable',
+            entryId,
+            error,
+        };
+    }
+    try {
+        const state = await readSelectedInitiative(selected, initiativeId);
+        if (!state) {
+            return {
+                kind: 'missing',
+                selected,
+            };
+        }
+        return {
+            kind: 'match',
+            selected,
+            state,
+            diagnostic: toResolutionMatch(selected, state),
+        };
+    }
+    catch (error) {
+        return {
+            kind: 'initiative_invalid',
+            selected,
+            error,
+        };
+    }
+}
+async function scanRegisteredStoresForInitiativeLists() {
+    const registeredStores = await listRegisteredContextStores();
+    return Promise.all(registeredStores.map((entry) => scanRegisteredStoreForInitiativeList(entry.id)));
+}
+async function scanRegisteredStoresForInitiative(initiativeId) {
+    const registeredStores = await listRegisteredContextStores();
+    return Promise.all(registeredStores.map((entry) => scanRegisteredStoreForInitiative(entry.id, initiativeId)));
+}
+export async function listInitiativeViewReferences(options = {}) {
+    if (options.store !== undefined || options.storePath !== undefined) {
+        const selected = await selectContextStoreForInitiative(options, 'list');
+        const listed = await listSelectedInitiativeViewReferences(selected);
+        return {
+            contextStore: listed.contextStore,
+            contextStores: [listed],
+            initiatives: listed.initiatives,
+            status: [],
+        };
+    }
+    const outcomes = await scanRegisteredStoresForInitiativeLists();
+    if (outcomes.length === 0) {
+        return {
+            contextStore: null,
+            contextStores: [],
+            initiatives: [],
+            status: [],
+        };
+    }
+    const contextStores = outcomes
+        .filter((outcome) => outcome.kind === 'listed')
+        .map((outcome) => outcome.listed);
+    const invalidCollections = outcomes.filter((outcome) => outcome.kind === 'initiative_collection_invalid');
+    const unreadable = outcomes.filter((outcome) => outcome.kind === 'store_unreadable');
+    const contextStoreResults = [
+        ...contextStores,
+        ...invalidCollections.map((outcome) => ({
+            contextStore: outcome.selected,
+            initiatives: [],
+            status: [outcome.diagnostic],
+        })),
+    ];
+    if (contextStores.length === 0 && invalidCollections.length > 0) {
+        throw new InitiativeResolutionError('No initiatives could be read because registered context stores contain invalid initiatives.', 'initiative_collections_invalid', {
+            target: 'initiative',
+            fix: 'Fix the invalid initiative folder state and retry.',
+        });
+    }
+    if (contextStoreResults.length === 0) {
+        throw new InitiativeResolutionError('No initiatives could be read from registered context stores.', 'context_stores_unreadable', {
+            target: 'context_store',
+            fix: 'openspec context-store doctor',
+        });
+    }
+    const status = [];
+    if (unreadable.length > 0) {
+        status.push(makeDiagnostic('warning', 'context_stores_partially_unreadable', 'Some registered context stores could not be read.', {
+            target: 'context_store',
+            fix: 'openspec context-store doctor',
+        }));
+    }
+    if (invalidCollections.length > 0) {
+        status.push(makeDiagnostic('warning', 'initiative_collections_partially_invalid', 'Some registered context stores contain invalid initiatives.', {
+            target: 'initiative',
+            fix: 'Fix the invalid initiative folder state and retry.',
+        }));
+    }
+    return {
+        contextStore: null,
+        contextStores: contextStoreResults,
+        initiatives: contextStoreResults
+            .flatMap((store) => store.initiatives)
+            .sort((left, right) => left.store.localeCompare(right.store) || left.id.localeCompare(right.id)),
+        status,
+    };
+}
+export async function resolveInitiativeViewReference(reference, options = {}) {
+    const parsed = parseInitiativeReference(reference, options);
+    if (parsed.options.store !== undefined || parsed.options.storePath !== undefined) {
+        const selected = await selectContextStoreForInitiative(parsed.options, 'show');
+        return resolveSelectedInitiativeViewReference(selected, parsed.initiativeId);
+    }
+    const outcomes = await scanRegisteredStoresForInitiative(parsed.initiativeId);
+    const matches = outcomes.filter((outcome) => outcome.kind === 'match');
+    const unreadable = outcomes.filter((outcome) => outcome.kind === 'store_unreadable');
+    const invalidInitiatives = outcomes.filter((outcome) => outcome.kind === 'initiative_invalid');
+    if (invalidInitiatives.length > 0) {
+        throw invalidInitiatives[0].error;
+    }
+    if (unreadable.length > 0) {
+        throw new InitiativeResolutionError(`Initiative lookup for '${parsed.initiativeId}' is incomplete because some context stores could not be read.`, 'initiative_lookup_incomplete', {
+            target: 'context_store',
+            fix: 'openspec context-store doctor',
+            ...(matches.length > 0
+                ? { details: { matches: matches.map((match) => match.diagnostic) } }
+                : {}),
+        });
+    }
+    if (matches.length === 0) {
+        throw new InitiativeResolutionError(`Initiative '${parsed.initiativeId}' was not found in registered context stores.`, 'initiative_not_found', {
+            target: 'initiative.id',
+            fix: 'openspec initiative list',
+        });
+    }
+    if (matches.length > 1) {
+        throw new InitiativeResolutionError(`Initiative '${parsed.initiativeId}' exists in multiple context stores.`, 'initiative_ambiguous', {
+            target: 'initiative.id',
+            fix: `openspec initiative show ${parsed.initiativeId} --store <store>`,
+            details: { matches: matches.map((match) => match.diagnostic) },
+        });
+    }
+    const [match] = matches;
+    return toInitiativeViewReference(match.selected, match.state);
+}
+export async function resolveInitiativeLinkReference(reference, options = {}) {
+    const initiative = await resolveInitiativeViewReference(reference, options);
+    return {
+        store: initiative.store,
+        id: initiative.id,
+    };
+}
+//# sourceMappingURL=resolution.js.map

package/dist/core/collections/initiatives/schema.d.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+export declare const INITIATIVE_COLLECTION_ID = "initiatives";
+export declare const INITIATIVE_FILE_NAME = "initiative.yaml";
+export declare const INITIATIVE_REQUIREMENTS_FILE_NAME = "requirements.md";
+export declare const INITIATIVE_DESIGN_FILE_NAME = "design.md";
+export declare const INITIATIVE_DECISIONS_FILE_NAME = "decisions.md";
+export declare const INITIATIVE_QUESTIONS_FILE_NAME = "questions.md";
+export declare const INITIATIVE_TASKS_FILE_NAME = "tasks.md";
+export declare const INITIATIVE_MARKDOWN_FILE_NAMES: readonly ["requirements.md", "design.md", "decisions.md", "questions.md", "tasks.md"];
+export declare const INITIATIVE_FILE_NAMES: readonly ["initiative.yaml", "requirements.md", "design.md", "decisions.md", "questions.md", "tasks.md"];
+export type InitiativeMarkdownFileName = typeof INITIATIVE_MARKDOWN_FILE_NAMES[number];
+export type InitiativeFileName = typeof INITIATIVE_FILE_NAMES[number];
+export declare const INITIATIVE_STATUSES: readonly ["exploring", "active", "complete", "archived"];
+export type InitiativeStatus = typeof INITIATIVE_STATUSES[number];
+export type InitiativeMetadataValue = string | number | boolean | null | InitiativeMetadataValue[] | {
+    [key: string]: InitiativeMetadataValue;
+};
+export type InitiativeMetadata = Record<string, InitiativeMetadataValue>;
+declare const InitiativeStateSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    id: z.ZodString;
+    title: z.ZodString;
+    summary: z.ZodString;
+    status: z.ZodEnum<{
+        complete: "complete";
+        active: "active";
+        exploring: "exploring";
+        archived: "archived";
+    }>;
+    created: z.ZodString;
+    owners: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<InitiativeMetadataValue, unknown, z.core.$ZodTypeInternals<InitiativeMetadataValue, unknown>>>>;
+}, z.core.$strict>;
+export type InitiativeStateInput = z.input<typeof InitiativeStateSchema>;
+export type InitiativeState = z.output<typeof InitiativeStateSchema>;
+export declare function validateInitiativeId(id: string): string;
+export declare function isValidInitiativeId(id: string): boolean;
+export declare function parseInitiativeState(content: string): InitiativeState;
+export declare function serializeInitiativeState(state: InitiativeStateInput): string;
+export {};
+//# sourceMappingURL=schema.d.ts.map