mcoda 0.1.0

package/packages/core/src/services/execution/__tests__/QaFollowupService.test.ts

@@ -0,0 +1,58 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { WorkspaceRepository } from "@mcoda/db";
+import { WorkspaceResolver } from "../../../workspace/WorkspaceManager.js";
+import { QaFollowupService } from "../QaFollowupService.js";
+
+test("QaFollowupService creates follow-up tasks and dependencies", async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "mcoda-followup-"));
+  const workspace = await WorkspaceResolver.resolveWorkspace({ cwd: dir, explicitWorkspace: dir });
+  const repo = await WorkspaceRepository.create(workspace.workspaceRoot);
+  try {
+    const project = await repo.createProjectIfMissing({ key: "proj", name: "Project" });
+    const [epic] = await repo.insertEpics([
+      { projectId: project.id, key: "proj-epic", title: "Epic", description: "", priority: 1 },
+    ]);
+    const [story] = await repo.insertStories([
+      { projectId: project.id, epicId: epic.id, key: "proj-epic-us-01", title: "Story", description: "" },
+    ]);
+    const [task] = await repo.insertTasks([
+      {
+        projectId: project.id,
+        epicId: epic.id,
+        userStoryId: story.id,
+        key: "proj-epic-us-01-t01",
+        title: "Task",
+        description: "",
+        status: "ready_to_qa",
+      },
+    ]);
+
+    const service = new QaFollowupService(repo, workspace.workspaceRoot);
+    const result = await service.createFollowupTask(task, {
+      title: "Fix QA issue",
+      description: "Observed failure",
+      evidenceUrl: "https://example.test/run/1",
+    });
+
+    assert.ok(result.task.id);
+    assert.equal(result.task.title, "Fix QA issue");
+
+    const deps = await repo.getDb().all<{ task_id: string; depends_on_task_id: string }[]>(
+      "SELECT task_id, depends_on_task_id FROM task_dependencies WHERE task_id = ?",
+      task.id,
+    );
+    assert.equal(deps.length, 1);
+    assert.equal(deps[0]?.depends_on_task_id, result.task.id);
+
+    const followup = await repo.getTaskByKey(result.task.key);
+    assert.equal(followup?.status, "not_started");
+    assert.equal(followup?.type, "bug");
+  } finally {
+    await repo.close();
+    await fs.rm(dir, { recursive: true, force: true });
+  }
+});

package/packages/core/src/services/execution/__tests__/QaProfileService.test.ts

@@ -0,0 +1,49 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { QaProfileService } from "../QaProfileService.js";
+
+const makeTask = (key: string, type?: string, metadata?: Record<string, unknown>) =>
+  ({
+    id: key,
+    projectId: "proj",
+    epicId: "epic",
+    userStoryId: "story",
+    key,
+    title: "Task",
+    description: "",
+    status: "ready_to_qa",
+    type,
+    storyPoints: 1,
+    priority: 1,
+    metadata,
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  }) as any;
+
+test("QaProfileService resolves by tag/type and falls back to default", async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "mcoda-qa-profile-"));
+  const configDir = path.join(dir, ".mcoda");
+  await fs.mkdir(configDir, { recursive: true });
+  const profiles = [
+    { name: "unit", runner: "cli", default: true, matcher: { task_types: ["backend"] } },
+    { name: "mobile", runner: "maestro", matcher: { tags: ["mobile"] } },
+  ];
+  await fs.writeFile(path.join(configDir, "qa-profiles.json"), JSON.stringify(profiles, null, 2), "utf8");
+  const service = new QaProfileService(dir);
+
+  try {
+    const tagged = await service.resolveProfileForTask(makeTask("t-1", "frontend", { tags: ["mobile"] }));
+    assert.equal(tagged?.name, "mobile");
+
+    const typed = await service.resolveProfileForTask(makeTask("t-2", "backend"));
+    assert.equal(typed?.name, "unit");
+
+    const fallback = await service.resolveProfileForTask(makeTask("t-3", "docs"));
+    assert.equal(fallback?.name, "unit");
+  } finally {
+    await fs.rm(dir, { recursive: true, force: true });
+  }
+});

package/packages/core/src/services/execution/__tests__/QaTasksService.test.ts

