mcoda 0.1.0

package/packages/core/src/services/execution/TaskSelectionService.ts

@@ -0,0 +1,362 @@
+import { WorkspaceRepository, TaskRow, ProjectRow } from "@mcoda/db";
+import { WorkspaceResolution } from "../../workspace/WorkspaceManager.js";
+
+export interface TaskSelectionFilters {
+  projectKey?: string;
+  epicKey?: string;
+  storyKey?: string;
+  taskKeys?: string[];
+  statusFilter?: string[];
+  limit?: number;
+  parallel?: number;
+}
+
+export interface SelectedTask {
+  task: TaskRow & {
+    epicKey: string;
+    storyKey: string;
+    epicTitle?: string;
+    storyTitle?: string;
+    storyDescription?: string;
+    acceptanceCriteria?: string[];
+  };
+  dependencies: {
+    ids: string[];
+    keys: string[];
+    blocking: string[];
+  };
+  blockedReason?: string;
+}
+
+export interface TaskSelectionPlan {
+  project?: ProjectRow;
+  filters: TaskSelectionFilters & { effectiveStatuses: string[] };
+  ordered: SelectedTask[];
+  blocked: SelectedTask[];
+  warnings: string[];
+}
+
+const DEFAULT_IMPLEMENTATION_STATUSES = ["not_started", "in_progress"];
+const DONE_DEPENDENCY_STATUSES = new Set(["completed", "cancelled"]);
+
+const normalizeStatusList = (statuses?: string[]): string[] => {
+  if (!statuses || statuses.length === 0) return DEFAULT_IMPLEMENTATION_STATUSES;
+  return Array.from(new Set(statuses.map((s) => s.toLowerCase().trim()).filter(Boolean)));
+};
+
+const parseAcceptanceCriteria = (raw?: string | null): string[] | undefined => {
+  if (!raw) return undefined;
+  return raw
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+};
+
+type RawTaskRow = {
+  task_id: string;
+  task_key: string;
+  task_status: string;
+  task_priority: number | null;
+  task_story_points: number | null;
+  task_created_at: string;
+  task_updated_at: string;
+  project_id: string;
+  task_description: string | null;
+  task_title: string;
+  task_type: string | null;
+  task_metadata: string | null;
+  task_assigned_agent_id: string | null;
+  task_assignee_human: string | null;
+  task_vcs_branch: string | null;
+  task_vcs_base_branch: string | null;
+  task_vcs_last_commit_sha: string | null;
+  epic_id: string;
+  epic_key: string;
+  epic_title: string;
+  epic_description: string | null;
+  story_id: string;
+  story_key: string;
+  story_title: string;
+  story_description: string | null;
+  story_acceptance: string | null;
+};
+
+type DependencyRow = {
+  taskId: string;
+  dependsOnTaskId: string;
+  relationType: string;
+  createdAt: string;
+  updatedAt: string;
+  dependsOnKey?: string | null;
+  dependsOnStatus?: string | null;
+};
+
+export class TaskSelectionService {
+  constructor(private workspace: WorkspaceResolution, private workspaceRepo: WorkspaceRepository) {}
+
+  static async create(workspace: WorkspaceResolution): Promise<TaskSelectionService> {
+    const workspaceRepo = await WorkspaceRepository.create(workspace.workspaceRoot);
+    return new TaskSelectionService(workspace, workspaceRepo);
+  }
+
+  async close(): Promise<void> {
+    await this.workspaceRepo.close();
+  }
+
+  private async fetchProject(projectKey?: string): Promise<ProjectRow | undefined> {
+    if (!projectKey) return undefined;
+    return this.workspaceRepo.getProjectByKey(projectKey);
+  }
+
+  private buildTaskFromRow(row: RawTaskRow): SelectedTask["task"] {
+    return {
+      id: row.task_id,
+      projectId: row.project_id,
+      epicId: row.epic_id,
+      userStoryId: row.story_id,
+      key: row.task_key,
+      title: row.task_title,
+      description: row.task_description ?? "",
+      type: row.task_type ?? undefined,
+      status: row.task_status,
+      storyPoints: row.task_story_points ?? undefined,
+      priority: row.task_priority ?? undefined,
+      assignedAgentId: row.task_assigned_agent_id ?? undefined,
+      assigneeHuman: row.task_assignee_human ?? undefined,
+      vcsBranch: row.task_vcs_branch ?? undefined,
+      vcsBaseBranch: row.task_vcs_base_branch ?? undefined,
+      vcsLastCommitSha: row.task_vcs_last_commit_sha ?? undefined,
+      metadata: row.task_metadata ? JSON.parse(row.task_metadata) : undefined,
+      openapiVersionAtCreation: undefined,
+      createdAt: row.task_created_at,
+      updatedAt: row.task_updated_at,
+      epicKey: row.epic_key,
+      storyKey: row.story_key,
+      epicTitle: row.epic_title ?? undefined,
+      storyTitle: row.story_title ?? undefined,
+      storyDescription: row.story_description ?? undefined,
+      acceptanceCriteria: parseAcceptanceCriteria(row.story_acceptance),
+    };
+  }
+
+  private async loadTasks(filters: TaskSelectionFilters & { project?: ProjectRow }): Promise<RawTaskRow[]> {
+    const clauses: string[] = [];
+    const params: any[] = [];
+    if (filters.project?.id) {
+      clauses.push("t.project_id = ?");
+      params.push(filters.project.id);
+    }
+    if (filters.epicKey) {
+      clauses.push("e.key = ?");
+      params.push(filters.epicKey);
+    }
+    if (filters.storyKey) {
+      clauses.push("us.key = ?");
+      params.push(filters.storyKey);
+    }
+    if (filters.taskKeys && filters.taskKeys.length > 0) {
+      clauses.push(`t.key IN (${filters.taskKeys.map(() => "?").join(", ")})`);
+      params.push(...filters.taskKeys);
+    }
+    const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+    const db = this.workspaceRepo.getDb();
+    return db.all<RawTaskRow[]>(
+      `
+        SELECT
+          t.id as task_id,
+          t.project_id as project_id,
+          t.key as task_key,
+          t.status as task_status,
+          t.priority as task_priority,
+          t.story_points as task_story_points,
+          t.created_at as task_created_at,
+          t.updated_at as task_updated_at,
+          t.description as task_description,
+          t.title as task_title,
+          t.type as task_type,
+          t.metadata_json as task_metadata,
+          t.assigned_agent_id as task_assigned_agent_id,
+          t.assignee_human as task_assignee_human,
+          t.vcs_branch as task_vcs_branch,
+          t.vcs_base_branch as task_vcs_base_branch,
+          t.vcs_last_commit_sha as task_vcs_last_commit_sha,
+          e.id as epic_id,
+          e.key as epic_key,
+          e.title as epic_title,
+          e.description as epic_description,
+          us.id as story_id,
+          us.key as story_key,
+          us.title as story_title,
+          us.description as story_description,
+          us.acceptance_criteria as story_acceptance
+        FROM tasks t
+        JOIN epics e ON e.id = t.epic_id
+        JOIN user_stories us ON us.id = t.user_story_id
+        ${where}
+      `,
+      ...params,
+    );
+  }
+
+  private async loadDependencies(taskIds: string[]): Promise<Map<string, DependencyRow[]>> {
+    if (taskIds.length === 0) return new Map();
+    const placeholders = taskIds.map(() => "?").join(", ");
+    const db = this.workspaceRepo.getDb();
+    const rows = await db.all<any[]>(
+      `
+        SELECT td.id, td.task_id, td.depends_on_task_id, td.relation_type, td.created_at, td.updated_at,
+               dep.key as depends_on_key, dep.status as depends_on_status
+        FROM task_dependencies td
+        LEFT JOIN tasks dep ON dep.id = td.depends_on_task_id
+        WHERE td.task_id IN (${placeholders})
+      `,
+      ...taskIds,
+    );
+    const grouped = new Map<string, DependencyRow[]>();
+    for (const row of rows) {
+      const normalized: DependencyRow = {
+        taskId: row.task_id,
+        dependsOnTaskId: row.depends_on_task_id,
+        relationType: row.relation_type,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        dependsOnKey: row.depends_on_key,
+        dependsOnStatus: row.depends_on_status,
+      };
+      const arr = grouped.get(normalized.taskId) ?? [];
+      arr.push(normalized);
+      grouped.set(normalized.taskId, arr);
+    }
+    return grouped;
+  }
+
+  private topologicalOrder(
+    tasks: SelectedTask[],
+    deps: Map<string, DependencyRow[]>,
+  ): { ordered: SelectedTask[]; warnings: string[] } {
+    const warnings: string[] = [];
+    const taskMap = new Map<string, SelectedTask>(tasks.map((t) => [t.task.id, t]));
+    const indegree = new Map<string, number>();
+    const edges = new Map<string, string[]>();
+    for (const task of tasks) {
+      indegree.set(task.task.id, 0);
+    }
+    for (const task of tasks) {
+      const rels = deps.get(task.task.id) ?? [];
+      for (const dep of rels) {
+        if (!dep.dependsOnTaskId) continue;
+        if (!taskMap.has(dep.dependsOnTaskId)) continue;
+        indegree.set(task.task.id, (indegree.get(task.task.id) ?? 0) + 1);
+        const list = edges.get(dep.dependsOnTaskId) ?? [];
+        list.push(task.task.id);
+        edges.set(dep.dependsOnTaskId, list);
+      }
+    }
+    const queue: SelectedTask[] = [];
+    for (const task of tasks) {
+      if ((indegree.get(task.task.id) ?? 0) === 0) {
+        queue.push(task);
+      }
+    }
+    const ordered: SelectedTask[] = [];
+    while (queue.length) {
+      queue.sort((a, b) => {
+        const pa = a.task.priority ?? Number.NEGATIVE_INFINITY;
+        const pb = b.task.priority ?? Number.NEGATIVE_INFINITY;
+        if (pa !== pb) return pb - pa;
+        const spa = a.task.storyPoints ?? Number.POSITIVE_INFINITY;
+        const spb = b.task.storyPoints ?? Number.POSITIVE_INFINITY;
+        if (spa !== spb) return spa - spb;
+        const ca = Date.parse(a.task.createdAt) || 0;
+        const cb = Date.parse(b.task.createdAt) || 0;
+        if (ca !== cb) return ca - cb;
+        const sa = a.task.status === "in_progress" ? 0 : 1;
+        const sb = b.task.status === "in_progress" ? 0 : 1;
+        return sa - sb;
+      });
+      const current = queue.shift()!;
+      ordered.push(current);
+      const targets = edges.get(current.task.id) ?? [];
+      for (const tId of targets) {
+        indegree.set(tId, (indegree.get(tId) ?? 0) - 1);
+        if ((indegree.get(tId) ?? 0) === 0) {
+          const node = taskMap.get(tId);
+          if (node) queue.push(node);
+        }
+      }
+    }
+    if (ordered.length !== tasks.length) {
+      warnings.push("Cycle detected in task dependencies; falling back to partial order.");
+      for (const task of tasks) {
+        if (!ordered.includes(task)) ordered.push(task);
+      }
+    }
+    return { ordered, warnings };
+  }
+
+  async selectTasks(filters: TaskSelectionFilters): Promise<TaskSelectionPlan> {
+    const project = await this.fetchProject(filters.projectKey);
+    if (filters.projectKey && !project) {
+      throw new Error(`Unknown project key: ${filters.projectKey}`);
+    }
+    const effectiveStatuses = normalizeStatusList(filters.statusFilter);
+    const allowBlocked = effectiveStatuses.includes("blocked");
+    const tasks = await this.loadTasks({ ...filters, project });
+    const filteredTasks = tasks.filter((task) => effectiveStatuses.includes(task.task_status.toLowerCase()));
+    const candidateIds = filteredTasks.map((t) => t.task_id);
+    const deps = await this.loadDependencies(candidateIds);
+    const taskMap = new Map<string, SelectedTask>();
+    for (const row of filteredTasks) {
+      const task = this.buildTaskFromRow(row);
+      taskMap.set(task.id, {
+        task,
+        dependencies: { ids: [], keys: [], blocking: [] },
+      });
+    }
+
+    const blocked: SelectedTask[] = [];
+    const eligible: SelectedTask[] = [];
+    for (const [taskId, entry] of taskMap.entries()) {
+      const depRows = deps.get(taskId) ?? [];
+      const ids: string[] = [];
+      const keys: string[] = [];
+      const blocking: string[] = [];
+      let blockedReason: string | undefined;
+      for (const dep of depRows) {
+        ids.push(dep.dependsOnTaskId);
+        if (dep.dependsOnKey) keys.push(dep.dependsOnKey);
+        const status = dep.dependsOnStatus?.toLowerCase();
+        const depInSelection = taskMap.has(dep.dependsOnTaskId);
+        const clear = dep.dependsOnTaskId
+          ? DONE_DEPENDENCY_STATUSES.has(status ?? "")
+          : true;
+        if (!clear) {
+          blockedReason = "dependency_not_ready";
+          blocking.push(dep.dependsOnTaskId);
+        } else if (!status && !depInSelection) {
+          // unknown status but dependency referenced; treat as blocked unless explicitly ignored
+          blockedReason = "dependency_not_ready";
+          blocking.push(dep.dependsOnTaskId);
+        }
+      }
+      entry.dependencies = { ids, keys, blocking };
+      if (blockedReason && !(allowBlocked || (filters.taskKeys ?? []).includes(entry.task.key))) {
+        entry.blockedReason = blockedReason;
+        blocked.push(entry);
+      } else {
+        entry.blockedReason = blockedReason;
+        eligible.push(entry);
+      }
+    }
+
+    const { ordered, warnings } = this.topologicalOrder(eligible, deps);
+    const limited = typeof filters.limit === "number" && filters.limit > 0 ? ordered.slice(0, filters.limit) : ordered;
+    return {
+      project: project ?? undefined,
+      filters: { ...filters, effectiveStatuses },
+      ordered: limited,
+      blocked,
+      warnings,
+    };
+  }
+}

