mcoda 0.1.2 → 0.1.4

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

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

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