@eddacraft/anvil-aps 0.1.0

package/dist/filter/index.js

@@ -0,0 +1,169 @@
+/**
+ * Filter module - Task and module filtering for APS plans
+ *
+ * Provides filtering capabilities for:
+ * - Scope-based filtering (by module scope or task scopes)
+ * - Module-based filtering (by module ID)
+ * - Task-based filtering (by task ID)
+ * - Metadata filtering (owner, tags, priority, confidence)
+ *
+ * Also provides context bundle generation for LLM consumption.
+ */
+// Re-export context bundle functions
+export { buildContextBundleJSON, buildContextBundleText, buildTaskContext, } from './context-bundle.js';
+/**
+ * Filter a loaded plan by the given criteria
+ *
+ * @param plan - The loaded plan to filter
+ * @param criteria - Filter criteria to apply
+ * @returns Filtered plan with matching modules and tasks
+ */
+export function filterPlan(plan, criteria) {
+    // Start with all modules and tasks
+    let filteredModules = Array.from(plan.modules.values());
+    let filteredTasks = [...plan.allTasks];
+    // Apply module-level filters first
+    if (criteria.modules && criteria.modules.length > 0) {
+        filteredModules = filteredModules.filter((m) => criteria.modules.includes(m.id));
+        // Also filter tasks to only those in matching modules
+        const moduleIds = new Set(criteria.modules);
+        filteredTasks = filteredTasks.filter((t) => {
+            const taskModule = findTaskModule(plan, t.id);
+            return taskModule && moduleIds.has(taskModule.id);
+        });
+    }
+    // Apply scope filter (matches module scope OR task scopes)
+    if (criteria.scopes && criteria.scopes.length > 0) {
+        const scopeSet = new Set(criteria.scopes.map((s) => s.toUpperCase()));
+        filteredModules = filteredModules.filter((m) => {
+            const moduleScope = m.metadata.scope?.toUpperCase();
+            return moduleScope && scopeSet.has(moduleScope);
+        });
+        filteredTasks = filteredTasks.filter((t) => {
+            // Check if any of the task's scopes match
+            if (t.scopes && t.scopes.length > 0) {
+                return t.scopes.some((s) => scopeSet.has(s.toUpperCase()));
+            }
+            // Fall back to checking if task ID prefix matches scope
+            const taskScope = t.id.split('-')[0];
+            return scopeSet.has(taskScope);
+        });
+    }
+    // Apply task ID filter
+    if (criteria.tasks && criteria.tasks.length > 0) {
+        const taskIdSet = new Set(criteria.tasks);
+        filteredTasks = filteredTasks.filter((t) => taskIdSet.has(t.id));
+    }
+    // Apply owner filter
+    if (criteria.owners && criteria.owners.length > 0) {
+        const ownerSet = new Set(criteria.owners.map((o) => o.toLowerCase()));
+        filteredModules = filteredModules.filter((m) => {
+            const owner = m.metadata.owner?.toLowerCase();
+            return owner && ownerSet.has(owner);
+        });
+        // For tasks, filter by the module owner (tasks don't have individual owners)
+        filteredTasks = filteredTasks.filter((t) => {
+            const taskModule = findTaskModule(plan, t.id);
+            if (!taskModule)
+                return false;
+            const owner = taskModule.metadata.owner?.toLowerCase();
+            return owner && ownerSet.has(owner);
+        });
+    }
+    // Apply tag filter (matches any tag)
+    if (criteria.tags && criteria.tags.length > 0) {
+        const tagSet = new Set(criteria.tags.map((t) => t.toLowerCase()));
+        filteredModules = filteredModules.filter((m) => {
+            const moduleTags = m.metadata.tags?.map((t) => t.toLowerCase()) ?? [];
+            return moduleTags.some((t) => tagSet.has(t));
+        });
+        filteredTasks = filteredTasks.filter((t) => {
+            const taskTags = t.tags?.map((tag) => tag.toLowerCase()) ?? [];
+            return taskTags.some((tag) => tagSet.has(tag));
+        });
+    }
+    // Apply priority filter
+    if (criteria.priorities && criteria.priorities.length > 0) {
+        const prioritySet = new Set(criteria.priorities);
+        filteredModules = filteredModules.filter((m) => {
+            return m.metadata.priority && prioritySet.has(m.metadata.priority);
+        });
+        // Tasks don't have priority, so filter by module priority
+        filteredTasks = filteredTasks.filter((t) => {
+            const taskModule = findTaskModule(plan, t.id);
+            return taskModule?.metadata.priority && prioritySet.has(taskModule.metadata.priority);
+        });
+    }
+    // Apply confidence filter
+    if (criteria.confidences && criteria.confidences.length > 0) {
+        const confidenceSet = new Set(criteria.confidences);
+        filteredTasks = filteredTasks.filter((t) => confidenceSet.has(t.confidence));
+    }
+    // Apply status filter
+    if (criteria.statuses && criteria.statuses.length > 0) {
+        const statusSet = new Set(criteria.statuses);
+        filteredTasks = filteredTasks.filter((t) => {
+            const status = t.status ?? 'open';
+            return statusSet.has(status);
+        });
+    }
+    return {
+        plan,
+        modules: filteredModules,
+        tasks: filteredTasks,
+        criteria,
+    };
+}
+/**
+ * Find the module that contains a task
+ */
+function findTaskModule(plan, taskId) {
+    for (const module of plan.modules.values()) {
+        if (module.tasks.some((t) => t.id === taskId)) {
+            return module;
+        }
+    }
+    return undefined;
+}
+/**
+ * Filter tasks by scope (convenience function)
+ */
+export function filterByScope(plan, scopes) {
+    return filterPlan(plan, { scopes }).tasks;
+}
+/**
+ * Filter tasks by module (convenience function)
+ */
+export function filterByModule(plan, moduleIds) {
+    return filterPlan(plan, { modules: moduleIds }).tasks;
+}
+/**
+ * Filter tasks by tags (convenience function)
+ */
+export function filterByTags(plan, tags) {
+    return filterPlan(plan, { tags }).tasks;
+}
+/**
+ * Filter tasks by owner (convenience function)
+ */
+export function filterByOwner(plan, owners) {
+    return filterPlan(plan, { owners }).tasks;
+}
+/**
+ * Filter tasks by priority (convenience function)
+ */
+export function filterByPriority(plan, priorities) {
+    return filterPlan(plan, { priorities }).tasks;
+}
+/**
+ * Filter tasks by confidence (convenience function)
+ */
+export function filterByConfidence(plan, confidences) {
+    return filterPlan(plan, { confidences }).tasks;
+}
+/**
+ * Get tasks matching specific IDs
+ */
+export function getTasksById(plan, taskIds) {
+    return filterPlan(plan, { tasks: taskIds }).tasks;
+}

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @eddacraft/anvil-aps - Anvil Planning Spec library
+ *
+ * This package provides functionality for parsing, loading, validating,
+ * and managing Anvil Planning Spec (APS) documents.
+ *
+ * @module @eddacraft/anvil-aps
+ */
+export * from './parser/index.js';
+export * from './loader/index.js';
+export * from './filter/index.js';
+export * from './validator/index.js';
+export * from './state/index.js';
+export * from './types/index.js';
+export * from './templates/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC"}

