@wrongstack/core 0.1.9 → 0.2.0

package/dist/sdd/index.js

@@ -0,0 +1,864 @@
+// src/sdd/spec-parser.ts
+var SpecParser = class {
+  parse(content) {
+    const lines = content.split("\n");
+    const sections = this.extractSections(lines);
+    const requirements = this.extractRequirements(lines);
+    const now = Date.now();
+    return {
+      id: crypto.randomUUID(),
+      title: this.extractTitle(lines),
+      version: this.extractVersion(lines),
+      status: "draft",
+      overview: this.extractOverview(lines),
+      sections,
+      requirements,
+      createdAt: now,
+      updatedAt: now
+    };
+  }
+  extractTitle(lines) {
+    for (const line of lines) {
+      const m = /^#\s+(.+)/.exec(line.trim());
+      if (m?.[1]) return m[1];
+    }
+    return "Untitled Specification";
+  }
+  extractVersion(lines) {
+    for (const line of lines) {
+      const m = /version[:\s]+(\d+\.\d+\.\d+)/i.exec(line.trim());
+      if (m?.[1]) return m[1];
+    }
+    return "0.0.1";
+  }
+  extractOverview(lines) {
+    const overviewLines = [];
+    let inOverview = false;
+    let foundHeading = false;
+    for (const line of lines) {
+      if (/^##\s+Overview/i.test(line.trim())) {
+        inOverview = true;
+        foundHeading = true;
+        continue;
+      }
+      if (foundHeading && /^##\s+/.test(line.trim())) break;
+      if (inOverview) overviewLines.push(line);
+    }
+    return overviewLines.join("\n").trim() || "No overview provided";
+  }
+  extractSections(lines) {
+    const sections = [];
+    let currentSection = null;
+    let currentLines = [];
+    let depth = 1;
+    for (const line of lines) {
+      const h2 = /^##\s+(.+)/.exec(line.trim());
+      const h3 = /^###\s+(.+)/.exec(line.trim());
+      if (h2) {
+        if (currentSection && currentLines.length > 0) {
+          sections.push({
+            type: this.mapSectionType(currentSection.title ?? "unknown"),
+            title: currentSection.title ?? "Unknown",
+            level: depth,
+            content: currentLines.join("\n").trim()
+          });
+        }
+        currentSection = { title: h2[1] ?? "Unknown" };
+        currentLines = [];
+        depth = 2;
+        continue;
+      }
+      if (h3) {
+        currentLines.push(line);
+        continue;
+      }
+      if (currentSection) {
+        currentLines.push(line);
+      }
+    }
+    if (currentSection && currentLines.length > 0) {
+      sections.push({
+        type: this.mapSectionType(currentSection.title ?? "unknown"),
+        title: currentSection.title ?? "Unknown",
+        level: depth,
+        content: currentLines.join("\n").trim()
+      });
+    }
+    return sections;
+  }
+  extractRequirements(lines) {
+    const requirements = [];
+    let inRequirements = false;
+    let idCounter = 0;
+    for (const line of lines) {
+      if (/^##\s+Requirements/i.test(line.trim())) {
+        inRequirements = true;
+        continue;
+      }
+      if (inRequirements && /^##\s+/.test(line.trim())) break;
+      if (inRequirements) {
+        const req = this.parseRequirementLine(line, `REQ-${++idCounter}`);
+        if (req) requirements.push(req);
+      }
+    }
+    return requirements;
+  }
+  parseRequirementLine(line, id) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) return null;
+    const lower = trimmed.toLowerCase();
+    const types = [
+      "functional",
+      "non-functional",
+      "security",
+      "performance",
+      "ux"
+    ];
+    let type = "functional";
+    for (const t of types) {
+      if (lower.includes(`[${t}]`)) type = t;
+    }
+    let priority = "medium";
+    if (trimmed.includes("[critical]") || trimmed.includes("[prio:high]")) {
+      priority = "critical";
+    } else if (trimmed.includes("[high]")) {
+      priority = "high";
+    } else if (trimmed.includes("[low]")) {
+      priority = "low";
+    }
+    return {
+      id,
+      type,
+      priority,
+      description: trimmed.replace(/\[[^\]]+\]/g, "").trim(),
+      acceptanceCriteria: []
+    };
+  }
+  mapSectionType(title) {
+    const t = title.toLowerCase();
+    if (t.includes("overview")) return "overview";
+    if (t.includes("requirement")) return "requirements";
+    if (t.includes("architect")) return "architecture";
+    if (t.includes("api")) return "api";
+    if (t.includes("data")) return "data";
+    if (t.includes("security")) return "security";
+    if (t.includes("acceptance")) return "acceptance";
+    return "overview";
+  }
+  analyze(spec) {
+    const gaps = [];
+    const suggestions = [];
+    const risks = [];
+    const hasOverview = spec.sections.some((s) => s.type === "overview");
+    const hasRequirements = spec.sections.some((s) => s.type === "requirements");
+    const hasAcceptance = spec.sections.some((s) => s.type === "acceptance");
+    if (!hasOverview) gaps.push("Missing Overview section");
+    if (!hasRequirements) gaps.push("Missing Requirements section");
+    if (!hasAcceptance) gaps.push("Missing Acceptance Criteria section");
+    if (spec.requirements.length === 0) {
+      gaps.push("No requirements defined");
+      suggestions.push("Add specific functional and non-functional requirements");
+    }
+    const unverifiedReqs = spec.requirements.filter((r) => r.acceptanceCriteria.length === 0);
+    if (unverifiedReqs.length > 0) {
+      gaps.push(`${unverifiedReqs.length} requirements without acceptance criteria`);
+      suggestions.push("Define clear acceptance criteria for each requirement");
+    }
+    const criticalUnresolved = spec.requirements.filter(
+      (r) => r.priority === "critical" && r.blockedBy && r.blockedBy.length > 0
+    );
+    for (const req of criticalUnresolved) {
+      risks.push({
+        requirement: req.id,
+        risk: `Critical requirement blocked by ${req.blockedBy?.length} other requirements`,
+        severity: "high"
+      });
+    }
+    const completeness = Math.round(
+      ((hasOverview ? 1 : 0) + (hasRequirements ? 1 : 0) + (hasAcceptance ? 1 : 0) + (spec.requirements.length > 0 ? 1 : 0) + (spec.sections.length > 3 ? 1 : 0)) / 5 * 100
+    );
+    return {
+      specId: spec.id,
+      completeness,
+      coverage: {
+        requirements: spec.requirements.length,
+        apiEndpoints: spec.apiEndpoints?.length ?? 0,
+        edgeCases: 0,
+        errorHandling: 0
+      },
+      gaps,
+      risks,
+      suggestions
+    };
+  }
+  validate(spec) {
+    const errors = [];
+    const warnings = [];
+    if (!spec.title.trim()) {
+      errors.push({ path: "title", message: "Title is required" });
+    }
+    if (!spec.version.trim()) {
+      errors.push({ path: "version", message: "Version is required" });
+    }
+    for (const req of spec.requirements) {
+      if (!req.description.trim()) {
+        errors.push({ path: `requirement.${req.id}`, message: "Requirement description is empty" });
+      }
+      if (req.acceptanceCriteria.length === 0) {
+        warnings.push({ path: `requirement.${req.id}`, message: "No acceptance criteria defined" });
+      }
+    }
+    const reqIds = new Set(spec.requirements.map((r) => r.id));
+    const blockedByIds = new Set(spec.requirements.flatMap((r) => r.blockedBy ?? []));
+    for (const id of blockedByIds) {
+      if (!reqIds.has(id)) {
+        errors.push({
+          path: "requirements",
+          message: `BlockedBy references non-existent requirement: ${id}`
+        });
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+};
+
+// src/sdd/task-generator.ts
+var TaskGenerator = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  async generateFromSpec(spec) {
+    const graph = await this.opts.taskTracker.createGraph(spec.id, spec.title);
+    const overview = spec.sections.find((s) => s.type === "overview");
+    if (overview) {
+      this.opts.taskTracker.addNode({
+        title: `Implement ${spec.title}`,
+        description: overview.content,
+        type: "feature",
+        priority: "high",
+        status: "pending"
+      });
+    }
+    const byPriority = {
+      critical: [],
+      high: [],
+      medium: [],
+      low: []
+    };
+    for (const req of spec.requirements) {
+      const bucket = byPriority[req.priority] ?? byPriority.medium;
+      bucket.push(req);
+    }
+    const order = ["critical", "high", "medium", "low"];
+    for (const p of order) {
+      for (const req of byPriority[p]) {
+        this.opts.taskTracker.addNode(this.createTaskFromRequirement(req));
+      }
+    }
+    if (spec.apiEndpoints && spec.apiEndpoints.length > 0) {
+      const apiParent = this.opts.taskTracker.addNode({
+        title: "API Implementation",
+        description: `Implement ${spec.apiEndpoints.length} API endpoints`,
+        type: "feature",
+        priority: "high",
+        status: "pending"
+      });
+      for (const endpoint of spec.apiEndpoints) {
+        const task = this.createTaskFromEndpoint(endpoint);
+        this.opts.taskTracker.addNode({
+          ...task,
+          parentId: apiParent.id
+        });
+      }
+    }
+    this.opts.taskTracker.addNode({
+      title: "Write Tests",
+      description: "Comprehensive test coverage for all features",
+      type: "test",
+      priority: "high",
+      status: "pending"
+    });
+    this.opts.taskTracker.addNode({
+      title: "Update Documentation",
+      description: "Update docs for new features",
+      type: "docs",
+      priority: "medium",
+      status: "pending"
+    });
+    return graph;
+  }
+  createTaskFromRequirement(req) {
+    return {
+      title: req.description,
+      description: this.buildDescription(req),
+      type: this.mapRequirementType(req.type),
+      priority: req.priority,
+      status: "pending",
+      specRequirementId: req.id,
+      tags: [req.type, req.priority],
+      estimateHours: this.estimateHours(req)
+    };
+  }
+  createTaskFromEndpoint(endpoint) {
+    return {
+      title: `${endpoint.method} ${endpoint.path}`,
+      description: endpoint.description,
+      type: "feature",
+      priority: "high",
+      status: "pending",
+      tags: [endpoint.method],
+      estimateHours: this.estimateForEndpoint(endpoint)
+    };
+  }
+  buildDescription(req) {
+    const lines = [req.description, "", "**Type:** " + req.type, "**Priority:** " + req.priority];
+    if (req.acceptanceCriteria.length > 0) {
+      lines.push("", "**Acceptance Criteria:**");
+      for (const criterion of req.acceptanceCriteria) {
+        lines.push(`- ${criterion}`);
+      }
+    }
+    if (req.blockedBy && req.blockedBy.length > 0) {
+      lines.push("", `**Blocked by:** ${req.blockedBy.join(", ")}`);
+    }
+    return lines.join("\n");
+  }
+  mapRequirementType(type) {
+    switch (type) {
+      case "functional":
+        return "feature";
+      case "non-functional":
+        return "feature";
+      case "security":
+        return "feature";
+      case "performance":
+        return "feature";
+      case "ux":
+        return "feature";
+      default:
+        return "feature";
+    }
+  }
+  estimateHours(req) {
+    switch (req.priority) {
+      case "critical":
+        return 8;
+      case "high":
+        return 4;
+      case "medium":
+        return 2;
+      case "low":
+        return 1;
+      default:
+        return 2;
+    }
+  }
+  estimateForEndpoint(endpoint) {
+    let hours = 2;
+    if (endpoint.auth) hours += 1;
+    if (endpoint.request) hours += 1;
+    return hours;
+  }
+  async generateSubtasks(parentTaskId, spec) {
+    const reqId = this.opts.taskTracker.getNode(parentTaskId)?.specRequirementId;
+    if (!reqId) return;
+    const req = spec.requirements.find((r) => r.id === reqId);
+    if (!req) return;
+    if (req.acceptanceCriteria.length > 0) {
+      for (const criterion of req.acceptanceCriteria) {
+        this.opts.taskTracker.addNode({
+          title: criterion,
+          description: `Verify: ${criterion}`,
+          type: "test",
+          priority: "medium",
+          status: "pending",
+          parentId: parentTaskId
+        });
+      }
+    }
+  }
+};
+var DefaultTaskStore = class {
+  graphs = /* @__PURE__ */ new Map();
+  async saveGraph(graph) {
+    this.graphs.set(graph.id, this.cloneGraph(graph));
+  }
+  async loadGraph(id) {
+    const g = this.graphs.get(id);
+    return g ? this.cloneGraph(g) : null;
+  }
+  async listGraphs() {
+    return Array.from(this.graphs.values()).map((g) => ({
+      id: g.id,
+      title: g.title,
+      updatedAt: g.updatedAt
+    }));
+  }
+  async deleteGraph(id) {
+    this.graphs.delete(id);
+  }
+  cloneGraph(g) {
+    return {
+      ...g,
+      nodes: new Map(g.nodes),
+      edges: [...g.edges],
+      rootNodes: [...g.rootNodes]
+    };
+  }
+};
+
+// src/types/task-graph.ts
+function computeTaskProgress(graph) {
+  let completed = 0;
+  let pending = 0;
+  let inProgress = 0;
+  let blocked = 0;
+  let failed = 0;
+  let review = 0;
+  let estimatedHours = 0;
+  let actualHours = 0;
+  for (const n of graph.nodes.values()) {
+    switch (n.status) {
+      case "completed":
+        completed++;
+        break;
+      case "pending":
+        pending++;
+        break;
+      case "in_progress":
+        inProgress++;
+        break;
+      case "blocked":
+        blocked++;
+        break;
+      case "failed":
+        failed++;
+        break;
+      case "review":
+        review++;
+        break;
+    }
+    estimatedHours += n.estimateHours ?? 0;
+    actualHours += n.actualHours ?? 0;
+  }
+  const total = graph.nodes.size;
+  return {
+    total,
+    pending,
+    inProgress,
+    blocked,
+    failed,
+    review,
+    completed,
+    percentComplete: total > 0 ? Math.round(completed / total * 100) : 0,
+    estimatedHours,
+    actualHours
+  };
+}
+
+// src/sdd/task-tracker.ts
+var TaskTracker = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  graph = null;
+  transitions = [];
+  async createGraph(specId, title) {
+    this.graph = {
+      id: crypto.randomUUID(),
+      specId,
+      title,
+      nodes: /* @__PURE__ */ new Map(),
+      edges: [],
+      rootNodes: [],
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    };
+    await this.opts.store.saveGraph(this.graph);
+    return this.graph;
+  }
+  async loadGraph(id) {
+    this.graph = await this.opts.store.loadGraph(id);
+    return this.graph;
+  }
+  addNode(node) {
+    if (!this.graph) throw new Error("No graph loaded");
+    const now = Date.now();
+    const newNode = {
+      ...node,
+      id: crypto.randomUUID(),
+      status: node.status ?? "pending",
+      createdAt: now,
+      updatedAt: now
+    };
+    this.graph.nodes.set(newNode.id, newNode);
+    if (!node.parentId) {
+      this.graph.rootNodes.push(newNode.id);
+    }
+    this.graph.updatedAt = now;
+    this.persist();
+    return newNode;
+  }
+  addEdge(from, to, type = "depends_on") {
+    if (!this.graph) throw new Error("No graph loaded");
+    this.graph.edges.push({
+      id: crypto.randomUUID(),
+      from,
+      to,
+      type
+    });
+    this.graph.updatedAt = Date.now();
+    this.persist();
+  }
+  updateNodeStatus(id, status, reason) {
+    if (!this.graph) throw new Error("No graph loaded");
+    const node = this.graph.nodes.get(id);
+    if (!node) throw new Error(`Node ${id} not found`);
+    const from = node.status;
+    const now = Date.now();
+    node.status = status;
+    node.updatedAt = now;
+    if (status === "completed") {
+      node.completedAt = now;
+    }
+    this.transitions.push({ from, to: status, timestamp: now, reason });
+    if (status === "completed") {
+      this.unblockDependents(id);
+    }
+    if (status === "in_progress") {
+      this.checkAndBlockIfNeeded(id);
+    }
+    this.graph.updatedAt = now;
+    this.persist();
+  }
+  getNode(id) {
+    return this.graph?.nodes.get(id);
+  }
+  getAllNodes(filter, sort) {
+    if (!this.graph) return [];
+    let nodes = Array.from(this.graph.nodes.values());
+    if (filter) {
+      nodes = nodes.filter((n) => {
+        if (filter.status?.length && !filter.status.includes(n.status)) return false;
+        if (filter.priority?.length && !filter.priority.includes(n.priority)) return false;
+        if (filter.type?.length && !filter.type.includes(n.type)) return false;
+        if (filter.assignee?.length && n.assignee && !filter.assignee.includes(n.assignee))
+          return false;
+        if (filter.tags?.length && n.tags && !n.tags.some((t) => filter.tags.includes(t)))
+          return false;
+        if (filter.specRequirementId && n.specRequirementId !== filter.specRequirementId)
+          return false;
+        return true;
+      });
+    }
+    if (sort) {
+      nodes.sort((a, b) => {
+        const cmp = compareByField(a, b, sort.field);
+        return sort.direction === "asc" ? cmp : -cmp;
+      });
+    }
+    return nodes;
+  }
+  getChildren(parentId) {
+    if (!this.graph) return [];
+    return Array.from(this.graph.nodes.values()).filter((n) => n.parentId === parentId);
+  }
+  getDependents(taskId) {
+    if (!this.graph) return [];
+    return this.graph.edges.filter((e) => e.from === taskId && e.type === "depends_on").map((e) => e.to);
+  }
+  getBlockers(taskId) {
+    if (!this.graph) return [];
+    return this.graph.edges.filter((e) => e.to === taskId && e.type === "depends_on").map((e) => e.from);
+  }
+  canStart(taskId) {
+    const blockers = this.getBlockers(taskId);
+    return blockers.every((id) => {
+      const node = this.graph?.nodes.get(id);
+      return node?.status === "completed";
+    });
+  }
+  getProgress() {
+    if (!this.graph) {
+      return {
+        total: 0,
+        pending: 0,
+        inProgress: 0,
+        blocked: 0,
+        failed: 0,
+        review: 0,
+        completed: 0,
+        percentComplete: 0,
+        estimatedHours: 0,
+        actualHours: 0
+      };
+    }
+    return computeTaskProgress(this.graph);
+  }
+  getTransitions(taskId) {
+    if (!taskId) return [...this.transitions];
+    return [...this.transitions];
+  }
+  unblockDependents(completedId) {
+    if (!this.graph) return;
+    const dependents = this.getDependents(completedId);
+    for (const depId of dependents) {
+      const dep = this.graph.nodes.get(depId);
+      if (dep?.status === "blocked") {
+        const remainingBlockers = this.getBlockers(depId);
+        const allUnblocked = remainingBlockers.every((id) => {
+          const blocker = this.graph?.nodes.get(id);
+          return blocker?.status === "completed";
+        });
+        if (allUnblocked) {
+          dep.status = "pending";
+          dep.updatedAt = Date.now();
+        }
+      }
+    }
+  }
+  checkAndBlockIfNeeded(taskId) {
+    if (!this.graph) return;
+    const blockers = this.getBlockers(taskId);
+    const someBlocked = blockers.some((id) => {
+      const blocker = this.graph?.nodes.get(id);
+      return blocker?.status !== "completed";
+    });
+    if (someBlocked) {
+      const node = this.graph.nodes.get(taskId);
+      if (node) {
+        node.status = "blocked";
+        node.updatedAt = Date.now();
+      }
+    }
+  }
+  /**
+   * 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.
+   */
+  persist() {
+    if (!this.graph) return;
+    this.opts.store.saveGraph(this.graph).catch((err) => {
+      if (this.opts.onPersistError) this.opts.onPersistError(err);
+      else
+        console.warn(
+          "[task-tracker] saveGraph failed:",
+          err instanceof Error ? err.message : String(err)
+        );
+    });
+  }
+};
+var PRIORITY_RANK = {
+  critical: 0,
+  high: 1,
+  medium: 2,
+  low: 3
+};
+var STATUS_RANK = {
+  in_progress: 0,
+  pending: 1,
+  review: 2,
+  blocked: 3,
+  failed: 4,
+  completed: 5
+};
+function compareByField(a, b, field) {
+  switch (field) {
+    case "priority":
+      return PRIORITY_RANK[a.priority] - PRIORITY_RANK[b.priority];
+    case "status":
+      return STATUS_RANK[a.status] - STATUS_RANK[b.status];
+    case "createdAt":
+      return a.createdAt - b.createdAt;
+    case "updatedAt":
+      return a.updatedAt - b.updatedAt;
+  }
+}
+
+// src/sdd/task-flow.ts
+var TaskFlow = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.setPhase("idle");
+  }
+  opts;
+  phase = "idle";
+  spec = null;
+  graph = null;
+  stopped = false;
+  emit(event, payload) {
+    this.opts.events.emit(event, payload);
+  }
+  async fromSpec(specContent) {
+    this.setPhase("parsing");
+    const parser = new SpecParser();
+    this.spec = parser.parse(specContent);
+    this.setPhase("analyzing");
+    const analysis = parser.analyze(this.spec);
+    this.emit("spec.analyzed", { analysis });
+    if (analysis.completeness < 50) {
+      this.emit("error", {
+        phase: "analyzing",
+        error: new Error(`Spec completeness too low: ${analysis.completeness}%`)
+      });
+      this.setPhase("failed");
+      throw new Error("Spec too incomplete");
+    }
+    this.setPhase("generating");
+    const generator = new TaskGenerator({ taskTracker: this.opts.tracker });
+    this.graph = await generator.generateFromSpec(this.spec);
+    return this.graph;
+  }
+  async execute(ctx) {
+    if (!this.graph) throw new Error("No graph loaded. Call fromSpec first.");
+    this.setPhase("executing");
+    this.stopped = false;
+    const pendingTasks = this.getExecutableTasks();
+    const maxConcurrent = this.opts.maxConcurrent ?? 2;
+    while (pendingTasks.length > 0 && !this.stopped) {
+      const batch = pendingTasks.splice(0, maxConcurrent);
+      const results = await Promise.allSettled(
+        batch.map((task) => this.executeSingleTask(task, ctx))
+      );
+      for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        const task = batch[i];
+        if (!result || !task) continue;
+        if (result.status === "rejected") {
+          const reason = result.reason;
+          this.opts.tracker.updateNodeStatus(task.id, "failed", reason?.message);
+          this.emit("task.failed", { taskId: task.id, error: reason?.message ?? "unknown" });
+          ctx.onTaskFail?.(task, reason);
+        } else {
+          this.opts.tracker.updateNodeStatus(task.id, "completed");
+          this.emit("task.completed", { taskId: task.id, result: result.value });
+          ctx.onTaskComplete?.(task, result.value);
+        }
+        this.emitProgress();
+      }
+      const stillPending = this.getExecutableTasks();
+      pendingTasks.length = 0;
+      pendingTasks.push(...stillPending);
+      if (this.checkDoneCondition()) {
+        break;
+      }
+    }
+    this.setPhase("completing");
+    this.emit("done", { graph: this.graph });
+    this.setPhase("done");
+    return this.graph;
+  }
+  async reviewTask(taskId, approved, comment) {
+    const task = this.opts.tracker.getNode(taskId);
+    if (!task) throw new Error(`Task ${taskId} not found`);
+    if (approved) {
+      this.opts.tracker.updateNodeStatus(taskId, "completed", comment);
+      this.emit("task.completed", { taskId });
+    } else {
+      this.opts.tracker.updateNodeStatus(taskId, "in_progress", comment ?? "Needs revision");
+      this.emit("task.review", { taskId });
+    }
+  }
+  stop() {
+    this.stopped = true;
+  }
+  getPhase() {
+    return this.phase;
+  }
+  getGraph() {
+    return this.graph;
+  }
+  getSpec() {
+    return this.spec;
+  }
+  setPhase(phase) {
+    const from = this.phase;
+    this.phase = phase;
+    this.emit("phase.change", { from, to: phase });
+  }
+  getExecutableTasks() {
+    return this.opts.tracker.getAllNodes({ status: ["pending", "blocked"] }).filter((n) => n.status === "pending" && this.opts.tracker.canStart(n.id)).sort((a, b) => {
+      const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+      return (priorityOrder[a.priority] ?? 4) - (priorityOrder[b.priority] ?? 4);
+    });
+  }
+  async executeSingleTask(task, ctx) {
+    this.opts.tracker.updateNodeStatus(task.id, "in_progress");
+    this.emit("task.started", { taskId: task.id });
+    return ctx.executeTask(task);
+  }
+  checkDoneCondition() {
+    const condition = this.opts.doneCondition;
+    if (!condition) {
+      const progress = this.opts.tracker.getProgress();
+      return progress.percentComplete === 100;
+    }
+    switch (condition.type) {
+      case "all_tasks_done": {
+        const progress = this.opts.tracker.getProgress();
+        return progress.pending === 0 && progress.inProgress === 0;
+      }
+      case "iterations":
+        return false;
+      // Not tracked here
+      case "tool_calls":
+        return false;
+      default:
+        return false;
+    }
+  }
+  emitProgress() {
+    const progress = this.opts.tracker.getProgress();
+    this.emit("progress", {
+      percent: progress.percentComplete,
+      message: `${progress.completed}/${progress.total} tasks completed`
+    });
+  }
+};
+var SpecDrivenDev = class {
+  store;
+  tracker;
+  events;
+  flows = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    this.store = new DefaultTaskStore();
+    this.tracker = new TaskTracker({ store: this.store });
+    this.events = opts.events;
+  }
+  async createFlow(specContent, options) {
+    const flow = new TaskFlow({
+      tracker: this.tracker,
+      events: this.events,
+      ...options
+    });
+    const graph = await flow.fromSpec(specContent);
+    this.flows.set(graph.id, flow);
+    return flow;
+  }
+  getTracker() {
+    return this.tracker;
+  }
+  getFlow(graphId) {
+    return this.flows.get(graphId);
+  }
+  listFlows() {
+    return Array.from(this.flows.entries()).map(([id, flow]) => ({
+      id,
+      title: flow.getGraph()?.title ?? "Untitled",
+      phase: flow.getPhase()
+    }));
+  }
+};
+
+export { DefaultTaskStore, SpecDrivenDev, SpecParser, TaskFlow, TaskGenerator, TaskTracker };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map