@eddacraft/anvil-aps 0.1.0

package/AGENTS.md

@@ -0,0 +1,155 @@
+# APS Package (@eddacraft/anvil-aps)
+
+> APS document parsing, validation, state management, and template generation
+
+**Parent**: See root `AGENTS.md` for project-wide conventions.
+
+## Structure
+
+```
+packages/aps/src/
+├── parser/             # Markdown AST parsing (remark/unified)
+│   └── index.ts        # Extract tasks, modules, metadata from .aps.md
+├── loader/             # Document loading and graph resolution
+│   └── index.ts        # Load plans, resolve dependencies
+├── validator/          # Validation rules (745 lines)
+│   └── index.ts        # 8 validation rules for APS documents
+├── filter/             # Task/module filtering
+│   └── index.ts        # Context bundle generation
+├── state/              # Task state management (844 lines)
+│   └── index.ts        # .anvil/state.json, locking
+├── templates/          # Template generation (607 lines)
+│   └── generator.ts    # Create .aps.md from prompts
+├── types/              # Zod schemas and TypeScript types
+│   └── index.ts        # APSDocument, Task, Module schemas
+└── index.ts            # Barrel exports with subpath access
+```
+
+## Where to Look
+
+| Task                | Location                 | Notes                        |
+| ------------------- | ------------------------ | ---------------------------- |
+| Add validation rule | `validator/index.ts`     | Follow existing rule pattern |
+| Modify parsing      | `parser/index.ts`        | Uses remark AST visitors     |
+| Add state operation | `state/index.ts`         | Modify state.json schema     |
+| Add template        | `templates/generator.ts` | Template string functions    |
+| Add filter          | `filter/index.ts`        | Task selection logic         |
+
+## Validation Rules
+
+8 built-in rules in `validator/index.ts`:
+
+| Rule                    | Purpose                              |
+| ----------------------- | ------------------------------------ |
+| `required-sections`     | Ensure mandatory sections exist      |
+| `task-format`           | Validate task ID format (TASK-001)   |
+| `task-intent`           | Tasks must have clear intent         |
+| `broken-links`          | Detect references to missing modules |
+| `duplicate-ids`         | No duplicate task/module IDs         |
+| `circular-dependencies` | Detect circular module dependencies  |
+| `scope-mismatch`        | Task scope matches module boundary   |
+| `orphan-modules`        | Modules must be referenced           |
+
+## Adding a Validation Rule
+
+```typescript
+// In validator/index.ts
+function validateMyRule(doc: APSDocument): ValidationIssue[] {
+  const issues: ValidationIssue[] = [];
+
+  // Check something...
+  if (condition) {
+    issues.push({
+      type: 'error', // or 'warning'
+      rule: 'my-rule',
+      message: 'What went wrong',
+      path: doc.path,
+      line: lineNumber, // Optional
+    });
+  }
+
+  return issues;
+}
+
+// Add to validateDocument():
+issues.push(...validateMyRule(doc));
+```
+
+## State Management
+
+Task execution state stored in `.anvil/state.json`:
+
+```typescript
+import {
+  loadState,
+  saveState,
+  lockTask,
+  unlockTask,
+} from '@eddacraft/anvil-aps/state';
+
+// Load current state
+const state = await loadState(projectRoot);
+
+// Lock a task for execution
+const lock = await lockTask(state, 'TASK-001', {
+  executor: 'user@example.com',
+  reason: 'Implementing feature',
+});
+
+// Update task status
+await updateTaskStatus(state, 'TASK-001', 'in_progress');
+
+// Unlock when done
+await unlockTask(state, 'TASK-001');
+```
+
+## Parser Usage
+
+```typescript
+import { parseAPSDocument } from '@eddacraft/anvil-aps/parser';
+
+const doc = await parseAPSDocument(content, { path: 'plans/index.aps.md' });
+
+// Access parsed structure
+doc.metadata; // Title, version, status
+doc.modules; // Array of Module objects
+doc.tasks; // Array of Task objects
+doc.dependencies; // Module dependency graph
+```
+
+## Template Generation
+
+```typescript
+import { generateTemplate } from '@eddacraft/anvil-aps/templates';
+
+const content = await generateTemplate('module', {
+  name: 'my-feature',
+  description: 'Implements something cool',
+  tasks: ['FEAT-001', 'FEAT-002'],
+});
+
+// Write to file
+await writeFile('plans/modules/my-feature.aps.md', content);
+```
+
+## Scripts
+
+```bash
+nx test aps                              # All APS tests
+nx test aps --testNamePattern="validator" # Validator tests only
+pnpm -F aps run generate:templates       # Regenerate template examples
+```
+
+## Anti-Patterns (This Package)
+
+- Never modify state.json directly - use state management functions
+- Never skip validation before loading documents
+- Always handle circular dependencies gracefully
+- Always preserve AST positions for error reporting
+
+## Testing
+
+- Fixture-based with realistic APS documents
+- Test files in `validator/__fixtures__/`, `parser/__fixtures__/`
+- Comprehensive edge cases for validation rules
+- State management tests with temp directories

