@thiagodiogo/pastelsdd 1.0.0-beta.1

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: `pastelsdd 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: `pastelsdd 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: 'pastelsdd 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: 'pastelsdd 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: 'pastelsdd 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: 'pastelsdd initiative list',
+        });
+    }
+    if (matches.length > 1) {
+        throw new InitiativeResolutionError(`Initiative '${parsed.initiativeId}' exists in multiple context stores.`, 'initiative_ambiguous', {
+            target: 'initiative.id',
+            fix: `pastelsdd 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

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

@@ -0,0 +1,134 @@
+import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
+import { z } from 'zod';
+export const INITIATIVE_COLLECTION_ID = 'initiatives';
+export const INITIATIVE_FILE_NAME = 'initiative.yaml';
+export const INITIATIVE_REQUIREMENTS_FILE_NAME = 'requirements.md';
+export const INITIATIVE_DESIGN_FILE_NAME = 'design.md';
+export const INITIATIVE_DECISIONS_FILE_NAME = 'decisions.md';
+export const INITIATIVE_QUESTIONS_FILE_NAME = 'questions.md';
+export const INITIATIVE_TASKS_FILE_NAME = 'tasks.md';
+export const INITIATIVE_MARKDOWN_FILE_NAMES = [
+    INITIATIVE_REQUIREMENTS_FILE_NAME,
+    INITIATIVE_DESIGN_FILE_NAME,
+    INITIATIVE_DECISIONS_FILE_NAME,
+    INITIATIVE_QUESTIONS_FILE_NAME,
+    INITIATIVE_TASKS_FILE_NAME,
+];
+export const INITIATIVE_FILE_NAMES = [
+    INITIATIVE_FILE_NAME,
+    ...INITIATIVE_MARKDOWN_FILE_NAMES,
+];
+export const INITIATIVE_STATUSES = [
+    'exploring',
+    'active',
+    'complete',
+    'archived',
+];
+const INITIATIVE_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/u;
+function assertNoNul(value, label) {
+    if (value.includes('\0')) {
+        throw new Error(`${label} must not contain NUL bytes`);
+    }
+}
+function nonBlankString(label) {
+    return z.string().refine((value) => value.trim().length > 0, {
+        message: `${label} must not be empty`,
+    });
+}
+const InitiativeMetadataValueSchema = z.lazy(() => z.union([
+    z.string(),
+    z.number().finite(),
+    z.boolean(),
+    z.null(),
+    z.array(InitiativeMetadataValueSchema),
+    z.record(z.string(), InitiativeMetadataValueSchema),
+]));
+const InitiativeMetadataSchema = z.record(z.string(), InitiativeMetadataValueSchema);
+const InitiativeStateSchema = z.object({
+    version: z.literal(1),
+    id: z.string(),
+    title: nonBlankString('title'),
+    summary: nonBlankString('summary'),
+    status: z.enum(INITIATIVE_STATUSES),
+    created: z.string().regex(INITIATIVE_DATE_PATTERN, {
+        message: 'created must be YYYY-MM-DD format',
+    }),
+    owners: z.array(nonBlankString('owner')).default([]),
+    metadata: InitiativeMetadataSchema.default({}),
+}).strict();
+function formatZodIssues(error) {
+    return error.issues
+        .map((issue) => {
+        const location = issue.path.length > 0 ? issue.path.join('.') : 'root';
+        return `${location}: ${issue.message}`;
+    })
+        .join('; ');
+}
+function parseYamlObject(content, label) {
+    try {
+        return parseYaml(content);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid ${label}: ${message}`);
+    }
+}
+export function validateInitiativeId(id) {
+    assertNoNul(id, 'Initiative id');
+    if (id.length === 0) {
+        throw new Error('Initiative id must not be empty');
+    }
+    if (id === '.' || id === '..') {
+        throw new Error(`Initiative id must not be '${id}'`);
+    }
+    if (/[\\/]/u.test(id)) {
+        throw new Error('Initiative id must not contain path separators');
+    }
+    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/u.test(id)) {
+        throw new Error('Initiative id must be kebab-case with lowercase letters, numbers, and single hyphen separators');
+    }
+    return id;
+}
+export function isValidInitiativeId(id) {
+    try {
+        validateInitiativeId(id);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function parseInitiativeStateInput(raw) {
+    const result = InitiativeStateSchema.safeParse(raw);
+    if (!result.success) {
+        throw new Error(`Invalid initiative state: ${formatZodIssues(result.error)}`);
+    }
+    validateInitiativeId(result.data.id);
+    return {
+        version: 1,
+        id: result.data.id,
+        title: result.data.title,
+        summary: result.data.summary,
+        status: result.data.status,
+        created: result.data.created,
+        owners: result.data.owners,
+        metadata: result.data.metadata,
+    };
+}
+export function parseInitiativeState(content) {
+    return parseInitiativeStateInput(parseYamlObject(content, 'initiative state'));
+}
+export function serializeInitiativeState(state) {
+    const parsedState = parseInitiativeStateInput(state);
+    return stringifyYaml({
+        version: 1,
+        id: parsedState.id,
+        title: parsedState.title,
+        summary: parsedState.summary,
+        status: parsedState.status,
+        created: parsedState.created,
+        owners: parsedState.owners,
+        metadata: parsedState.metadata,
+    });
+}
+//# sourceMappingURL=schema.js.map

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

@@ -0,0 +1,12 @@
+import { type InitiativeMarkdownFileName, type InitiativeState } from './schema.js';
+export interface InitiativeTemplateFile {
+    fileName: InitiativeMarkdownFileName;
+    content: string;
+}
+export declare function buildInitiativeRequirementsTemplate(state: InitiativeState): string;
+export declare function buildInitiativeDesignTemplate(state: InitiativeState): string;
+export declare function buildInitiativeDecisionsTemplate(state: InitiativeState): string;
+export declare function buildInitiativeQuestionsTemplate(): string;
+export declare function buildInitiativeTasksTemplate(): string;
+export declare function buildDefaultInitiativeFiles(state: InitiativeState): InitiativeTemplateFile[];
+//# sourceMappingURL=templates.d.ts.map

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

@@ -0,0 +1,90 @@
+import { INITIATIVE_DECISIONS_FILE_NAME, INITIATIVE_DESIGN_FILE_NAME, INITIATIVE_MARKDOWN_FILE_NAMES, INITIATIVE_QUESTIONS_FILE_NAME, INITIATIVE_REQUIREMENTS_FILE_NAME, INITIATIVE_TASKS_FILE_NAME, } from './schema.js';
+function withTrailingNewline(content) {
+    return content.endsWith('\n') ? content : `${content}\n`;
+}
+export function buildInitiativeRequirementsTemplate(state) {
+    return withTrailingNewline(`# Requirements
+
+## Product Intent
+
+${state.summary}
+
+## Accepted Requirements
+
+- TBD
+
+## Out Of Scope
+
+- TBD
+`);
+}
+export function buildInitiativeDesignTemplate(state) {
+    return withTrailingNewline(`# Design
+
+## Context
+
+${state.summary}
+
+## Approach
+
+TBD
+
+## Affected Areas
+
+- TBD
+
+## Dependencies
+
+- TBD
+
+## Risks
+
+- TBD
+`);
+}
+export function buildInitiativeDecisionsTemplate(state) {
+    return withTrailingNewline(`# Decisions
+
+## Accepted Decisions
+
+### ${state.created}: ${state.title}
+
+- Decision: TBD
+- Why: TBD
+- Implications: TBD
+`);
+}
+export function buildInitiativeQuestionsTemplate() {
+    return withTrailingNewline(`# Questions
+
+## Open Questions
+
+- TBD
+
+## Resolved Questions
+
+- TBD
+`);
+}
+export function buildInitiativeTasksTemplate() {
+    return withTrailingNewline(`# Tasks
+
+## Coordination Tasks
+
+- [ ] TBD
+`);
+}
+export function buildDefaultInitiativeFiles(state) {
+    const templates = {
+        [INITIATIVE_REQUIREMENTS_FILE_NAME]: buildInitiativeRequirementsTemplate(state),
+        [INITIATIVE_DESIGN_FILE_NAME]: buildInitiativeDesignTemplate(state),
+        [INITIATIVE_DECISIONS_FILE_NAME]: buildInitiativeDecisionsTemplate(state),
+        [INITIATIVE_QUESTIONS_FILE_NAME]: buildInitiativeQuestionsTemplate(),
+        [INITIATIVE_TASKS_FILE_NAME]: buildInitiativeTasksTemplate(),
+    };
+    return INITIATIVE_MARKDOWN_FILE_NAMES.map((fileName) => ({
+        fileName,
+        content: templates[fileName],
+    }));
+}
+//# sourceMappingURL=templates.js.map