@eddacraft/anvil-aps 0.1.0

package/dist/parser/parse-task.js

@@ -0,0 +1,261 @@
+/**
+ * Task parsing utilities
+ * Extracts task information from Markdown AST nodes
+ */
+import { ParseError } from '../types/index.js';
+/**
+ * Extract task ID and title from H3 heading text
+ * Format: "SCOPE-NUMBER: Task title"
+ * - Scope: 1-10 uppercase alphanumeric characters
+ * - Number: 3-digit zero-padded (001-999)
+ */
+export function parseTaskHeading(heading) {
+    if (heading.depth !== 3) {
+        throw new ParseError('Task headings must be H3 (###)', undefined, undefined, 'parseTaskHeading');
+    }
+    const text = extractPlainText(heading);
+    // Extract ID and title - ID must match TASK_ID_REGEX format
+    const match = text.match(/^([A-Z0-9]{1,10}-\d{3}):\s*(.+)$/);
+    if (!match) {
+        throw new ParseError(`Invalid task heading format. Expected "SCOPE-NNN: Title" (e.g., AUTH-001), got: "${text}"`, undefined, undefined, 'parseTaskHeading');
+    }
+    return {
+        id: match[1],
+        title: match[2].trim(),
+    };
+}
+/**
+ * Extract plain text from AST node (handles inline formatting)
+ */
+function extractPlainText(node) {
+    if ('value' in node && typeof node.value === 'string') {
+        return node.value;
+    }
+    if ('children' in node && Array.isArray(node.children)) {
+        return node.children.map((child) => extractPlainText(child)).join('');
+    }
+    return '';
+}
+/**
+ * Parse task fields from paragraph and list nodes
+ * Fields are in format: **FieldName:** value
+ */
+export function parseTaskFields(paragraphs, lists) {
+    const fields = {};
+    let lastField = null;
+    let inlineInputs = null;
+    // First pass: extract all field key-value pairs from paragraphs
+    for (const para of paragraphs) {
+        const fieldMatches = extractFieldsFromParagraph(para);
+        for (const [key, value] of Object.entries(fieldMatches)) {
+            // Handle Inputs specially - may be inline text or followed by a list
+            if (key === 'Inputs') {
+                if (value.trim() === '') {
+                    // Empty value - expect a list to follow
+                    lastField = key;
+                }
+                else {
+                    // Inline text value - store for later (list takes precedence if present)
+                    inlineInputs = value.trim();
+                    lastField = key;
+                }
+                continue;
+            }
+            assignField(fields, key, value);
+            lastField = key;
+        }
+    }
+    // Second pass: handle Inputs field
+    // Lists take precedence over inline text
+    if (lastField === 'Inputs' && lists.length > 0) {
+        fields.inputs = extractListItems(lists[0]);
+    }
+    else if (inlineInputs !== null) {
+        // Use inline text as a single-item array
+        fields.inputs = [inlineInputs];
+    }
+    return fields;
+}
+/**
+ * Extract field key-value pairs from a paragraph containing bold markers
+ */
+function extractFieldsFromParagraph(para) {
+    const fields = {};
+    let currentKey = '';
+    let currentValue = '';
+    let inField = false;
+    for (const child of para.children) {
+        if (child.type === 'strong') {
+            // Check if this strong node contains a field name
+            const strongText = extractPlainText(child);
+            const fieldMatch = strongText.match(/^([\w-]+(?:\s+[\w-]+)*):$/);
+            if (fieldMatch) {
+                // Save previous field if exists (even if value is empty)
+                if (currentKey) {
+                    fields[currentKey] = currentValue.trim().replace(/\s+/g, ' ');
+                }
+                currentKey = fieldMatch[1];
+                currentValue = '';
+                inField = true;
+            }
+        }
+        else if (inField) {
+            // Extract text from any phrasing content node (text, inlineCode, etc.)
+            // This handles validation commands in backticks and other inline formatting
+            if (child.type === 'break') {
+                // Convert breaks to spaces to handle multi-line values
+                currentValue += ' ';
+            }
+            else {
+                currentValue += extractPlainText(child);
+            }
+        }
+    }
+    // Save last field (even if value is empty)
+    if (currentKey) {
+        fields[currentKey] = currentValue.trim().replace(/\s+/g, ' ');
+    }
+    return fields;
+}
+/**
+ * Assign a parsed field value to the appropriate Task property
+ */
+function assignField(task, key, value) {
+    const normalizedKey = key.replace(/\s+/g, '');
+    switch (normalizedKey) {
+        case 'Intent':
+            task.intent = value;
+            break;
+        case 'ExpectedOutcome':
+            task.expectedOutcome = value;
+            break;
+        case 'Validation':
+        case 'Test':
+            // Support both "Validation:" and "Test:" field names per APS spec
+            task.validation = value;
+            break;
+        case 'Confidence':
+            task.confidence = parseConfidence(value);
+            break;
+        case 'Scopes':
+            task.scopes = parseCommaSeparated(value);
+            break;
+        case 'NonScope':
+        case 'Non-scope':
+            task.nonScope = parseCommaSeparated(value);
+            break;
+        case 'Files':
+            task.files = parseCommaSeparated(value);
+            break;
+        case 'Tags':
+            task.tags = parseCommaSeparated(value);
+            break;
+        case 'Dependencies':
+            task.dependencies = parseCommaSeparated(value);
+            break;
+        case 'Risks':
+            task.risks = parseCommaSeparated(value);
+            break;
+        case 'Packages': {
+            // Monorepo support: list of affected packages
+            const trimmed = value.trim();
+            if (!trimmed || trimmed.toLowerCase() === '(none)') {
+                task.packages = [];
+            }
+            else {
+                task.packages = parseCommaSeparated(value);
+            }
+            break;
+        }
+        case 'Link':
+            task.link = value;
+            break;
+        case 'Status':
+            task.status = parseStatus(value);
+            break;
+        // 'Inputs' is handled separately as a list
+    }
+}
+/**
+ * Parse confidence value from string
+ */
+function parseConfidence(value) {
+    const normalized = value.toLowerCase().trim();
+    if (normalized === 'low' || normalized === 'medium' || normalized === 'high') {
+        return normalized;
+    }
+    return 'medium'; // default
+}
+/**
+ * Parse task status from string
+ */
+function parseStatus(value) {
+    const normalized = value.toLowerCase().trim();
+    if (normalized === 'open' ||
+        normalized === 'locked' ||
+        normalized === 'completed' ||
+        normalized === 'cancelled') {
+        return normalized;
+    }
+    return 'open'; // default
+}
+/**
+ * Parse comma-separated list into array
+ */
+function parseCommaSeparated(value) {
+    return value
+        .split(',')
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0);
+}
+/**
+ * Extract list items as strings
+ */
+function extractListItems(list) {
+    const items = [];
+    for (const item of list.children) {
+        if (item.type === 'listItem' && item.children.length > 0) {
+            const firstChild = item.children[0];
+            if (firstChild && firstChild.type === 'paragraph') {
+                items.push(extractPlainText(firstChild));
+            }
+        }
+    }
+    return items;
+}
+/**
+ * Parse a complete task from AST nodes
+ * @param heading - H3 heading node with task ID and title
+ * @param content - Array of paragraph and list nodes containing task fields
+ * @param sourcePath - Optional source file path
+ * @param lineNumber - Optional line number where task starts
+ */
+export function parseTask(heading, content, sourcePath, lineNumber) {
+    const { id, title } = parseTaskHeading(heading);
+    const paragraphs = content.filter((node) => node.type === 'paragraph');
+    const lists = content.filter((node) => node.type === 'list');
+    const fields = parseTaskFields(paragraphs, lists);
+    if (!fields.intent) {
+        throw new ParseError(`Task ${id} is missing required field: Intent`, sourcePath, lineNumber, 'parseTask');
+    }
+    return {
+        id,
+        title,
+        intent: fields.intent,
+        expectedOutcome: fields.expectedOutcome,
+        validation: fields.validation,
+        confidence: fields.confidence ?? 'medium',
+        scopes: fields.scopes,
+        nonScope: fields.nonScope,
+        files: fields.files,
+        tags: fields.tags,
+        dependencies: fields.dependencies,
+        inputs: fields.inputs,
+        risks: fields.risks,
+        packages: fields.packages,
+        link: fields.link,
+        status: fields.status,
+        sourcePath,
+        sourceLineNumber: lineNumber,
+    };
+}