@@ -0,0 +1,157 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { WorkspaceRepository } from "@mcoda/db";
+import { WorkspaceResolver } from "../../../workspace/WorkspaceManager.js";
+import { TaskSelectionService } from "../TaskSelectionService.js";
+import { TaskStateService } from "../TaskStateService.js";
+import { QaTasksService } from "../QaTasksService.js";
+import { JobService } from "../../jobs/JobService.js";
+
+class StubQaAdapter {
+  async ensureInstalled() {
+    return { ok: true };
+  }
+  async invoke(_profile: any, ctx: any) {
+    const now = new Date().toISOString();
+    return {
+      outcome: "pass",
+      exitCode: 0,
+      stdout: "ok",
+      stderr: "",
+      artifacts: [path.join(ctx.workspaceRoot, ".mcoda", "jobs", ctx.jobId, "qa", ctx.taskKey, "stdout.log")],
+      startedAt: now,
+      finishedAt: now,
+    };
+  }
+}
+
+class StubProfileService {
+  async resolveProfileForTask() {
+    return { name: "unit", runner: "cli", test_command: "echo ok" };
+  }
+}
+
+class StubAgentService {
+  async resolveAgent() {
+    return { id: "qa-agent", defaultModel: "stub" } as any;
+  }
+  async invoke() {
+    return { output: '{"recommendation":"pass"}' };
+  }
+}
+
+class StubRoutingService {
+  async resolveAgentForCommand() {
+    return {
+      agent: { id: "qa-agent", defaultModel: "stub" } as any,
+      agentId: "qa-agent",
+      agentSlug: "qa-agent",
+      model: "stub",
+      capabilities: [],
+      healthStatus: "healthy",
+      source: "workspace_default",
+      routingPreview: { workspaceId: "ws", commandName: "qa-tasks" } as any,
+    };
+  }
+}
+
+class StubDocdex {
+  async search() {
+    return [];
+  }
+  async close() {}
+}
+
+class StubVcs {
+  async ensureRepo() {}
+  async ensureClean() {}
+  async branchExists() {
+    return true;
+  }
+  async checkoutBranch() {}
+  async ensureBaseBranch() {}
+}
+
+test("qa-tasks auto run records QA outcome, tokens, and state transitions", async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "mcoda-qa-service-"));
+  const workspace = await WorkspaceResolver.resolveWorkspace({ cwd: dir, explicitWorkspace: dir });
+  const repo = await WorkspaceRepository.create(workspace.workspaceRoot);
+  const jobService = new JobService(workspace.workspaceRoot, repo);
+  const selectionService = new TaskSelectionService(workspace, repo);
+  const stateService = new TaskStateService(repo);
+  const project = await repo.createProjectIfMissing({ key: "proj", name: "Project" });
+  const [epic] = await repo.insertEpics(
+    [{ projectId: project.id, key: "proj-epic", title: "Epic", description: "", priority: 1 }],
+    false,
+  );
+  const [story] = await repo.insertStories(
+    [{ projectId: project.id, epicId: epic.id, key: "proj-epic-us-01", title: "Story", description: "" }],
+    false,
+  );
+  const [task] = await repo.insertTasks(
+    [
+      {
+        projectId: project.id,
+        epicId: epic.id,
+        userStoryId: story.id,
+        key: "proj-epic-us-01-t01",
+        title: "Task QA",
+        description: "",
+        status: "ready_to_qa",
+        storyPoints: 1,
+      },
+    ],
+    false,
+  );
+
+  const service = new QaTasksService(workspace, {
+    workspaceRepo: repo,
+    jobService,
+    selectionService,
+    stateService,
+    profileService: new StubProfileService() as any,
+    followupService: { createFollowupTask: async () => ({}) } as any,
+    vcsClient: new StubVcs() as any,
+    agentService: new StubAgentService() as any,
+    docdex: new StubDocdex() as any,
+    routingService: new StubRoutingService() as any,
+  });
+  // Override adapter selection to use stubbed adapter.
+  (service as any).adapterForProfile = () => new StubQaAdapter();
+
+  try {
+    const result = await service.run({
+      workspace,
+      projectKey: project.key,
+      statusFilter: ["ready_to_qa"],
+      mode: "auto",
+      agentStream: false,
+    });
+
+    assert.equal(result.results.length, 1);
+    assert.equal(result.results[0]?.outcome, "pass");
+
+    const updated = await repo.getTaskByKey(task.key);
+    assert.equal(updated?.status, "completed");
+
+    const db = repo.getDb();
+    const qaRuns = await db.all<{ recommendation: string }[]>(
+      "SELECT recommendation FROM task_qa_runs WHERE task_id = ?",
+      task.id,
+    );
+    assert.equal(qaRuns.length, 1);
+    assert.equal(qaRuns[0]?.recommendation, "pass");
+
+    const tokens = await db.all("SELECT tokens_prompt FROM token_usage");
+    assert.equal(tokens.length, 1);
+
+    const jobs = await db.all<{ state: string }[]>("SELECT state FROM jobs WHERE id = ?", result.jobId);
+    assert.equal(jobs[0]?.state, "completed");
+  } finally {
+    await service.close();
+    await fs.rm(dir, { recursive: true, force: true });
+  }
+});

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