package/LICENSE

@@ -0,0 +1,14 @@
+Copyright (c) 2026 EddaCraft. All rights reserved.
+
+PROPRIETARY AND CONFIDENTIAL
+
+This software and associated documentation files (the "Software") are the
+exclusive property of EddaCraft. Unauthorised copying, modification,
+distribution, or use of this Software, via any medium, is strictly prohibited
+without the express written permission of EddaCraft.
+
+The Software is provided for evaluation and testing purposes only to authorised
+beta testers. No licence is granted to use, copy, modify, or distribute the
+Software for any other purpose.
+
+For licensing enquiries, contact: legal@eddacraft.com

package/README.md

@@ -0,0 +1,57 @@
+# @eddacraft/anvil-aps
+
+Anvil Planning Spec (APS) library for parsing, loading, validating, and managing
+planning documents.
+
+## Overview
+
+The `@eddacraft/anvil-aps` package provides a complete toolkit for working with
+Anvil Planning Spec documents:
+
+- **Parser**: Parse Markdown-based planning documents using remark AST
+- **Loader**: Load and resolve planning document graphs with dependency tracking
+- **Validator**: Validate planning documents against APS rules
+- **State**: Manage task state and locking for concurrent execution
+
+## Installation
+
+```bash
+pnpm add @eddacraft/anvil-aps
+```
+
+## Usage
+
+Coming soon - see `docs/` directory for detailed documentation.
+
+## Documentation
+
+- [APS Planning Spec](./docs/APS-Planning-Spec-v0.1.md) - Full specification
+- [APS Conventions](./docs/APS-Conventions.md) - Markdown conventions and
+  patterns
+- [Non-Goals](./docs/APS-NonGoals.md) - What APS explicitly does not do
+- [Anvil Integration](./docs/APS-Anvil-Integration.md) - How APS integrates with
+  Anvil CLI
+
+## Development
+
+```bash
+# Build the package
+nx build aps
+
+# Run tests
+nx test aps
+
+# Run tests in watch mode
+nx test aps --watch
+
+# Type check
+pnpm typecheck
+
+# Lint
+nx lint aps
+```
+
+## Licence
+
+Copyright (c) 2026 EddaCraft. All rights reserved. See [LICENSE](../../LICENSE)
+for details.

package/TODO.md

@@ -0,0 +1,40 @@
+# APS Package Status
+
+> **Full Plan**: `plans/index.aps.md` (module: aps-markdown-adapter)
+>
+> This package is **complete**. See the plan document for adapter work.
+
+---
+
+## Package Status: Complete ✅
+
+The `@eddacraft/anvil-aps` library provides:
+
+- **Parser** — `parseDocument()`, `parseIndex()`, `parseTask()`
+- **Loader** — `loadPlan()` with multi-module support
+- **Filter** — `filterPlan()` with scope/tag/owner/task filtering
+- **Validator** — `validatePlanningDoc()` with issue reporting
+- **State** — Task locking/unlocking via `.anvil/state.json`
+- **Templates** — `generateIndexTemplate()`, `generateLeafTemplate()`
+
+### Test Coverage
+
+| Module    | Coverage  | Tests   |
+| --------- | --------- | ------- |
+| parser    | 89.5%     | 31      |
+| loader    | 96%       | 18      |
+| validator | 97.9%     | 27      |
+| state     | 94.2%     | 35      |
+| filter    | 89.6%     | 30      |
+| templates | 100%      | 26      |
+| **Total** | **93.1%** | **167** |
+
+---
+
+## Related Work
+
+See `plans/modules/aps-markdown-adapter.aps.md` for adapter integration.
+
+---
+
+_Last updated: January 2026_

