mcoda 0.1.0

package/packages/core/src/services/backlog/__tests__/BacklogService.test.ts

@@ -0,0 +1,219 @@
+import assert from "node:assert/strict";
+import { describe, it, beforeEach, afterEach } from "node:test";
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { Connection, WorkspaceMigrations, WorkspaceRepository } from "@mcoda/db";
+import { PathHelper } from "@mcoda/shared";
+import { BacklogService } from "../BacklogService.js";
+import { WorkspaceResolution } from "../../../workspace/WorkspaceManager.js";
+
+const workspaceFromRoot = (workspaceRoot: string): WorkspaceResolution => ({
+  workspaceRoot,
+  workspaceId: workspaceRoot,
+  mcodaDir: path.join(workspaceRoot, ".mcoda"),
+  id: workspaceRoot,
+  legacyWorkspaceIds: [],
+  workspaceDbPath: PathHelper.getWorkspaceDbPath(workspaceRoot),
+  globalDbPath: PathHelper.getGlobalDbPath(),
+});
+
+describe("BacklogService", () => {
+  let workspaceRoot: string;
+
+  beforeEach(async () => {
+    workspaceRoot = await fs.mkdtemp(path.join(os.tmpdir(), "mcoda-backlog-"));
+    await fs.mkdir(path.join(workspaceRoot, ".mcoda"), { recursive: true });
+    const dbPath = PathHelper.getWorkspaceDbPath(workspaceRoot);
+    const connection = await Connection.open(dbPath);
+    await WorkspaceMigrations.run(connection.db);
+    const repo = new WorkspaceRepository(connection.db, connection);
+    const project = await repo.createProjectIfMissing({ key: "WEB", name: "Web" });
+    const [epic1, epic2] = await repo.insertEpics(
+      [
+        {
+          projectId: project.id,
+          key: "web-01",
+          title: "Auth",
+          description: "Authentication epic description that is intentionally long to test truncation handling.",
+          priority: 1,
+        },
+        {
+          projectId: project.id,
+          key: "web-02",
+          title: "Payments",
+          description: "Payments epic",
+          priority: 2,
+        },
+      ],
+      true,
+    );
+    const [story1, story2, story3] = await repo.insertStories(
+      [
+        {
+          projectId: project.id,
+          epicId: epic1.id,
+          key: "web-01-us-01",
+          title: "Login flow",
+          description: "Implement login",
+          priority: 1,
+        },
+        {
+          projectId: project.id,
+          epicId: epic1.id,
+          key: "web-01-us-02",
+          title: "Session refresh",
+          description: "Refresh tokens",
+          priority: 2,
+        },
+        {
+          projectId: project.id,
+          epicId: epic2.id,
+          key: "web-02-us-01",
+          title: "Card payments",
+          description: "Accept payments",
+          priority: 1,
+        },
+      ],
+      true,
+    );
+    const [task1, task2, task3, task4, task5, task6] = await repo.insertTasks(
+      [
+        {
+          projectId: project.id,
+          epicId: epic1.id,
+          userStoryId: story1.id,
+          key: "web-01-us-01-t01",
+          title: "Scaffold login page",
+          description: "Create login UI and basic form controls",
+          status: "not_started",
+          storyPoints: 3,
+          priority: 1,
+          assigneeHuman: "alice",
+        },
+        {
+          projectId: project.id,
+          epicId: epic1.id,
+          userStoryId: story1.id,
+          key: "web-01-us-01-t02",
+          title: "Hook login API",
+          description: "Wire up API",
+          status: "blocked",
+          storyPoints: 2,
+          priority: 2,
+          assigneeHuman: "bob",
+        },
+        {
+          projectId: project.id,
+          epicId: epic1.id,
+          userStoryId: story2.id,
+          key: "web-01-us-02-t01",
+          title: "Add review gate",
+          description: "Implement review checks",
+          status: "ready_to_review",
+          storyPoints: 5,
+          priority: 1,
+          assigneeHuman: "alice",
+        },
+        {
+          projectId: project.id,
+          epicId: epic2.id,
+          userStoryId: story3.id,
+          key: "web-02-us-01-t01",
+          title: "QA plan",
+          description: "QA scenario",
+          status: "ready_to_qa",
+          storyPoints: 1,
+          priority: 3,
+        },
+        {
+          projectId: project.id,
+          epicId: epic2.id,
+          userStoryId: story3.id,
+          key: "web-02-us-01-t02",
+          title: "Ship payments",
+          description: "Deploy payments",
+          status: "completed",
+          storyPoints: 8,
+          priority: 1,
+        },
+        {
+          projectId: project.id,
+          epicId: epic1.id,
+          userStoryId: story1.id,
+          key: "web-01-us-01-t03",
+          title: "Handle errors",
+          description: "Edge cases",
+          status: "in_progress",
+          storyPoints: null,
+          priority: 3,
+          assigneeHuman: "alice",
+        },
+      ],
+      true,
+    );
+    await repo.insertTaskDependencies(
+      [
+        { taskId: task2.id, dependsOnTaskId: task1.id, relationType: "blocks" },
+        { taskId: task3.id, dependsOnTaskId: task2.id, relationType: "blocks" },
+        { taskId: task6.id, dependsOnTaskId: task2.id, relationType: "blocks" },
+      ],
+      true,
+    );
+    await repo.close();
+  });
+
+  afterEach(async () => {
+    await fs.rm(workspaceRoot, { recursive: true, force: true });
+  });
+
+  it("aggregates backlog buckets and orders dependencies per bucket", async () => {
+    const workspace = workspaceFromRoot(workspaceRoot);
+    const service = await BacklogService.create(workspace);
+    const { summary, warnings } = await service.getBacklog({ projectKey: "WEB", orderByDependencies: true });
+
+    assert.equal(warnings.length, 0);
+    assert.equal(summary.scope.project_key, "WEB");
+    assert.equal(summary.totals.implementation.tasks, 3);
+    assert.equal(summary.totals.implementation.story_points, 5);
+    assert.equal(summary.totals.review.tasks, 1);
+    assert.equal(summary.totals.review.story_points, 5);
+    assert.equal(summary.totals.qa.story_points, 1);
+    assert.equal(summary.totals.done.story_points, 8);
+
+    assert.deepEqual(
+      summary.epics.map((e) => e.epic_key),
+      ["web-01", "web-02"],
+    );
+    const storyStatuses = summary.epics.flatMap((e) => e.stories.map((s) => s.status));
+    assert.deepEqual(storyStatuses.sort(), ["completed", "in_progress", "ready_to_review"].sort());
+
+    const tasksByKey = new Map(summary.tasks.map((t) => [t.task_key, t]));
+    assert.deepEqual(tasksByKey.get("web-01-us-01-t02")?.dependency_keys, ["web-01-us-01-t01"]);
+    assert.deepEqual(tasksByKey.get("web-01-us-01-t03")?.dependency_keys, ["web-01-us-01-t02"]);
+
+    const orderedKeys = summary.tasks.map((t) => t.task_key);
+    assert.deepEqual(orderedKeys, [
+      "web-01-us-01-t01",
+      "web-02-us-01-t01",
+      "web-01-us-01-t02",
+      "web-01-us-02-t01",
+      "web-01-us-01-t03",
+      "web-02-us-01-t02",
+    ]);
+
+    await service.close();
+  });
+
+  it("filters by status when requested", async () => {
+    const workspace = workspaceFromRoot(workspaceRoot);
+    const service = await BacklogService.create(workspace);
+    const { summary } = await service.getBacklog({ projectKey: "WEB", statuses: ["ready_to_review"] });
+
+    assert.equal(summary.tasks.length, 1);
+    assert.equal(summary.tasks[0]?.task_key, "web-01-us-02-t01");
+    assert.equal(summary.totals.review.tasks, 1);
+    assert.equal(summary.totals.implementation.tasks, 0);
+    await service.close();
+  });
+});