package/dist/index.js

@@ -0,0 +1,15 @@
+/**
+ * @eddacraft/anvil-aps - Anvil Planning Spec library
+ *
+ * This package provides functionality for parsing, loading, validating,
+ * and managing Anvil Planning Spec (APS) documents.
+ *
+ * @module @eddacraft/anvil-aps
+ */
+export * from './parser/index.js';
+export * from './loader/index.js';
+export * from './filter/index.js';
+export * from './validator/index.js';
+export * from './state/index.js';
+export * from './types/index.js';
+export * from './templates/index.js';

package/dist/loader/index.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Plan loader module
+ * Loads and resolves APS planning documents into a graph structure
+ */
+import { type Task, type ModuleMetadata } from '../types/index.js';
+/**
+ * A loaded module with its tasks and metadata
+ */
+export interface LoadedModule {
+    /** Module identifier */
+    id: string;
+    /** Module metadata from index or leaf spec */
+    metadata: ModuleMetadata;
+    /** All tasks in this module */
+    tasks: Task[];
+    /** Resolved absolute path to the module file */
+    resolvedPath: string;
+    /** IDs of modules this module depends on */
+    dependsOn: string[];
+}
+/**
+ * A complete loaded plan with all modules resolved
+ */
+export interface LoadedPlan {
+    /** Plan title */
+    title: string;
+    /** Root file path */
+    rootPath: string;
+    /** Whether this is a single-file plan or multi-module */
+    isMultiModule: boolean;
+    /** All loaded modules */
+    modules: Map<string, LoadedModule>;
+    /** All tasks from all modules (flattened) */
+    allTasks: Task[];
+    /** Dependency graph (module ID -> dependent module IDs) */
+    dependencyGraph: Map<string, string[]>;
+}
+/**
+ * Options for loading a plan
+ */
+export interface LoadOptions {
+    /** Base directory for resolving relative paths (defaults to directory of root file) */
+    baseDir?: string;
+    /** Whether to recursively load linked modules (default: true) */
+    recursive?: boolean;
+    /** Maximum depth for recursive loading (default: 10) */
+    maxDepth?: number;
+}
+/**
+ * Load an APS plan from a file path
+ *
+ * @param filePath - Path to the root plan file (index or leaf spec)
+ * @param options - Loading options
+ * @returns Loaded plan with all modules resolved
+ */
+export declare function loadPlan(filePath: string, options?: LoadOptions): Promise<LoadedPlan>;
+/**
+ * Resolve a relative path against a base directory.
+ * Rejects absolute paths and paths that escape the base directory.
+ */
+export declare function resolvePath(relativePath: string, baseDir: string): string;
+/**
+ * Get all tasks for a specific module
+ */
+export declare function getModuleTasks(plan: LoadedPlan, moduleId: string): Task[];
+/**
+ * Get all modules that depend on a specific module
+ */
+export declare function getDependentModules(plan: LoadedPlan, moduleId: string): string[];
+/**
+ * Get modules in topological order (dependencies first)
+ */
+export declare function getModulesInOrder(plan: LoadedPlan): string[];
+/**
+ * Check for circular dependencies in the plan
+ */
+export declare function detectCycles(plan: LoadedPlan): string[][];
+export type { ParsedIndex } from '../parser/parse-index.js';
+export type { ParsedDocument } from '../types/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/loader/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/loader/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAUH,OAAO,EAAc,KAAK,IAAI,EAAE,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAE/E;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,wBAAwB;IACxB,EAAE,EAAE,MAAM,CAAC;IAEX,8CAA8C;IAC9C,QAAQ,EAAE,cAAc,CAAC;IAEzB,+BAA+B;IAC/B,KAAK,EAAE,IAAI,EAAE,CAAC;IAEd,gDAAgD;IAChD,YAAY,EAAE,MAAM,CAAC;IAErB,4CAA4C;IAC5C,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,iBAAiB;IACjB,KAAK,EAAE,MAAM,CAAC;IAEd,qBAAqB;IACrB,QAAQ,EAAE,MAAM,CAAC;IAEjB,yDAAyD;IACzD,aAAa,EAAE,OAAO,CAAC;IAEvB,yBAAyB;IACzB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAEnC,6CAA6C;IAC7C,QAAQ,EAAE,IAAI,EAAE,CAAC;IAEjB,2DAA2D;IAC3D,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CACxC;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,uFAAuF;IACvF,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,iEAAiE;IACjE,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB,wDAAwD;IACxD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;GAMG;AACH,wBAAsB,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,UAAU,CAAC,CAgB/F;AAwID;;;GAGG;AACH,wBAAgB,WAAW,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAiBzE;AAmBD;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,EAAE,CAGzE;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAUhF;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,EAAE,CAqB5D;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,EAAE,EAAE,CAoCzD;AAGD,YAAY,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5D,YAAY,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/loader/index.js