package/dist/filter/context-bundle.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Context Bundle Builder
+ *
+ * Generates context bundles for LLM consumption from filtered plans.
+ * Outputs both text (Markdown) and JSON formats.
+ */
+import type { FilteredPlan } from './index.js';
+/**
+ * Context bundle in JSON format
+ */
+export interface ContextBundleJSON {
+    /** Plan title */
+    title: string;
+    /** Filter criteria that was applied */
+    filter: {
+        scopes?: string[];
+        modules?: string[];
+        tasks?: string[];
+        owners?: string[];
+        tags?: string[];
+        priorities?: string[];
+        confidences?: string[];
+    };
+    /** Summary statistics */
+    summary: {
+        totalModules: number;
+        totalTasks: number;
+        tasksByConfidence: {
+            high: number;
+            medium: number;
+            low: number;
+        };
+        tasksByStatus: {
+            open: number;
+            locked: number;
+            completed: number;
+            cancelled: number;
+        };
+    };
+    /** Modules with their tasks */
+    modules: Array<{
+        id: string;
+        scope?: string;
+        owner?: string;
+        priority?: string;
+        tags?: string[];
+        tasks: Array<{
+            id: string;
+            title: string;
+            intent: string;
+            confidence: string;
+            status: string;
+            scopes?: string[];
+            tags?: string[];
+            dependencies?: string[];
+            inputs?: string[];
+            expectedOutcome?: string;
+        }>;
+    }>;
+    /** Dependency graph (module -> dependencies) */
+    dependencyGraph: Record<string, string[]>;
+}
+/**
+ * Build a context bundle from a filtered plan
+ *
+ * @param filtered - The filtered plan
+ * @returns Context bundle in JSON format
+ */
+export declare function buildContextBundleJSON(filtered: FilteredPlan): ContextBundleJSON;
+/**
+ * Build a context bundle in Markdown text format
+ *
+ * @param filtered - The filtered plan
+ * @returns Markdown text suitable for LLM context
+ */
+export declare function buildContextBundleText(filtered: FilteredPlan): string;
+/**
+ * Build context for a single task (focused view)
+ */
+export declare function buildTaskContext(filtered: FilteredPlan, taskId: string): string | null;
+//# sourceMappingURL=context-bundle.d.ts.map

package/dist/filter/context-bundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-bundle.d.ts","sourceRoot":"","sources":["../../src/filter/context-bundle.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,iBAAiB;IACjB,KAAK,EAAE,MAAM,CAAC;IAEd,uCAAuC;IACvC,MAAM,EAAE;QACN,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;QAClB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;QACnB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;QACjB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;QAClB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;QAChB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;QACtB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;KACxB,CAAC;IAEF,yBAAyB;IACzB,OAAO,EAAE;QACP,YAAY,EAAE,MAAM,CAAC;QACrB,UAAU,EAAE,MAAM,CAAC;QACnB,iBAAiB,EAAE;YACjB,IAAI,EAAE,MAAM,CAAC;YACb,MAAM,EAAE,MAAM,CAAC;YACf,GAAG,EAAE,MAAM,CAAC;SACb,CAAC;QACF,aAAa,EAAE;YACb,IAAI,EAAE,MAAM,CAAC;YACb,MAAM,EAAE,MAAM,CAAC;YACf,SAAS,EAAE,MAAM,CAAC;YAClB,SAAS,EAAE,MAAM,CAAC;SACnB,CAAC;KACH,CAAC;IAEF,+BAA+B;IAC/B,OAAO,EAAE,KAAK,CAAC;QACb,EAAE,EAAE,MAAM,CAAC;QACX,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;QAChB,KAAK,EAAE,KAAK,CAAC;YACX,EAAE,EAAE,MAAM,CAAC;YACX,KAAK,EAAE,MAAM,CAAC;YACd,MAAM,EAAE,MAAM,CAAC;YACf,UAAU,EAAE,MAAM,CAAC;YACnB,MAAM,EAAE,MAAM,CAAC;YACf,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;YAClB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;YAChB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;YACxB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;YAClB,eAAe,CAAC,EAAE,MAAM,CAAC;SAC1B,CAAC,CAAC;KACJ,CAAC,CAAC;IAEH,gDAAgD;IAChD,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CAC3C;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,YAAY,GAAG,iBAAiB,CAqEhF;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,CA+FrE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CA2DtF"}

package/dist/filter/context-bundle.js