package/packages/core/src/services/backlog/__tests__/TaskOrderingService.test.ts

@@ -0,0 +1,268 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { Connection, WorkspaceMigrations, WorkspaceRepository } from "@mcoda/db";
+import { WorkspaceResolver } from "../../../workspace/WorkspaceManager.js";
+import { TaskOrderingService } from "../TaskOrderingService.js";
+
+const setupWorkspace = async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "mcoda-order-"));
+  const workspace = await WorkspaceResolver.resolveWorkspace({ cwd: dir, explicitWorkspace: dir });
+  const dbPath = path.join(dir, ".mcoda", "mcoda.db");
+  const connection = await Connection.open(dbPath);
+  await WorkspaceMigrations.run(connection.db);
+  const repo = new WorkspaceRepository(connection.db, connection);
+
+  const project = await repo.createProjectIfMissing({ key: "PROJ", name: "Proj" });
+  const [epic] = await repo.insertEpics(
+    [
+      {
+        projectId: project.id,
+        key: "proj-01",
+        title: "Epic",
+        description: "",
+      },
+    ],
+    true,
+  );
+  const [story] = await repo.insertStories(
+    [
+      {
+        projectId: project.id,
+        epicId: epic.id,
+        key: "proj-01-us-01",
+        title: "Story",
+        description: "",
+      },
+    ],
+    true,
+  );
+
+  return { dir, workspace, repo, project, epic, story };
+};
+
+const cleanupWorkspace = async (dir: string, repo: WorkspaceRepository) => {
+  try {
+    await repo.close();
+  } catch {
+    /* ignore */
+  }
+  await fs.rm(dir, { recursive: true, force: true });
+};
+
+test("orders tasks by dependency impact and normalizes priorities", async () => {
+  const ctx = await setupWorkspace();
+  try {
+    const [t1, t2, t3, t4] = await ctx.repo.insertTasks(
+      [
+        {
+          projectId: ctx.project.id,
+          epicId: ctx.epic.id,
+          userStoryId: ctx.story.id,
+          key: "PROJ-01-US-01-T01",
+          title: "Root task",
+          description: "",
+          status: "not_started",
+          storyPoints: 3,
+        },
+        {
+          projectId: ctx.project.id,
+          epicId: ctx.epic.id,
+          userStoryId: ctx.story.id,
+          key: "PROJ-01-US-01-T02",
+          title: "Second",
+          description: "",
+          status: "not_started",
+          storyPoints: 1,
+        },
+        {
+          projectId: ctx.project.id,
+          epicId: ctx.epic.id,
+          userStoryId: ctx.story.id,
+          key: "PROJ-01-US-01-T03",
+          title: "Third",
+          description: "",
+          status: "not_started",
+          storyPoints: 2,
+        },
+        {
+          projectId: ctx.project.id,
+          epicId: ctx.epic.id,
+          userStoryId: ctx.story.id,
+          key: "PROJ-01-US-01-T04",
+          title: "Fourth",
+          description: "",
+          status: "not_started",
+          storyPoints: 5,
+        },
+      ],
+      true,
+    );
+    await ctx.repo.insertTaskDependencies(
+      [
+        { taskId: t2.id, dependsOnTaskId: t1.id, relationType: "blocks" },
+        { taskId: t3.id, dependsOnTaskId: t1.id, relationType: "blocks" },
+        { taskId: t4.id, dependsOnTaskId: t3.id, relationType: "blocks" },
+      ],
+      true,
+    );
+
+    const service = await TaskOrderingService.create(ctx.workspace, { recordTelemetry: false });
+    try {
+      const result = await service.orderTasks({
+        projectKey: ctx.project.key,
+        includeBlocked: true,
+      });
+      assert.equal(result.ordered.length, 4);
+      assert.deepEqual(
+        result.ordered.map((t) => t.taskKey),
+        ["PROJ-01-US-01-T01", "PROJ-01-US-01-T03", "PROJ-01-US-01-T02", "PROJ-01-US-01-T04"],
+      );
+      const priorities = await Promise.all(
+        [t1, t2, t3, t4].map((task) => ctx.repo.getTaskByKey(task.key)),
+      );
+      assert.deepEqual(
+        priorities.map((t) => t?.priority),
+        [1, 3, 2, 4],
+      );
+      const epicRow = await ctx.repo.getDb().get<{ priority: number }>("SELECT priority FROM epics WHERE id = ?", ctx.epic.id);
+      const storyRow = await ctx.repo.getDb().get<{ priority: number }>(
+        "SELECT priority FROM user_stories WHERE id = ?",
+        ctx.story.id,
+      );
+      assert.equal(epicRow?.priority, 1);
+      assert.equal(storyRow?.priority, 1);
+    } finally {
+      await service.close();
+    }
+  } finally {
+    await cleanupWorkspace(ctx.dir, ctx.repo);
+  }
+});
+
+test("excludes blocked tasks when includeBlocked is false and still assigns priorities", async () => {
+  const ctx = await setupWorkspace();
+  try {
+    const [t1, t2, t3] = await ctx.repo.insertTasks(
+      [
+        {
+          projectId: ctx.project.id,
+          epicId: ctx.epic.id,
+          userStoryId: ctx.story.id,
+          key: "PROJ-01-US-01-T01",
+          title: "Root done",
+          description: "",
+          status: "completed",
+        },
+        {
+          projectId: ctx.project.id,
+          epicId: ctx.epic.id,
+          userStoryId: ctx.story.id,
+          key: "PROJ-01-US-01-T02",
+          title: "Unblocked",
+          description: "",
+          status: "not_started",
+        },
+        {
+          projectId: ctx.project.id,
+          epicId: ctx.epic.id,
+          userStoryId: ctx.story.id,
+          key: "PROJ-01-US-01-T03",
+          title: "Blocked child",
+          description: "",
+          status: "not_started",
+        },
+      ],
+      true,
+    );
+    await ctx.repo.insertTaskDependencies(
+      [
+        { taskId: t2.id, dependsOnTaskId: t1.id, relationType: "blocks" },
+        { taskId: t3.id, dependsOnTaskId: t2.id, relationType: "blocks" },
+      ],
+      true,
+    );
+
+    const service = await TaskOrderingService.create(ctx.workspace, { recordTelemetry: false });
+    try {
+      const result = await service.orderTasks({
+        projectKey: ctx.project.key,
+        includeBlocked: false,
+        statusFilter: ["not_started", "completed"],
+      });
+      assert.equal(result.ordered.length, 2);
+      assert.equal(result.blocked.length, 1);
+      assert.ok(result.blocked[0].taskKey.endsWith("T03"));
+      const priorities = await Promise.all(
+        [t1, t2, t3].map((task) => ctx.repo.getTaskByKey(task.key)),
+      );
+      assert.deepEqual(
+        priorities.map((t) => t?.priority),
+        [1, 2, 3],
+      );
+    } finally {
+      await service.close();
+    }
+  } finally {
+    await cleanupWorkspace(ctx.dir, ctx.repo);
+  }
+});
+
+test("handles dependency cycles gracefully", async () => {
+  const ctx = await setupWorkspace();
+  try {
+    const [t1, t2] = await ctx.repo.insertTasks(
+      [
+        {
+          projectId: ctx.project.id,
+          epicId: ctx.epic.id,
+          userStoryId: ctx.story.id,
+          key: "PROJ-01-US-01-T01",
+          title: "Cycle A",
+          description: "",
+          status: "not_started",
+        },
+        {
+          projectId: ctx.project.id,
+          epicId: ctx.epic.id,
+          userStoryId: ctx.story.id,
+          key: "PROJ-01-US-01-T02",
+          title: "Cycle B",
+          description: "",
+          status: "not_started",
+        },
+      ],
+      true,
+    );
+    await ctx.repo.insertTaskDependencies(
+      [
+        { taskId: t1.id, dependsOnTaskId: t2.id, relationType: "blocks" },
+        { taskId: t2.id, dependsOnTaskId: t1.id, relationType: "blocks" },
+      ],
+      true,
+    );
+
+    const service = await TaskOrderingService.create(ctx.workspace, { recordTelemetry: false });
+    try {
+      const result = await service.orderTasks({
+        projectKey: ctx.project.key,
+        includeBlocked: true,
+      });
+      assert.equal(result.ordered.length, 2);
+      assert.ok(result.warnings.length > 0);
+      const priorities = await Promise.all(
+        [t1, t2].map((task) => ctx.repo.getTaskByKey(task.key)),
+      );
+      const sortedPriorities = priorities
+        .map((t) => t?.priority ?? 0)
+        .sort((a, b) => a - b);
+      assert.deepEqual(sortedPriorities, [1, 2]);
+    } finally {
+      await service.close();
+    }
+  } finally {
+    await cleanupWorkspace(ctx.dir, ctx.repo);
+  }
+});