package/packages/core/src/services/execution/TaskStateService.ts

@@ -0,0 +1,64 @@
+import { WorkspaceRepository, TaskRow } from "@mcoda/db";
+
+const mergeMetadata = (existing: Record<string, unknown> | undefined, patch?: Record<string, unknown> | null) => {
+  if (patch === undefined) return existing;
+  if (patch === null) return null;
+  return { ...(existing ?? {}), ...patch };
+};
+
+export class TaskStateService {
+  constructor(private workspaceRepo: WorkspaceRepository) {}
+
+  async transitionToInProgress(task: TaskRow): Promise<void> {
+    if (task.status === "in_progress") return;
+    await this.workspaceRepo.updateTask(task.id, { status: "in_progress" });
+  }
+
+  async markReadyToReview(task: TaskRow, metadataPatch?: Record<string, unknown>): Promise<void> {
+    await this.workspaceRepo.updateTask(task.id, {
+      status: "ready_to_review",
+      metadata: mergeMetadata(task.metadata, metadataPatch ?? undefined) ?? undefined,
+    });
+  }
+
+  async markReadyToQa(task: TaskRow, metadataPatch?: Record<string, unknown>): Promise<void> {
+    await this.workspaceRepo.updateTask(task.id, {
+      status: "ready_to_qa",
+      metadata: mergeMetadata(task.metadata, metadataPatch ?? undefined) ?? undefined,
+    });
+  }
+
+  async markCompleted(task: TaskRow, metadataPatch?: Record<string, unknown>): Promise<void> {
+    await this.workspaceRepo.updateTask(task.id, {
+      status: "completed",
+      metadata: mergeMetadata(task.metadata, metadataPatch ?? undefined) ?? undefined,
+    });
+  }
+
+  async returnToInProgress(task: TaskRow, metadataPatch?: Record<string, unknown>): Promise<void> {
+    await this.workspaceRepo.updateTask(task.id, {
+      status: "in_progress",
+      metadata: mergeMetadata(task.metadata, metadataPatch ?? undefined) ?? undefined,
+    });
+  }
+
+  async markBlocked(task: TaskRow, reason: string): Promise<void> {
+    const metadata = mergeMetadata(task.metadata, { blocked_reason: reason }) ?? { blocked_reason: reason };
+    await this.workspaceRepo.updateTask(task.id, {
+      status: "blocked",
+      metadata,
+    });
+  }
+
+  async recordReviewMetadata(task: TaskRow, metadata: { decision: string; agentId?: string | null; modelName?: string | null; jobId?: string | null; reviewId?: string | null }) {
+    const patch = mergeMetadata(task.metadata, {
+      last_review_decision: metadata.decision,
+      last_review_agent_id: metadata.agentId ?? null,
+      last_review_model: metadata.modelName ?? null,
+      last_review_job_id: metadata.jobId ?? null,
+      last_review_id: metadata.reviewId ?? null,
+      last_reviewed_at: new Date().toISOString(),
+    });
+    await this.workspaceRepo.updateTask(task.id, { metadata: patch ?? undefined });
+  }
+}