@@ -0,0 +1,230 @@
+/**
+ * Context Bundle Builder
+ *
+ * Generates context bundles for LLM consumption from filtered plans.
+ * Outputs both text (Markdown) and JSON formats.
+ */
+/**
+ * Build a context bundle from a filtered plan
+ *
+ * @param filtered - The filtered plan
+ * @returns Context bundle in JSON format
+ */
+export function buildContextBundleJSON(filtered) {
+    const { plan, modules, tasks, criteria } = filtered;
+    // Build summary statistics
+    const summary = {
+        totalModules: modules.length,
+        totalTasks: tasks.length,
+        tasksByConfidence: {
+            high: tasks.filter((t) => t.confidence === 'high').length,
+            medium: tasks.filter((t) => t.confidence === 'medium').length,
+            low: tasks.filter((t) => t.confidence === 'low').length,
+        },
+        tasksByStatus: {
+            open: tasks.filter((t) => (t.status ?? 'open') === 'open').length,
+            locked: tasks.filter((t) => t.status === 'locked').length,
+            completed: tasks.filter((t) => t.status === 'completed').length,
+            cancelled: tasks.filter((t) => t.status === 'cancelled').length,
+        },
+    };
+    // Build module data with tasks
+    const moduleData = modules.map((module) => {
+        const moduleTasks = tasks.filter((t) => module.tasks.some((mt) => mt.id === t.id));
+        return {
+            id: module.id,
+            scope: module.metadata.scope,
+            owner: module.metadata.owner,
+            priority: module.metadata.priority,
+            tags: module.metadata.tags,
+            tasks: moduleTasks.map((t) => ({
+                id: t.id,
+                title: t.title,
+                intent: t.intent,
+                confidence: t.confidence,
+                status: t.status ?? 'open',
+                scopes: t.scopes,
+                tags: t.tags,
+                dependencies: t.dependencies,
+                inputs: t.inputs,
+                expectedOutcome: t.expectedOutcome,
+            })),
+        };
+    });
+    // Build dependency graph for filtered modules
+    const dependencyGraph = {};
+    for (const module of modules) {
+        const deps = plan.dependencyGraph.get(module.id) ?? [];
+        // Only include dependencies that are in the filtered set
+        const filteredDeps = deps.filter((d) => modules.some((m) => m.id === d));
+        dependencyGraph[module.id] = filteredDeps;
+    }
+    return {
+        title: plan.title,
+        filter: {
+            scopes: criteria.scopes,
+            modules: criteria.modules,
+            tasks: criteria.tasks,
+            owners: criteria.owners,
+            tags: criteria.tags,
+            priorities: criteria.priorities,
+            confidences: criteria.confidences,
+        },
+        summary,
+        modules: moduleData,
+        dependencyGraph,
+    };
+}
+/**
+ * Build a context bundle in Markdown text format
+ *
+ * @param filtered - The filtered plan
+ * @returns Markdown text suitable for LLM context
+ */
+export function buildContextBundleText(filtered) {
+    const { plan, modules, tasks, criteria } = filtered;
+    const lines = [];
+    // Header
+    lines.push(`# ${plan.title}`);
+    lines.push('');
+    // Filter info
+    const filterParts = [];
+    if (criteria.scopes?.length)
+        filterParts.push(`scopes: ${criteria.scopes.join(', ')}`);
+    if (criteria.modules?.length)
+        filterParts.push(`modules: ${criteria.modules.join(', ')}`);
+    if (criteria.tasks?.length)
+        filterParts.push(`tasks: ${criteria.tasks.join(', ')}`);
+    if (criteria.owners?.length)
+        filterParts.push(`owners: ${criteria.owners.join(', ')}`);
+    if (criteria.tags?.length)
+        filterParts.push(`tags: ${criteria.tags.join(', ')}`);
+    if (criteria.priorities?.length)
+        filterParts.push(`priorities: ${criteria.priorities.join(', ')}`);
+    if (criteria.confidences?.length)
+        filterParts.push(`confidences: ${criteria.confidences.join(', ')}`);
+    if (filterParts.length > 0) {
+        lines.push(`> Filtered by: ${filterParts.join('; ')}`);
+        lines.push('');
+    }
+    // Summary
+    lines.push('## Summary');
+    lines.push('');
+    lines.push(`- **Modules:** ${modules.length}`);
+    lines.push(`- **Tasks:** ${tasks.length}`);
+    const highConfidence = tasks.filter((t) => t.confidence === 'high').length;
+    const mediumConfidence = tasks.filter((t) => t.confidence === 'medium').length;
+    const lowConfidence = tasks.filter((t) => t.confidence === 'low').length;
+    lines.push(`- **Confidence:** ${highConfidence} high, ${mediumConfidence} medium, ${lowConfidence} low`);
+    const openTasks = tasks.filter((t) => (t.status ?? 'open') === 'open').length;
+    const lockedTasks = tasks.filter((t) => t.status === 'locked').length;
+    const completedTasks = tasks.filter((t) => t.status === 'completed').length;
+    lines.push(`- **Status:** ${openTasks} open, ${lockedTasks} locked, ${completedTasks} completed`);
+    lines.push('');
+    // Modules and tasks
+    for (const module of modules) {
+        lines.push(`## Module: ${module.id}`);
+        lines.push('');
+        if (module.metadata.scope)
+            lines.push(`**Scope:** ${module.metadata.scope}`);
+        if (module.metadata.owner)
+            lines.push(`**Owner:** ${module.metadata.owner}`);
+        if (module.metadata.priority)
+            lines.push(`**Priority:** ${module.metadata.priority}`);
+        if (module.metadata.tags?.length)
+            lines.push(`**Tags:** ${module.metadata.tags.join(', ')}`);
+        const deps = plan.dependencyGraph.get(module.id) ?? [];
+        if (deps.length > 0)
+            lines.push(`**Dependencies:** ${deps.join(', ')}`);
+        lines.push('');
+        // Tasks for this module
+        const moduleTasks = tasks.filter((t) => module.tasks.some((mt) => mt.id === t.id));
+        if (moduleTasks.length === 0) {
+            lines.push('*No tasks match the filter criteria.*');
+            lines.push('');
+            continue;
+        }
+        lines.push('### Tasks');
+        lines.push('');
+        for (const task of moduleTasks) {
+            lines.push(`#### ${task.id}: ${task.title}`);
+            lines.push('');
+            lines.push(`**Intent:** ${task.intent}`);
+            lines.push(`**Confidence:** ${task.confidence}`);
+            lines.push(`**Status:** ${task.status ?? 'open'}`);
+            if (task.scopes?.length)
+                lines.push(`**Scopes:** ${task.scopes.join(', ')}`);
+            if (task.tags?.length)
+                lines.push(`**Tags:** ${task.tags.join(', ')}`);
+            if (task.dependencies?.length)
+                lines.push(`**Dependencies:** ${task.dependencies.join(', ')}`);
+            if (task.expectedOutcome)
+                lines.push(`**Expected Outcome:** ${task.expectedOutcome}`);
+            if (task.inputs?.length) {
+                lines.push('**Inputs:**');
+                for (const input of task.inputs) {
+                    lines.push(`- ${input}`);
+                }
+            }
+            lines.push('');
+        }
+    }
+    return lines.join('\n');
+}
+/**
+ * Build context for a single task (focused view)
+ */
+export function buildTaskContext(filtered, taskId) {
+    const task = filtered.tasks.find((t) => t.id === taskId);
+    if (!task)
+        return null;
+    const lines = [];
+    lines.push(`# Task: ${task.id}`);
+    lines.push('');
+    lines.push(`## ${task.title}`);
+    lines.push('');
+    lines.push(`**Intent:** ${task.intent}`);
+    lines.push('');
+    lines.push(`**Confidence:** ${task.confidence}`);
+    lines.push(`**Status:** ${task.status ?? 'open'}`);
+    if (task.scopes?.length) {
+        lines.push('');
+        lines.push(`**Scopes:** ${task.scopes.join(', ')}`);
+        lines.push('');
+        lines.push('> These scopes define what files/modules this task is allowed to modify.');
+    }
+    if (task.tags?.length) {
+        lines.push('');
+        lines.push(`**Tags:** ${task.tags.join(', ')}`);
+    }
+    if (task.dependencies?.length) {
+        lines.push('');
+        lines.push('## Dependencies');
+        lines.push('');
+        lines.push('This task depends on:');
+        for (const dep of task.dependencies) {
+            const depTask = filtered.plan.allTasks.find((t) => t.id === dep);
+            if (depTask) {
+                lines.push(`- **${dep}:** ${depTask.title} (${depTask.status ?? 'open'})`);
+            }
+            else {
+                lines.push(`- **${dep}:** (not found)`);
+            }
+        }
+    }
+    if (task.inputs?.length) {
+        lines.push('');
+        lines.push('## Inputs');
+        lines.push('');
+        for (const input of task.inputs) {
+            lines.push(`- ${input}`);
+        }
+    }
+    if (task.expectedOutcome) {
+        lines.push('');
+        lines.push('## Expected Outcome');
+        lines.push('');
+        lines.push(task.expectedOutcome);
+    }
+    return lines.join('\n');
+}