@@ -0,0 +1,179 @@
+import test from "node:test";
+import assert from "node:assert";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { WorkspaceRepository } from "@mcoda/db";
+import { WorkspaceResolver } from "../../../workspace/WorkspaceManager.js";
+import { TaskSelectionService } from "../TaskSelectionService.js";
+
+const setupWorkspace = async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "mcoda-selection-"));
+  const workspace = await WorkspaceResolver.resolveWorkspace({ cwd: dir, explicitWorkspace: dir });
+  const repo = await WorkspaceRepository.create(workspace.workspaceRoot);
+  const project = await repo.createProjectIfMissing({ key: "proj", name: "proj" });
+  const [epic] = await repo.insertEpics(
+    [
+      {
+        projectId: project.id,
+        key: "proj-epic",
+        title: "Epic",
+        description: "Epic desc",
+        storyPointsTotal: null,
+        priority: 1,
+      },
+    ],
+    false,
+  );
+  const [story] = await repo.insertStories(
+    [
+      {
+        projectId: project.id,
+        epicId: epic.id,
+        key: "proj-epic-us-01",
+        title: "Story",
+        description: "Story desc",
+        acceptanceCriteria: "ac1",
+        storyPointsTotal: null,
+        priority: 1,
+      },
+    ],
+    false,
+  );
+  return { dir, workspace, repo, project, epic, story };
+};
+
+const cleanupWorkspace = async (dir: string, repo: WorkspaceRepository) => {
+  await repo.close();
+  await fs.rm(dir, { recursive: true, force: true });
+};
+
+test("selectTasks orders by dependencies and priority and skips dependency-blocked tasks", async () => {
+  const ctx = await setupWorkspace();
+  const { repo, story, project, dir, workspace } = ctx;
+
+  const [readyReview] = await repo.insertTasks(
+    [
+      {
+        projectId: project.id,
+        epicId: story.epicId,
+        userStoryId: story.id,
+        key: "proj-epic-us-01-t05",
+        title: "Review Task",
+        description: "",
+        status: "ready_to_review",
+      },
+    ],
+    false,
+  );
+
+  const tasks = await repo.insertTasks(
+    [
+      {
+        projectId: project.id,
+        epicId: story.epicId,
+        userStoryId: story.id,
+        key: "proj-epic-us-01-t01",
+        title: "Task A",
+        description: "",
+        priority: 1,
+        status: "not_started",
+      },
+      {
+        projectId: project.id,
+        epicId: story.epicId,
+        userStoryId: story.id,
+        key: "proj-epic-us-01-t02",
+        title: "Task B",
+        description: "",
+        priority: 2,
+        status: "in_progress",
+      },
+      {
+        projectId: project.id,
+        epicId: story.epicId,
+        userStoryId: story.id,
+        key: "proj-epic-us-01-t03",
+        title: "Task C",
+        description: "",
+        priority: 5,
+        storyPoints: 1,
+        status: "not_started",
+      },
+      {
+        projectId: project.id,
+        epicId: story.epicId,
+        userStoryId: story.id,
+        key: "proj-epic-us-01-t04",
+        title: "Blocked",
+        description: "",
+        status: "not_started",
+      },
+    ],
+    false,
+  );
+
+  await repo.insertTaskDependencies(
+    [
+      { taskId: tasks[1].id, dependsOnTaskId: tasks[0].id, relationType: "blocks" },
+      { taskId: tasks[3].id, dependsOnTaskId: readyReview.id, relationType: "blocks" },
+    ],
+    false,
+  );
+
+  const selection = new TaskSelectionService(workspace, repo);
+  const plan = await selection.selectTasks({ projectKey: "proj" });
+  assert.deepStrictEqual(plan.ordered.map((t) => t.task.key), ["proj-epic-us-01-t03", "proj-epic-us-01-t01"]);
+  assert.equal(plan.blocked.length, 2);
+  assert.ok(plan.blocked.some((b) => b.task.key === "proj-epic-us-01-t04"));
+  assert.ok(plan.blocked.some((b) => b.task.key === "proj-epic-us-01-t02"));
+  await cleanupWorkspace(dir, repo);
+});
+
+test("selectTasks surfaces cycles in dependencies", async () => {
+  const ctx = await setupWorkspace();
+  const { repo, story, project, dir, workspace } = ctx;
+
+  const tasks = await repo.insertTasks(
+    [
+      {
+        projectId: project.id,
+        epicId: story.epicId,
+        userStoryId: story.id,
+        key: "proj-epic-us-01-t10",
+        title: "Cycle A",
+        description: "",
+        status: "not_started",
+      },
+      {
+        projectId: project.id,
+        epicId: story.epicId,
+        userStoryId: story.id,
+        key: "proj-epic-us-01-t11",
+        title: "Cycle B",
+        description: "",
+        status: "not_started",
+      },
+    ],
+    false,
+  );
+
+  await repo.insertTaskDependencies(
+    [
+      { taskId: tasks[0].id, dependsOnTaskId: tasks[1].id, relationType: "blocks" },
+      { taskId: tasks[1].id, dependsOnTaskId: tasks[0].id, relationType: "blocks" },
+    ],
+    false,
+  );
+
+  const selection = new TaskSelectionService(workspace, repo);
+  const plan = await selection.selectTasks({
+    projectKey: "proj",
+    taskKeys: ["proj-epic-us-01-t10", "proj-epic-us-01-t11"],
+  });
+  assert.equal(plan.ordered.length, 2);
+  assert.equal(plan.blocked.length, 0);
+  assert.ok(plan.ordered.every((t) => t.blockedReason === "dependency_not_ready"));
+  assert.ok(plan.warnings.some((w) => w.toLowerCase().includes("cycle")));
+  await cleanupWorkspace(dir, repo);
+});

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

