mcoda 0.1.2 → 0.1.4

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

@@ -1,58 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,157 +0,0 @@
-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

@@ -1,179 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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 });
-  }
-});