@@ -0,0 +1,253 @@
+/**
+ * Plan loader module
+ * Loads and resolves APS planning documents into a graph structure
+ */
+import { promises as fs } from 'node:fs';
+import { dirname, resolve, isAbsolute, sep } from 'node:path';
+import { unified } from 'unified';
+import remarkParse from 'remark-parse';
+import { visit } from 'unist-util-visit';
+import { parseDocument } from '../parser/parse-document.js';
+import { parseIndex } from '../parser/parse-index.js';
+import { ParseError } from '../types/index.js';
+/**
+ * Load an APS plan from a file path
+ *
+ * @param filePath - Path to the root plan file (index or leaf spec)
+ * @param options - Loading options
+ * @returns Loaded plan with all modules resolved
+ */
+export async function loadPlan(filePath, options = {}) {
+    const absolutePath = isAbsolute(filePath) ? filePath : resolve(filePath);
+    const baseDir = options.baseDir ?? dirname(absolutePath);
+    const recursive = options.recursive ?? true;
+    const maxDepth = options.maxDepth ?? 10;
+    const content = await readFile(absolutePath);
+    // Try to detect if this is an index file or leaf spec
+    const isIndex = detectIndexFile(content);
+    if (isIndex) {
+        return loadMultiModulePlan(absolutePath, content, baseDir, recursive, maxDepth);
+    }
+    else {
+        return loadSingleFilePlan(absolutePath, content);
+    }
+}
+/**
+ * Detect if content is an index file (has ## Modules section)
+ * Uses AST parsing for robust detection (case-insensitive, handles variants)
+ */
+function detectIndexFile(content) {
+    const processor = unified().use(remarkParse);
+    const ast = processor.parse(content);
+    let hasModulesSection = false;
+    visit(ast, 'heading', (node) => {
+        if (node.depth === 2) {
+            // Extract heading text and normalize
+            let text = '';
+            visit(node, 'text', (textNode) => {
+                text += textNode.value;
+            });
+            // Check if heading starts with "modules" (case-insensitive)
+            // This handles "## Modules", "## modules", "## Modules & Scopes", etc.
+            const normalizedText = text.trim().toLowerCase();
+            if (normalizedText === 'modules' || normalizedText.startsWith('modules')) {
+                hasModulesSection = true;
+            }
+        }
+    });
+    return hasModulesSection;
+}
+/**
+ * Load a single-file plan (leaf spec with tasks)
+ */
+async function loadSingleFilePlan(filePath, content) {
+    const doc = await parseDocument(content, filePath);
+    const moduleId = doc.metadata?.scope ?? 'main';
+    const module = {
+        id: moduleId,
+        metadata: doc.metadata ?? {},
+        tasks: doc.tasks,
+        resolvedPath: filePath,
+        dependsOn: [],
+    };
+    const modules = new Map();
+    modules.set(moduleId, module);
+    return {
+        title: doc.title,
+        rootPath: filePath,
+        isMultiModule: false,
+        modules,
+        allTasks: doc.tasks,
+        dependencyGraph: new Map([[moduleId, []]]),
+    };
+}
+/**
+ * Load a multi-module plan from an index file
+ */
+async function loadMultiModulePlan(indexPath, content, baseDir, recursive, _maxDepth // TODO: implement depth limiting for nested index files
+) {
+    const index = await parseIndex(content, indexPath);
+    const modules = new Map();
+    const allTasks = [];
+    const dependencyGraph = new Map();
+    // Load each module
+    for (const moduleMeta of index.modules) {
+        const moduleId = moduleMeta.id;
+        if (!moduleId) {
+            throw new ParseError('Module is missing required id field', indexPath);
+        }
+        if (!moduleMeta.path) {
+            throw new ParseError(`Module "${moduleId}" is missing required Path field`, indexPath);
+        }
+        const resolvedPath = resolvePath(moduleMeta.path, baseDir);
+        if (recursive) {
+            const moduleContent = await readFile(resolvedPath);
+            const moduleDoc = await parseDocument(moduleContent, resolvedPath);
+            // Merge metadata from index with any from the leaf spec
+            const mergedMetadata = {
+                ...moduleDoc.metadata,
+                ...moduleMeta,
+                id: moduleId,
+            };
+            const loadedModule = {
+                id: moduleId,
+                metadata: mergedMetadata,
+                tasks: moduleDoc.tasks,
+                resolvedPath,
+                dependsOn: moduleMeta.dependencies ?? [],
+            };
+            modules.set(moduleId, loadedModule);
+            allTasks.push(...moduleDoc.tasks);
+            dependencyGraph.set(moduleId, moduleMeta.dependencies ?? []);
+        }
+        else {
+            // Non-recursive: just record module metadata without loading content
+            const loadedModule = {
+                id: moduleId,
+                metadata: moduleMeta,
+                tasks: [],
+                resolvedPath,
+                dependsOn: moduleMeta.dependencies ?? [],
+            };
+            modules.set(moduleId, loadedModule);
+            dependencyGraph.set(moduleId, moduleMeta.dependencies ?? []);
+        }
+    }
+    return {
+        title: index.title,
+        rootPath: indexPath,
+        isMultiModule: true,
+        modules,
+        allTasks,
+        dependencyGraph,
+    };
+}
+/**
+ * Resolve a relative path against a base directory.
+ * Rejects absolute paths and paths that escape the base directory.
+ */
+export function resolvePath(relativePath, baseDir) {
+    // Reject absolute paths — module paths must be relative to baseDir
+    if (isAbsolute(relativePath)) {
+        throw new ParseError(`Absolute module paths are not allowed: ${relativePath}`, relativePath);
+    }
+    // Remove leading ./ if present
+    const cleanPath = relativePath.replace(/^\.\//, '');
+    const resolved = resolve(baseDir, cleanPath);
+    const resolvedBase = resolve(baseDir);
+    // Validate the resolved path stays within baseDir
+    if (resolved !== resolvedBase && !resolved.startsWith(resolvedBase + sep)) {
+        throw new ParseError(`Module path escapes base directory: ${relativePath}`, relativePath);
+    }
+    return resolved;
+}
+/**
+ * Read a file with proper error handling
+ */
+async function readFile(filePath) {
+    try {
+        return await fs.readFile(filePath, 'utf-8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new ParseError(`File not found: ${filePath}`, filePath);
+        }
+        throw new ParseError(`Failed to read file: ${error instanceof Error ? error.message : String(error)}`, filePath);
+    }
+}
+/**
+ * Get all tasks for a specific module
+ */
+export function getModuleTasks(plan, moduleId) {
+    const module = plan.modules.get(moduleId);
+    return module?.tasks ?? [];
+}
+/**
+ * Get all modules that depend on a specific module
+ */
+export function getDependentModules(plan, moduleId) {
+    const dependents = [];
+    for (const [id, deps] of plan.dependencyGraph) {
+        if (deps.includes(moduleId)) {
+            dependents.push(id);
+        }
+    }
+    return dependents;
+}
+/**
+ * Get modules in topological order (dependencies first)
+ */
+export function getModulesInOrder(plan) {
+    const visited = new Set();
+    const result = [];
+    function visit(moduleId) {
+        if (visited.has(moduleId))
+            return;
+        visited.add(moduleId);
+        const deps = plan.dependencyGraph.get(moduleId) ?? [];
+        for (const dep of deps) {
+            visit(dep);
+        }
+        result.push(moduleId);
+    }
+    for (const moduleId of plan.modules.keys()) {
+        visit(moduleId);
+    }
+    return result;
+}
+/**
+ * Check for circular dependencies in the plan
+ */
+export function detectCycles(plan) {
+    const cycles = [];
+    const visited = new Set();
+    const recursionStack = new Set();
+    const path = [];
+    function dfs(moduleId) {
+        visited.add(moduleId);
+        recursionStack.add(moduleId);
+        path.push(moduleId);
+        const deps = plan.dependencyGraph.get(moduleId) ?? [];
+        for (const dep of deps) {
+            if (!visited.has(dep)) {
+                if (dfs(dep)) {
+                    return true;
+                }
+            }
+            else if (recursionStack.has(dep)) {
+                // Found a cycle
+                const cycleStart = path.indexOf(dep);
+                cycles.push([...path.slice(cycleStart), dep]);
+            }
+        }
+        path.pop();
+        recursionStack.delete(moduleId);
+        return false;
+    }
+    for (const moduleId of plan.modules.keys()) {
+        if (!visited.has(moduleId)) {
+            dfs(moduleId);
+        }
+    }
+    return cycles;
+}

package/dist/parser/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Parser module - Markdown parsing for APS documents
+ *
+ * @example
+ * ```typescript
+ * import { parseDocument, parseIndex } from '@eddacraft/anvil-aps/parser';
+ *
+ * // Parse a leaf spec (tasks)
+ * const leafContent = await fs.readFile('feature.aps.md', 'utf-8');
+ * const doc = await parseDocument(leafContent, 'feature.aps.md');
+ * console.log(doc.tasks.length); // 8
+ *
+ * // Parse an index file (modules)
+ * const indexContent = await fs.readFile('plan/APS.md', 'utf-8');
+ * const index = await parseIndex(indexContent, 'plan/APS.md');
+ * console.log(index.modules.length); // 4
+ * ```
+ */
+export { parseDocument } from './parse-document.js';
+export { parseIndex, type ParsedIndex } from './parse-index.js';
+export { parseTask, parseTaskHeading, parseTaskFields } from './parse-task.js';
+export type { Task, ParsedDocument, ModuleMetadata, Confidence, TaskStatus, } from '../types/index.js';
+export { ParseError } from '../types/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/parser/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/parser/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,UAAU,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAChE,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAC/E,YAAY,EACV,IAAI,EACJ,cAAc,EACd,cAAc,EACd,UAAU,EACV,UAAU,GACX,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/parser/index.js

@@ -0,0 +1,22 @@
+/**
+ * Parser module - Markdown parsing for APS documents
+ *
+ * @example
+ * ```typescript
+ * import { parseDocument, parseIndex } from '@eddacraft/anvil-aps/parser';
+ *
+ * // Parse a leaf spec (tasks)
+ * const leafContent = await fs.readFile('feature.aps.md', 'utf-8');
+ * const doc = await parseDocument(leafContent, 'feature.aps.md');
+ * console.log(doc.tasks.length); // 8
+ *
+ * // Parse an index file (modules)
+ * const indexContent = await fs.readFile('plan/APS.md', 'utf-8');
+ * const index = await parseIndex(indexContent, 'plan/APS.md');
+ * console.log(index.modules.length); // 4
+ * ```
+ */
+export { parseDocument } from './parse-document.js';
+export { parseIndex } from './parse-index.js';
+export { parseTask, parseTaskHeading, parseTaskFields } from './parse-task.js';
+export { ParseError } from '../types/index.js';

package/dist/parser/parse-document.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Document parsing utilities
+ * Converts APS Markdown documents to structured data
+ */
+import { type ParsedDocument } from '../types/index.js';
+/**
+ * Parse an APS leaf spec document from Markdown content
+ *
+ * This function parses leaf specs (documents with tasks).
+ * For index files (documents with modules), use `parseIndex` instead.
+ *
+ * @param content - Markdown content of a leaf spec
+ * @param sourcePath - Optional source file path for error reporting
+ * @returns Parsed document with tasks
+ */
+export declare function parseDocument(content: string, sourcePath?: string): Promise<ParsedDocument>;
+//# sourceMappingURL=parse-document.d.ts.map

package/dist/parser/parse-document.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-document.d.ts","sourceRoot":"","sources":["../../src/parser/parse-document.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,OAAO,EAAyB,KAAK,cAAc,EAAuB,MAAM,mBAAmB,CAAC;AAEpG;;;;;;;;;GASG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAmBjG"}