@eddacraft/anvil-aps 0.1.0

package/dist/templates/index.js

@@ -0,0 +1,4 @@
+/**
+ * Template generation for APS planning documents
+ */
+export * from './generator.js';

package/dist/types/index.d.ts

@@ -0,0 +1,131 @@
+/**
+ * APS type definitions and schemas
+ */
+import { z } from 'zod';
+/**
+ * Task confidence levels
+ */
+export declare const ConfidenceSchema: z.ZodEnum<{
+    low: "low";
+    medium: "medium";
+    high: "high";
+}>;
+export type Confidence = z.infer<typeof ConfidenceSchema>;
+/**
+ * Task status values
+ * Note: Status is managed externally in .anvil/state.json
+ */
+export declare const TaskStatusSchema: z.ZodEnum<{
+    open: "open";
+    locked: "locked";
+    completed: "completed";
+    cancelled: "cancelled";
+}>;
+export type TaskStatus = z.infer<typeof TaskStatusSchema>;
+/**
+ * Priority levels
+ */
+export declare const PrioritySchema: z.ZodEnum<{
+    low: "low";
+    medium: "medium";
+    high: "high";
+}>;
+export type Priority = z.infer<typeof PrioritySchema>;
+/**
+ * Parsed task from APS document
+ */
+/** Task ID regex: 1-10 uppercase alphanumeric scope, hyphen, 3-digit zero-padded number */
+export declare const TASK_ID_REGEX: RegExp;
+export declare const TaskSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    intent: z.ZodString;
+    expectedOutcome: z.ZodOptional<z.ZodString>;
+    validation: z.ZodOptional<z.ZodString>;
+    confidence: z.ZodDefault<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>>;
+    scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    nonScope: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    dependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    inputs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    risks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    packages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    link: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        locked: "locked";
+        completed: "completed";
+        cancelled: "cancelled";
+    }>>;
+    sourcePath: z.ZodOptional<z.ZodString>;
+    sourceLineNumber: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type Task = z.infer<typeof TaskSchema>;
+/**
+ * Module status values
+ * Legacy values (Draft, Complete) are accepted during parsing but normalised
+ * to their canonical equivalents (Proposed, Done).
+ */
+export declare const ModuleStatusSchema: z.ZodEnum<{
+    Proposed: "Proposed";
+    Ready: "Ready";
+    "In Progress": "In Progress";
+    Done: "Done";
+    Blocked: "Blocked";
+}>;
+export type ModuleStatus = z.infer<typeof ModuleStatusSchema>;
+/**
+ * Module metadata from index files or leaf spec headers
+ */
+export declare const ModuleMetadataSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        Proposed: "Proposed";
+        Ready: "Ready";
+        "In Progress": "In Progress";
+        Done: "Done";
+        Blocked: "Blocked";
+    }>>;
+    priority: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    dependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    packages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type ModuleMetadata = z.infer<typeof ModuleMetadataSchema>;
+/**
+ * Parsed leaf spec document result
+ * For index files, use ParsedIndex from the parser module
+ */
+export interface ParsedDocument {
+    /** Document title from H1 */
+    title: string;
+    /** Module metadata from header line */
+    metadata?: ModuleMetadata;
+    /** List of tasks */
+    tasks: Task[];
+    /** Source file path */
+    sourcePath?: string;
+}
+/**
+ * Parser error with context
+ */
+export declare class ParseError extends Error {
+    readonly sourcePath?: string | undefined;
+    readonly lineNumber?: number | undefined;
+    readonly context?: string | undefined;
+    constructor(message: string, sourcePath?: string | undefined, lineNumber?: number | undefined, context?: string | undefined);
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;EAAoC,CAAC;AAClE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;EAAuD,CAAC;AACrF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D;;GAEG;AACH,eAAO,MAAM,cAAc;;;;EAAoC,CAAC;AAChE,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD;;GAEG;AACH,2FAA2F;AAC3F,eAAO,MAAM,aAAa,QAA2B,CAAC;AAEtD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsDrB,CAAC;AAEH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAE9C;;;;GAIG;AACH,eAAO,MAAM,kBAAkB;;;;;;EAAkE,CAAC;AAClG,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;iBA8B/B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,6BAA6B;IAC7B,KAAK,EAAE,MAAM,CAAC;IAEd,uCAAuC;IACvC,QAAQ,CAAC,EAAE,cAAc,CAAC;IAE1B,oBAAoB;IACpB,KAAK,EAAE,IAAI,EAAE,CAAC;IAEd,uBAAuB;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,qBAAa,UAAW,SAAQ,KAAK;aAGjB,UAAU,CAAC,EAAE,MAAM;aACnB,UAAU,CAAC,EAAE,MAAM;aACnB,OAAO,CAAC,EAAE,MAAM;gBAHhC,OAAO,EAAE,MAAM,EACC,UAAU,CAAC,EAAE,MAAM,YAAA,EACnB,UAAU,CAAC,EAAE,MAAM,YAAA,EACnB,OAAO,CAAC,EAAE,MAAM,YAAA;CAKnC"}

package/dist/types/index.js

@@ -0,0 +1,107 @@
+/**
+ * APS type definitions and schemas
+ */
+import { z } from 'zod';
+/**
+ * Task confidence levels
+ */
+export const ConfidenceSchema = z.enum(['low', 'medium', 'high']);
+/**
+ * Task status values
+ * Note: Status is managed externally in .anvil/state.json
+ */
+export const TaskStatusSchema = z.enum(['open', 'locked', 'completed', 'cancelled']);
+/**
+ * Priority levels
+ */
+export const PrioritySchema = z.enum(['low', 'medium', 'high']);
+/**
+ * Parsed task from APS document
+ */
+/** Task ID regex: 1-10 uppercase alphanumeric scope, hyphen, 3-digit zero-padded number */
+export const TASK_ID_REGEX = /^[A-Z0-9]{1,10}-\d{3}$/;
+export const TaskSchema = z.object({
+    /** Task ID in format SCOPE-NUMBER (e.g., AUTH-001, LLM2-007) */
+    id: z.string().regex(TASK_ID_REGEX),
+    /** Task title (after the ID and colon in H3 heading) */
+    title: z.string(),
+    /** What the task aims to achieve (required) */
+    intent: z.string(),
+    /** Success criteria (optional) */
+    expectedOutcome: z.string().optional(),
+    /** Command or method to verify task completion (optional) */
+    validation: z.string().optional(),
+    /** Certainty about approach (optional, defaults to 'medium') */
+    confidence: ConfidenceSchema.default('medium'),
+    /** What can be changed - LLM file access constraints (optional) */
+    scopes: z.array(z.string()).optional(),
+    /** What will NOT be changed (optional) */
+    nonScope: z.array(z.string()).optional(),
+    /** Best-effort list of files that may be affected (optional) */
+    files: z.array(z.string()).optional(),
+    /** Labels for filtering and search (optional) */
+    tags: z.array(z.string()).optional(),
+    /** Tasks that must complete first (optional) */
+    dependencies: z.array(z.string()).optional(),
+    /** Required inputs or context (optional) */
+    inputs: z.array(z.string()).optional(),
+    /** Potential risks associated with this task (optional) */
+    risks: z.array(z.string()).optional(),
+    /** Packages affected by this task (monorepo support) */
+    packages: z.array(z.string()).optional(),
+    /** External link (e.g., Jira ticket) (optional) */
+    link: z.string().optional(),
+    /** Current execution state (optional, managed externally) */
+    status: TaskStatusSchema.optional(),
+    /** Source file path where this task was parsed from */
+    sourcePath: z.string().optional(),
+    /** Line number in source file where this task starts */
+    sourceLineNumber: z.number().optional(),
+});
+/**
+ * Module status values
+ * Legacy values (Draft, Complete) are accepted during parsing but normalised
+ * to their canonical equivalents (Proposed, Done).
+ */
+export const ModuleStatusSchema = z.enum(['Proposed', 'Ready', 'In Progress', 'Done', 'Blocked']);
+/**
+ * Module metadata from index files or leaf spec headers
+ */
+export const ModuleMetadataSchema = z.object({
+    /** Module identifier (e.g., 'auth', 'payments') */
+    id: z.string().optional(),
+    /** Module title from H1 heading */
+    title: z.string().optional(),
+    /** Path to leaf spec file (for index files) */
+    path: z.string().optional(),
+    /** Scope prefix for task IDs (e.g., AUTH, PAY) */
+    scope: z.string().optional(),
+    /** Person/team responsible */
+    owner: z.string().optional(),
+    /** Current module status */
+    status: ModuleStatusSchema.optional(),
+    /** Priority level */
+    priority: PrioritySchema.optional(),
+    /** Tags for filtering */
+    tags: z.array(z.string()).optional(),
+    /** Modules this depends on */
+    dependencies: z.array(z.string()).optional(),
+    /** Packages affected by this module (monorepo support) */
+    packages: z.array(z.string()).optional(),
+});
+/**
+ * Parser error with context
+ */
+export class ParseError extends Error {
+    sourcePath;
+    lineNumber;
+    context;
+    constructor(message, sourcePath, lineNumber, context) {
+        super(message);
+        this.sourcePath = sourcePath;
+        this.lineNumber = lineNumber;
+        this.context = context;
+        this.name = 'ParseError';
+    }
+}
+// ValidationResult is exported from validator/index.ts

package/dist/validator/index.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Validator module - Validation rules for APS planning documents
+ *
+ * Provides validation for:
+ * - Required sections (Index: ## Modules, Leaf: ## Tasks)
+ * - Task format (ID, Intent required)
+ * - Duplicate task IDs across plan graph
+ * - Broken module links
+ * - Scope mismatches (warning)
+ * - Missing Confidence (warning)
+ * - Missing Expected Outcome (warning)
+ * - Missing Validation/Test (warning)
+ * - Orphan leaf specs (warning)
+ * - Circular module dependencies
+ */
+/**
+ * Validation issue severity
+ */
+export type ValidationSeverity = 'error' | 'warning';
+/**
+ * A single validation issue
+ */
+export interface ValidationIssue {
+    /** Severity level */
+    severity: ValidationSeverity;
+    /** Human-readable message */
+    message: string;
+    /** Rule that triggered this issue */
+    rule: string;
+    /** File path where the issue was found */
+    path?: string;
+    /** Line number in the file (1-based) */
+    lineNumber?: number;
+    /** Additional context */
+    context?: string;
+}
+/**
+ * Result of validating a planning document
+ */
+export interface ValidationResult {
+    /** Whether the document is valid (no errors, warnings allowed) */
+    valid: boolean;
+    /** List of all issues found */
+    issues: ValidationIssue[];
+    /** Just the errors */
+    errors: ValidationIssue[];
+    /** Just the warnings */
+    warnings: ValidationIssue[];
+}
+/**
+ * Options for validation
+ */
+export interface ValidateOptions {
+    /** Base directory for resolving relative paths */
+    baseDir?: string;
+    /** Whether to recursively validate linked modules (default: true) */
+    recursive?: boolean;
+    /** Rules to skip (by rule name) */
+    skipRules?: string[];
+}
+/**
+ * Validate an APS planning document
+ *
+ * @param filePath - Path to the planning document (index or leaf spec)
+ * @param options - Validation options
+ * @returns Validation result with errors and warnings
+ *
+ * @example
+ * ```typescript
+ * const result = await validatePlanningDoc('docs/planning/APS.md');
+ * if (!result.valid) {
+ *   for (const error of result.errors) {
+ *     console.error(`${error.path}:${error.lineNumber}: ${error.message}`);
+ *   }
+ * }
+ * ```
+ */
+export declare function validatePlanningDoc(filePath: string, options?: ValidateOptions): Promise<ValidationResult>;
+/**
+ * Format validation issues for display
+ */
+export declare function formatValidationIssues(result: ValidationResult): string;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/validator/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAWH;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,SAAS,CAAC;AAErD;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,qBAAqB;IACrB,QAAQ,EAAE,kBAAkB,CAAC;IAE7B,6BAA6B;IAC7B,OAAO,EAAE,MAAM,CAAC;IAEhB,qCAAqC;IACrC,IAAI,EAAE,MAAM,CAAC;IAEb,0CAA0C;IAC1C,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,wCAAwC;IACxC,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB,yBAAyB;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,kEAAkE;IAClE,KAAK,EAAE,OAAO,CAAC;IAEf,+BAA+B;IAC/B,MAAM,EAAE,eAAe,EAAE,CAAC;IAE1B,sBAAsB;IACtB,MAAM,EAAE,eAAe,EAAE,CAAC;IAE1B,wBAAwB;IACxB,QAAQ,EAAE,eAAe,EAAE,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,kDAAkD;IAClD,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,qEAAqE;IACrE,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB,mCAAmC;IACnC,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,gBAAgB,CAAC,CAqF3B;AA8iBD;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,CAyBvE"}