package/dist/state/index.d.ts

@@ -0,0 +1,307 @@
+/**
+ * State module - Task state management and locking functionality
+ *
+ * Manages `.anvil/state.json` for tracking task execution states.
+ * Provides TaskLocker for locking tasks for execution with:
+ * - First-lock-wins concurrent lock handling
+ * - Execution plan JSON generation with hash and provenance
+ * - Lock/unlock/status operations
+ */
+import { z } from 'zod';
+import { type Task, type TaskStatus } from '../types/index.js';
+/**
+ * Source location of a task in a planning document
+ */
+export declare const TaskSourceSchema: z.ZodObject<{
+    file: z.ZodString;
+    line: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type TaskSource = z.infer<typeof TaskSourceSchema>;
+/**
+ * State of a single task
+ */
+export declare const TaskStateSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        open: "open";
+        locked: "locked";
+        completed: "completed";
+        cancelled: "cancelled";
+    }>;
+    locked_at: z.ZodOptional<z.ZodString>;
+    locked_by: z.ZodOptional<z.ZodString>;
+    execution_file: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodObject<{
+        file: z.ZodString;
+        line: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    completed_at: z.ZodOptional<z.ZodString>;
+    cancelled_at: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type TaskState = z.infer<typeof TaskStateSchema>;
+/**
+ * Full state file schema (.anvil/state.json)
+ */
+export declare const StateFileSchema: z.ZodObject<{
+    version: z.ZodDefault<z.ZodString>;
+    tasks: z.ZodRecord<z.ZodString, z.ZodObject<{
+        status: z.ZodEnum<{
+            open: "open";
+            locked: "locked";
+            completed: "completed";
+            cancelled: "cancelled";
+        }>;
+        locked_at: z.ZodOptional<z.ZodString>;
+        locked_by: z.ZodOptional<z.ZodString>;
+        execution_file: z.ZodOptional<z.ZodString>;
+        source: z.ZodOptional<z.ZodObject<{
+            file: z.ZodString;
+            line: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        completed_at: z.ZodOptional<z.ZodString>;
+        cancelled_at: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type StateFile = z.infer<typeof StateFileSchema>;
+/**
+ * Provenance information for execution plans
+ */
+export declare const ProvenanceSchema: z.ZodObject<{
+    locked_by: z.ZodString;
+    locked_at: z.ZodString;
+    git_commit: z.ZodOptional<z.ZodString>;
+    git_branch: z.ZodOptional<z.ZodString>;
+    source_file: z.ZodString;
+    source_line: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type Provenance = z.infer<typeof ProvenanceSchema>;
+/**
+ * Execution plan JSON schema (per-task, written to .anvil/executions/)
+ */
+export declare const ExecutionPlanSchema: z.ZodObject<{
+    version: z.ZodDefault<z.ZodString>;
+    task_id: z.ZodString;
+    title: z.ZodString;
+    intent: z.ZodString;
+    expected_outcome: z.ZodOptional<z.ZodString>;
+    confidence: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>;
+    scopes: 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>>;
+    content_hash: z.ZodString;
+    provenance: z.ZodObject<{
+        locked_by: z.ZodString;
+        locked_at: z.ZodString;
+        git_commit: z.ZodOptional<z.ZodString>;
+        git_branch: z.ZodOptional<z.ZodString>;
+        source_file: z.ZodString;
+        source_line: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ExecutionPlan = z.infer<typeof ExecutionPlanSchema>;
+/**
+ * Get the path to the state file
+ */
+export declare function getStateFilePath(projectRoot: string): string;
+/**
+ * Get the path to the executions directory
+ */
+export declare function getExecutionsDir(projectRoot: string): string;
+/**
+ * Read the state file, returning empty state if it doesn't exist
+ */
+export declare function readStateFile(projectRoot: string): Promise<StateFile>;
+/**
+ * Write the state file, creating directories if needed
+ */
+export declare function writeStateFile(projectRoot: string, state: StateFile): Promise<void>;
+/**
+ * Get the state of a specific task
+ */
+export declare function getTaskState(projectRoot: string, taskId: string): Promise<TaskState | undefined>;
+/**
+ * Update the state of a specific task
+ */
+export declare function updateTaskState(projectRoot: string, taskId: string, taskState: TaskState): Promise<void>;
+/**
+ * Generate execution plan JSON for a task
+ */
+export declare function createExecutionPlan(task: Task, provenance: Provenance): ExecutionPlan;
+/**
+ * Compute SHA-256 hash of task content
+ */
+export declare function computeTaskHash(task: Task): string;
+/**
+ * Get execution plan file path for a task
+ */
+export declare function getExecutionPlanPath(projectRoot: string, taskId: string): string;
+/**
+ * Write execution plan to file
+ */
+export declare function writeExecutionPlan(projectRoot: string, plan: ExecutionPlan): Promise<string>;
+/**
+ * Read execution plan from file.
+ * Verifies the stored content_hash matches the recomputed hash.
+ * If the hash does not match, the plan is still returned but a
+ * `hashMismatch` flag is set on the result.
+ */
+export declare function readExecutionPlan(projectRoot: string, taskId: string): Promise<(ExecutionPlan & {
+    hashMismatch?: boolean;
+}) | undefined>;
+/**
+ * Delete execution plan file
+ */
+export declare function deleteExecutionPlan(projectRoot: string, taskId: string): Promise<void>;
+/**
+ * Get current user name
+ */
+export declare function getCurrentUser(): string;
+/**
+ * Get git commit hash (if in a git repo)
+ */
+export declare function getGitCommit(projectRoot: string): string | undefined;
+/**
+ * Get git branch name (if in a git repo)
+ */
+export declare function getGitBranch(projectRoot: string): string | undefined;
+/**
+ * Create provenance info for a task
+ */
+export declare function createProvenance(task: Task, projectRoot: string, user?: string): Provenance;
+/**
+ * Error thrown by state operations
+ */
+export declare class StateError extends Error {
+    readonly path?: string | undefined;
+    readonly taskId?: string | undefined;
+    constructor(message: string, path?: string | undefined, taskId?: string | undefined);
+}
+/**
+ * Result of a lock operation
+ */
+export interface LockResult {
+    success: boolean;
+    taskId: string;
+    executionPlanPath?: string;
+    error?: string;
+}
+/**
+ * Result of an unlock operation
+ */
+export interface UnlockResult {
+    success: boolean;
+    taskId: string;
+    previousStatus?: TaskStatus;
+    error?: string;
+}
+/**
+ * Task status information
+ */
+export interface TaskStatusInfo {
+    taskId: string;
+    status: TaskStatus;
+    lockedAt?: string;
+    lockedBy?: string;
+    executionFile?: string;
+    source?: TaskSource;
+    completedAt?: string;
+    cancelledAt?: string;
+}
+/**
+ * Options for TaskLocker
+ */
+export interface TaskLockerOptions {
+    /** Project root directory */
+    projectRoot: string;
+    /** Path to the planning document */
+    planPath: string;
+    /** User name for provenance (defaults to current user) */
+    user?: string;
+    /** Skip validation before locking */
+    skipValidation?: boolean;
+}
+/**
+ * TaskLocker - Manages task locking for execution
+ *
+ * @example
+ * ```typescript
+ * const locker = new TaskLocker({
+ *   projectRoot: '/path/to/project',
+ *   planPath: 'docs/planning/APS.md',
+ * });
+ *
+ * // Lock a task
+ * const result = await locker.lock('AUTH-001');
+ * if (result.success) {
+ *   console.log(`Task locked, execution plan: ${result.executionPlanPath}`);
+ * }
+ *
+ * // Check status
+ * const status = await locker.getStatus('AUTH-001');
+ *
+ * // Unlock (cancel) a task
+ * await locker.unlock('AUTH-001');
+ * ```
+ */
+export declare class TaskLocker {
+    private projectRoot;
+    private planPath;
+    private user;
+    private skipValidation;
+    private plan;
+    constructor(options: TaskLockerOptions);
+    /**
+     * Load the plan (validates first unless skipValidation is true)
+     */
+    private loadPlan;
+    /**
+     * Find a task by ID in the loaded plan
+     */
+    private findTask;
+    /**
+     * Lock a task for execution
+     *
+     * - Validates planning doc first (unless skipValidation)
+     * - Snapshots task definition
+     * - Generates execution plan JSON with hash and provenance
+     * - Updates state.json
+     * - First lock wins (fails if already locked)
+     */
+    lock(taskId: string): Promise<LockResult>;
+    /**
+     * Unlock (cancel) a locked task
+     *
+     * - Moves task to 'cancelled' status
+     * - Removes execution plan file
+     */
+    unlock(taskId: string): Promise<UnlockResult>;
+    /**
+     * Mark a task as completed
+     */
+    complete(taskId: string): Promise<UnlockResult>;
+    /**
+     * Get the status of a specific task
+     */
+    getStatus(taskId: string): Promise<TaskStatusInfo | undefined>;
+    /**
+     * Get status of all tasks in the plan
+     */
+    getAllStatus(): Promise<TaskStatusInfo[]>;
+    /**
+     * Get summary of task statuses
+     */
+    getStatusSummary(): Promise<Record<TaskStatus, number>>;
+}
+/**
+ * Format task status for display
+ */
+export declare function formatTaskStatus(status: TaskStatusInfo): string;
+/**
+ * Format all task statuses for display
+ */
+export declare function formatAllTaskStatus(statuses: TaskStatusInfo[]): string;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/state/index.ts"],"names":[],"mappings":"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"}