package/dist/filter/index.d.ts

@@ -0,0 +1,85 @@
+/**
+ * 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.
+ */
+export { buildContextBundleJSON, buildContextBundleText, buildTaskContext, type ContextBundleJSON, } from './context-bundle.js';
+import type { LoadedPlan, LoadedModule } from '../loader/index.js';
+import type { Task, Priority, Confidence } from '../types/index.js';
+/**
+ * Filter criteria for tasks and modules
+ */
+export interface FilterCriteria {
+    /** Filter by scope (matches module scope or task scopes) */
+    scopes?: string[];
+    /** Filter by module ID */
+    modules?: string[];
+    /** Filter by specific task IDs */
+    tasks?: string[];
+    /** Filter by owner (e.g., @alice) */
+    owners?: string[];
+    /** Filter by tags (matches any) */
+    tags?: string[];
+    /** Filter by priority levels */
+    priorities?: Priority[];
+    /** Filter by confidence levels */
+    confidences?: Confidence[];
+    /** Filter by task status */
+    statuses?: Array<'open' | 'locked' | 'completed' | 'cancelled'>;
+}
+/**
+ * Result of filtering a plan
+ */
+export interface FilteredPlan {
+    /** Original plan reference */
+    plan: LoadedPlan;
+    /** Filtered modules (only those matching criteria) */
+    modules: LoadedModule[];
+    /** Filtered tasks (only those matching criteria) */
+    tasks: Task[];
+    /** Applied filter criteria */
+    criteria: FilterCriteria;
+}
+/**
+ * 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 declare function filterPlan(plan: LoadedPlan, criteria: FilterCriteria): FilteredPlan;
+/**
+ * Filter tasks by scope (convenience function)
+ */
+export declare function filterByScope(plan: LoadedPlan, scopes: string[]): Task[];
+/**
+ * Filter tasks by module (convenience function)
+ */
+export declare function filterByModule(plan: LoadedPlan, moduleIds: string[]): Task[];
+/**
+ * Filter tasks by tags (convenience function)
+ */
+export declare function filterByTags(plan: LoadedPlan, tags: string[]): Task[];
+/**
+ * Filter tasks by owner (convenience function)
+ */
+export declare function filterByOwner(plan: LoadedPlan, owners: string[]): Task[];
+/**
+ * Filter tasks by priority (convenience function)
+ */
+export declare function filterByPriority(plan: LoadedPlan, priorities: Priority[]): Task[];
+/**
+ * Filter tasks by confidence (convenience function)
+ */
+export declare function filterByConfidence(plan: LoadedPlan, confidences: Confidence[]): Task[];
+/**
+ * Get tasks matching specific IDs
+ */
+export declare function getTasksById(plan: LoadedPlan, taskIds: string[]): Task[];
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/filter/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACtB,gBAAgB,EAChB,KAAK,iBAAiB,GACvB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACnE,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpE;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,4DAA4D;IAC5D,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAElB,0BAA0B;IAC1B,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAEnB,kCAAkC;IAClC,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IAEjB,qCAAqC;IACrC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAElB,mCAAmC;IACnC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAEhB,gCAAgC;IAChC,UAAU,CAAC,EAAE,QAAQ,EAAE,CAAC;IAExB,kCAAkC;IAClC,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;IAE3B,4BAA4B;IAC5B,QAAQ,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,QAAQ,GAAG,WAAW,GAAG,WAAW,CAAC,CAAC;CACjE;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,8BAA8B;IAC9B,IAAI,EAAE,UAAU,CAAC;IAEjB,sDAAsD;IACtD,OAAO,EAAE,YAAY,EAAE,CAAC;IAExB,oDAAoD;IACpD,KAAK,EAAE,IAAI,EAAE,CAAC;IAEd,8BAA8B;IAC9B,QAAQ,EAAE,cAAc,CAAC;CAC1B;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,cAAc,GAAG,YAAY,CA+GnF;AAcD;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,CAExE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,CAE5E;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,CAErE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,CAExE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,QAAQ,EAAE,GAAG,IAAI,EAAE,CAEjF;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,EAAE,GAAG,IAAI,EAAE,CAEtF;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,CAExE"}