@wrongstack/core 0.1.9 → 0.2.0

package/dist/sdd/index.d.ts

@@ -0,0 +1,206 @@
+import { h as Specification, S as SpecAnalysis, g as SpecValidationResult, l as TaskGraph, m as TaskNode, k as TaskFilter, p as TaskSort, o as TaskProgress, r as TaskType, n as TaskPriority } from '../task-graph-BITvWt4t.js';
+import { E as EventBus } from '../events-B6Q03pTu.js';
+import { D as DoneCondition } from '../multi-agent-BDfkxL5C.js';
+import '../context-u0bryklF.js';
+
+declare class SpecParser {
+    parse(content: string): Specification;
+    private extractTitle;
+    private extractVersion;
+    private extractOverview;
+    private extractSections;
+    private extractRequirements;
+    private parseRequirementLine;
+    private mapSectionType;
+    analyze(spec: Specification): SpecAnalysis;
+    validate(spec: Specification): SpecValidationResult;
+}
+
+interface TaskStore {
+    saveGraph(graph: TaskGraph): Promise<void>;
+    loadGraph(id: string): Promise<TaskGraph | null>;
+    listGraphs(): Promise<{
+        id: string;
+        title: string;
+        updatedAt: number;
+    }[]>;
+    deleteGraph(id: string): Promise<void>;
+}
+interface TaskTrackerOptions {
+    store: TaskStore;
+    /**
+     * Called when an in-the-background persistence (`saveGraph`) rejects.
+     * The synchronous TaskTracker methods (addNode/addEdge/updateNodeStatus)
+     * fire-and-forget their writes; without this, a failing store silently
+     * loses graph mutations. Defaults to a console.warn.
+     */
+    onPersistError?: (err: unknown) => void;
+}
+interface TaskTransition {
+    from: TaskNode['status'];
+    to: TaskNode['status'];
+    timestamp: number;
+    reason?: string;
+}
+declare class TaskTracker {
+    private readonly opts;
+    private graph;
+    private transitions;
+    constructor(opts: TaskTrackerOptions);
+    createGraph(specId: string, title: string): Promise<TaskGraph>;
+    loadGraph(id: string): Promise<TaskGraph | null>;
+    addNode(node: Omit<TaskNode, 'id' | 'createdAt' | 'updatedAt'>): TaskNode;
+    addEdge(from: string, to: string, type?: TaskGraph['edges'][0]['type']): void;
+    updateNodeStatus(id: string, status: TaskNode['status'], reason?: string): void;
+    getNode(id: string): TaskNode | undefined;
+    getAllNodes(filter?: TaskFilter, sort?: TaskSort): TaskNode[];
+    getChildren(parentId: string): TaskNode[];
+    getDependents(taskId: string): string[];
+    getBlockers(taskId: string): string[];
+    canStart(taskId: string): boolean;
+    getProgress(): TaskProgress;
+    getTransitions(taskId?: string): TaskTransition[];
+    private unblockDependents;
+    private checkAndBlockIfNeeded;
+    /**
+     * Fire-and-forget persistence with attached error handler.
+     * Synchronous mutators (addNode/addEdge/updateNodeStatus) use this to
+     * avoid forcing an async cascade through every caller; if the store
+     * rejects, the configured `onPersistError` is invoked so failures are
+     * surfaced instead of swallowed by an unhandled promise rejection.
+     */
+    private persist;
+}
+
+interface TaskGeneratorOptions {
+    taskTracker: TaskTracker;
+}
+interface GeneratedTask {
+    specRequirementId?: string;
+    title: string;
+    description: string;
+    type: TaskType;
+    priority: TaskPriority;
+    estimateHours?: number;
+    tags?: string[];
+}
+declare class TaskGenerator {
+    private readonly opts;
+    constructor(opts: TaskGeneratorOptions);
+    generateFromSpec(spec: Specification): Promise<TaskGraph>;
+    private createTaskFromRequirement;
+    private createTaskFromEndpoint;
+    private buildDescription;
+    private mapRequirementType;
+    private estimateHours;
+    private estimateForEndpoint;
+    generateSubtasks(parentTaskId: string, spec: Specification): Promise<void>;
+}
+declare class DefaultTaskStore implements TaskStore {
+    private graphs;
+    saveGraph(graph: TaskGraph): Promise<void>;
+    loadGraph(id: string): Promise<TaskGraph | null>;
+    listGraphs(): Promise<{
+        id: string;
+        title: string;
+        updatedAt: number;
+    }[]>;
+    deleteGraph(id: string): Promise<void>;
+    private cloneGraph;
+}
+
+/**
+ * Extended event map used internally by TaskFlow and multi-agent components.
+ * These events are emitted on the injected EventBus and are a subset of
+ * the full EventMap — they do not require a separate registration.
+ */
+interface TaskFlowEventMap {
+    'phase.change': {
+        from: TaskFlowPhase;
+        to: TaskFlowPhase;
+    };
+    'task.started': {
+        taskId: string;
+    };
+    'task.completed': {
+        taskId: string;
+        result?: unknown;
+    };
+    'task.failed': {
+        taskId: string;
+        error: string;
+    };
+    'task.review': {
+        taskId: string;
+    };
+    'spec.analyzed': {
+        analysis: SpecAnalysis;
+    };
+    progress: {
+        percent: number;
+        message: string;
+    };
+    done: {
+        graph: TaskGraph;
+    };
+    error: {
+        phase: TaskFlowPhase;
+        error: Error;
+    };
+}
+type TaskFlowPhase = 'idle' | 'parsing' | 'analyzing' | 'generating' | 'executing' | 'reviewing' | 'completing' | 'done' | 'failed';
+type TaskFlowEventName = keyof TaskFlowEventMap;
+interface TaskFlowOptions {
+    tracker: TaskTracker;
+    events: EventBus;
+    doneCondition?: DoneCondition;
+    maxConcurrent?: number;
+}
+interface TaskFlowExecutionContext {
+    executeTask: (task: TaskNode) => Promise<unknown>;
+    onTaskComplete?: (task: TaskNode, result: unknown) => void;
+    onTaskFail?: (task: TaskNode, error: Error) => void;
+}
+declare class TaskFlow {
+    private readonly opts;
+    private phase;
+    private spec;
+    private graph;
+    private stopped;
+    constructor(opts: TaskFlowOptions);
+    private emit;
+    fromSpec(specContent: string): Promise<TaskGraph>;
+    execute(ctx: TaskFlowExecutionContext): Promise<TaskGraph>;
+    reviewTask(taskId: string, approved: boolean, comment?: string): Promise<void>;
+    stop(): void;
+    getPhase(): TaskFlowPhase;
+    getGraph(): TaskGraph | null;
+    getSpec(): Specification | null;
+    private setPhase;
+    private getExecutableTasks;
+    private executeSingleTask;
+    private checkDoneCondition;
+    private emitProgress;
+}
+interface SpecDrivenDevOptions {
+    workingDirectory: string;
+    events: EventBus;
+    doneCondition?: DoneCondition;
+}
+declare class SpecDrivenDev {
+    private store;
+    private tracker;
+    private readonly events;
+    private flows;
+    constructor(opts: SpecDrivenDevOptions);
+    createFlow(specContent: string, options?: Partial<TaskFlowOptions>): Promise<TaskFlow>;
+    getTracker(): TaskTracker;
+    getFlow(graphId: string): TaskFlow | undefined;
+    listFlows(): {
+        id: string;
+        title: string;
+        phase: TaskFlowPhase;
+    }[];
+}
+
+export { DefaultTaskStore, type GeneratedTask, SpecDrivenDev, type SpecDrivenDevOptions, SpecParser, TaskFlow, type TaskFlowEventMap, type TaskFlowEventName, type TaskFlowExecutionContext, type TaskFlowOptions, type TaskFlowPhase, TaskGenerator, type TaskGeneratorOptions, type TaskStore, TaskTracker, type TaskTrackerOptions, type TaskTransition };