@@ -0,0 +1,51 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { WorkspaceRepository } from "@mcoda/db";
+import { WorkspaceResolver } from "../../../workspace/WorkspaceManager.js";
+import { TaskStateService } from "../TaskStateService.js";
+
+test("TaskStateService merges metadata and updates status", async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "mcoda-taskstate-"));
+  const workspace = await WorkspaceResolver.resolveWorkspace({ cwd: dir, explicitWorkspace: dir });
+  const repo = await WorkspaceRepository.create(workspace.workspaceRoot);
+  try {
+    const project = await repo.createProjectIfMissing({ key: "proj", name: "Project" });
+    const [epic] = await repo.insertEpics([
+      { projectId: project.id, key: "proj-epic", title: "Epic", description: "", priority: 1 },
+    ]);
+    const [story] = await repo.insertStories([
+      { projectId: project.id, epicId: epic.id, key: "proj-epic-us-01", title: "Story", description: "" },
+    ]);
+    const [task] = await repo.insertTasks([
+      {
+        projectId: project.id,
+        epicId: epic.id,
+        userStoryId: story.id,
+        key: "proj-epic-us-01-t01",
+        title: "Task",
+        description: "",
+        status: "not_started",
+        metadata: { owner: "alex" },
+      },
+    ]);
+
+    const service = new TaskStateService(repo);
+    await service.markReadyToReview(task, { review: true });
+
+    const updated = await repo.getTaskByKey(task.key);
+    assert.equal(updated?.status, "ready_to_review");
+    assert.equal((updated?.metadata as any)?.owner, "alex");
+    assert.equal((updated?.metadata as any)?.review, true);
+
+    await service.markBlocked(task, "needs_spec");
+    const blocked = await repo.getTaskByKey(task.key);
+    assert.equal(blocked?.status, "blocked");
+    assert.equal((blocked?.metadata as any)?.blocked_reason, "needs_spec");
+  } finally {
+    await repo.close();
+    await fs.rm(dir, { recursive: true, force: true });
+  }
+});