mcoda 0.1.2 → 0.1.4

package/packages/cli/src/__tests__/EstimateCommands.test.ts

@@ -1,54 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import path from "node:path";
-import { parseEstimateArgs } from "../commands/estimate/EstimateCommands.js";
-
-describe("estimate argument parsing", () => {
-  it("parses velocity window and aliases", () => {
-    const parsed = parseEstimateArgs(["--velocity-window", "20", "--window", "10"]);
-    // last one wins
-    assert.equal(parsed.velocityWindow, 10);
-  });
-
-  it("parses sp-per-hour overrides", () => {
-    const parsed = parseEstimateArgs([
-      "--sp-per-hour",
-      "12",
-      "--sp-per-hour-review",
-      "8",
-      "--sp-per-hour-qa",
-      "6",
-    ]);
-    assert.equal(parsed.spPerHour, 12);
-    assert.equal(parsed.spPerHourReview, 8);
-    assert.equal(parsed.spPerHourQa, 6);
-  });
-
-  it("captures quiet/no-color/no-telemetry flags", () => {
-    const parsed = parseEstimateArgs(["--quiet", "--no-color", "--no-telemetry"]);
-    assert.equal(parsed.quiet, true);
-    assert.equal(parsed.noColor, true);
-    assert.equal(parsed.noTelemetry, true);
-  });
-
-  it("parses workspace and scope filters", () => {
-    const expectedRoot = path.resolve("/tmp/w");
-    const parsed = parseEstimateArgs([
-      "--workspace",
-      "/tmp/w",
-      "--project",
-      "PROJ",
-      "--epic",
-      "E1",
-      "--story",
-      "S1",
-      "--assignee",
-      "user",
-    ]);
-    assert.equal(parsed.workspaceRoot, expectedRoot);
-    assert.equal(parsed.project, "PROJ");
-    assert.equal(parsed.epic, "E1");
-    assert.equal(parsed.story, "S1");
-    assert.equal(parsed.assignee, "user");
-  });
-});

package/packages/cli/src/__tests__/JobsCommands.behavior.test.ts

@@ -1,311 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { JobsCommands } from "../commands/jobs/JobsCommands.js";
-import { JobInsightsService, JobService, JobResumeService } from "@mcoda/core";
-
-const originalApiBase = process.env.MCODA_API_BASE_URL;
-if (!originalApiBase) {
-  process.env.MCODA_API_BASE_URL = "http://localhost";
-}
-const originalJobsApiBase = process.env.MCODA_JOBS_API_URL;
-if (!originalJobsApiBase) {
-  process.env.MCODA_JOBS_API_URL = process.env.MCODA_API_BASE_URL;
-}
-
-const withPatched = <T, K extends keyof T>(target: T, key: K, impl: T[K], fn: () => Promise<void> | void) => {
-  const original = target[key];
-  // @ts-ignore override for testing
-  target[key] = impl;
-  return (async () => {
-    try {
-      await fn();
-    } finally {
-      // @ts-ignore restore original
-      target[key] = original;
-    }
-  })();
-};
-
-const captureLogs = async (fn: () => Promise<void> | void): Promise<string[]> => {
-  const logs: string[] = [];
-  const originalLog = console.log;
-  // @ts-ignore override
-  console.log = (...args: any[]) => {
-    logs.push(args.join(" "));
-  };
-  try {
-    await fn();
-  } finally {
-    // @ts-ignore restore
-    console.log = originalLog;
-  }
-  return logs;
-};
-
-describe("job command behavior", () => {
-  it("returns non-zero exit for failed status", async () => {
-    const finishCalls: Array<{ status: string; error?: string }> = [];
-    const getJob = async () => ({ id: "job-1", type: "work", state: "failed", commandName: "work-on-tasks" });
-    const latestCheckpoint = async () => undefined;
-    await withPatched(JobInsightsService.prototype as any, "getJob", getJob as any, async () => {
-      await withPatched(JobInsightsService.prototype as any, "latestCheckpoint", latestCheckpoint as any, async () => {
-        await withPatched(JobService.prototype as any, "startCommandRun", async () => ({ id: "cmd-1" }), async () => {
-          await withPatched(JobService.prototype as any, "finishCommandRun", async (_id: string, status: string, error?: string) => {
-            finishCalls.push({ status, error });
-          }, async () => {
-            const originalExit = process.exitCode;
-            process.exitCode = undefined;
-            await JobsCommands.run(["status", "job-1"]);
-            assert.equal(process.exitCode, 1);
-            assert.equal(finishCalls.at(-1)?.status, "failed");
-            process.exitCode = originalExit;
-          });
-        });
-      });
-    });
-  });
-
-  it("watch exits on completed without error", async () => {
-    const getJob = async () => ({ id: "job-2", type: "work", state: "completed", commandName: "work-on-tasks" });
-    const latestCheckpoint = async () => undefined;
-    const finishes: string[] = [];
-    await withPatched(JobInsightsService.prototype as any, "getJob", getJob as any, async () => {
-      await withPatched(JobInsightsService.prototype as any, "latestCheckpoint", latestCheckpoint as any, async () => {
-        await withPatched(JobService.prototype as any, "startCommandRun", async () => ({ id: "cmd-2" }), async () => {
-          await withPatched(JobService.prototype as any, "finishCommandRun", async (_id: string, status: string) => {
-            finishes.push(status);
-          }, async () => {
-            const originalExit = process.exitCode;
-            process.exitCode = undefined;
-            await JobsCommands.run(["watch", "job-2", "--interval", "1", "--no-logs"]);
-            assert.equal(process.exitCode ?? 0, 0);
-            assert.equal(finishes.at(-1), "succeeded");
-            process.exitCode = originalExit;
-          });
-        });
-      });
-    });
-  });
-
-  it("resume fails when no checkpoints exist", async () => {
-    const finishCalls: Array<{ status: string; error?: string }> = [];
-    await withPatched(JobResumeService.prototype as any, "resume", async () => {
-      throw new Error("No checkpoints");
-    }, async () => {
-      await withPatched(JobService.prototype as any, "startCommandRun", async () => ({ id: "cmd-3" }), async () => {
-        await withPatched(JobService.prototype as any, "finishCommandRun", async (_id: string, status: string, error?: string) => {
-          finishCalls.push({ status, error });
-        }, async () => {
-          const originalExit = process.exitCode;
-          process.exitCode = undefined;
-          await JobsCommands.run(["resume", "job-3"]);
-          assert.equal(process.exitCode, 1);
-          assert.match(finishCalls.at(-1)?.error ?? "", /No checkpoints/);
-          process.exitCode = originalExit;
-        });
-      });
-    });
-  });
-
-  it("cancel rejects non-cancellable without --force", async () => {
-    const getJob = async () => ({ id: "job-4", type: "work", state: "completed", commandName: "work-on-tasks" });
-    const finishCalls: Array<{ status: string; error?: string }> = [];
-    await withPatched(JobInsightsService.prototype as any, "getJob", getJob as any, async () => {
-      await withPatched(JobService.prototype as any, "updateJobStatus", async () => {}, async () => {
-        await withPatched(JobService.prototype as any, "startCommandRun", async () => ({ id: "cmd-4" }), async () => {
-          await withPatched(JobService.prototype as any, "finishCommandRun", async (_id: string, status: string, error?: string) => {
-            finishCalls.push({ status, error });
-          }, async () => {
-            const originalExit = process.exitCode;
-            process.exitCode = undefined;
-            await JobsCommands.run(["cancel", "job-4"]);
-            assert.equal(process.exitCode, 1);
-            assert.match(finishCalls.at(-1)?.error ?? "", /rerun with --force/);
-            process.exitCode = originalExit;
-          });
-        });
-      });
-    });
-  });
-
-  it("list succeeds with rows", async () => {
-    const finishCalls: Array<{ status: string; error?: string }> = [];
-    await withPatched(JobInsightsService.prototype as any, "listJobs", async () => [
-      { id: "job-10", type: "review", jobState: "running", jobStateDetail: "working", totalUnits: 10, completedUnits: 5, commandName: "code-review" },
-    ], async () => {
-      await withPatched(JobService.prototype as any, "startCommandRun", async () => ({ id: "cmd-10" }), async () => {
-        await withPatched(JobService.prototype as any, "finishCommandRun", async (_id: string, status: string, error?: string) => {
-          finishCalls.push({ status, error });
-        }, async () => {
-          await JobsCommands.run(["list"]);
-          assert.equal(finishCalls.at(-1)?.status, "succeeded");
-        });
-      });
-    });
-  });
-
-  it("list --json emits SDS-shaped fields", async () => {
-    const finishes: string[] = [];
-    await withPatched(JobInsightsService.prototype as any, "listJobs", async () => [
-      { id: "job-json", type: "review", jobState: "running", jobStateDetail: "detail", totalUnits: 2, completedUnits: 1, commandName: "code-review", createdAt: "now" },
-    ], async () => {
-      await withPatched(JobService.prototype as any, "startCommandRun", async () => ({ id: "cmd-10b" }), async () => {
-        await withPatched(JobService.prototype as any, "finishCommandRun", async (_id: string, status: string) => {
-          finishes.push(status);
-        }, async () => {
-          const logs = await captureLogs(async () => {
-            await JobsCommands.run(["list", "--json"]);
-          });
-          const parsed = JSON.parse(logs.join("\n"));
-          assert.equal(parsed[0].jobState ?? parsed[0].job_state, "running");
-          assert.equal(parsed[0].jobStateDetail ?? parsed[0].job_state_detail, "detail");
-          assert.equal(parsed[0].completedUnits ?? parsed[0].completed_units, 1);
-          assert.equal(parsed[0].createdAt ?? parsed[0].created_at, "now");
-          assert.equal(finishes.at(-1), "succeeded");
-        });
-      });
-    });
-  });
-
-  it("logs prints entries once without follow", async () => {
-    const finishes: string[] = [];
-    await withPatched(JobInsightsService.prototype as any, "getJobLogs", async () => ({ entries: [{ timestamp: "t1", message: "m1" }], cursor: undefined }), async () => {
-      await withPatched(JobService.prototype as any, "startCommandRun", async () => ({ id: "cmd-logs" }), async () => {
-        await withPatched(JobService.prototype as any, "finishCommandRun", async (_id: string, status: string) => {
-          finishes.push(status);
-        }, async () => {
-          await JobsCommands.run(["logs", "job-logs"]);
-          assert.equal(finishes.at(-1), "succeeded");
-        });
-      });
-    });
-  });
-
-  it("logs --follow polls until terminal and sets exit code on failure", async () => {
-    const finishes: string[] = [];
-    const logCalls: string[] = [];
-    let jobPoll = 0;
-    await withPatched(JobInsightsService.prototype as any, "getJobLogs", async () => {
-      logCalls.push("logs");
-      if (logCalls.length === 1) return { entries: [{ timestamp: "t1", message: "m1" }], cursor: { timestamp: "t1" } };
-      return { entries: [{ timestamp: "t2", message: "m2" }], cursor: { timestamp: "t2" } };
-    }, async () => {
-      await withPatched(JobInsightsService.prototype as any, "getJob", async () => {
-        jobPoll += 1;
-        return { id: "job-follow", state: jobPoll === 1 ? "running" : "failed" };
-      }, async () => {
-        await withPatched(JobService.prototype as any, "startCommandRun", async () => ({ id: "cmd-logs-follow" }), async () => {
-          await withPatched(JobService.prototype as any, "finishCommandRun", async (_id: string, status: string) => {
-            finishes.push(status);
-          }, async () => {
-            const originalExit = process.exitCode;
-            process.exitCode = undefined;
-            const logs = await captureLogs(async () => {
-              await JobsCommands.run(["logs", "job-follow", "--follow", "--interval", "1"]);
-            });
-            assert(logs.some((l) => l.includes("t1")));
-            assert(logs.some((l) => l.includes("t2")));
-            assert.equal(process.exitCode, 1);
-            assert.equal(finishes.at(-1), "succeeded");
-            process.exitCode = originalExit;
-          });
-        });
-      });
-    });
-  });
-
-  it("inspect succeeds with checkpoint/tasks/tokens", async () => {
-    const finishes: string[] = [];
-    await withPatched(JobInsightsService.prototype as any, "getJob", async () => ({
-      id: "job-inspect",
-      type: "review",
-      jobState: "completed",
-      commandName: "code-review",
-    }), async () => {
-      await withPatched(JobInsightsService.prototype as any, "latestCheckpoint", async () => ({ stage: "done", timestamp: "now" }), async () => {
-        await withPatched(JobInsightsService.prototype as any, "summarizeTasks", async () => ({ totals: { completed: 1 }, tasks: [] }), async () => {
-          await withPatched(JobInsightsService.prototype as any, "summarizeTokenUsage", async () => [{ agentId: "a1", modelName: "m1", tokensTotal: 10 }], async () => {
-            await withPatched(JobService.prototype as any, "startCommandRun", async () => ({ id: "cmd-inspect" }), async () => {
-              await withPatched(JobService.prototype as any, "finishCommandRun", async (_id: string, status: string) => {
-                finishes.push(status);
-              }, async () => {
-                await JobsCommands.run(["inspect", "job-inspect"]);
-                assert.equal(finishes.at(-1), "succeeded");
-              });
-            });
-          });
-        });
-      });
-    });
-  });
-
-  it("status --json includes job_state detail and checkpoint", async () => {
-    const finishes: string[] = [];
-    await withPatched(JobInsightsService.prototype as any, "getJob", async () => ({
-      id: "job-json-status",
-      type: "review",
-      jobState: "running",
-      jobStateDetail: "working",
-      totalUnits: 4,
-      completedUnits: 2,
-      commandName: "code-review",
-    }), async () => {
-      await withPatched(JobInsightsService.prototype as any, "latestCheckpoint", async () => ({ stage: "stage-x", timestamp: "ts" }), async () => {
-        await withPatched(JobService.prototype as any, "startCommandRun", async () => ({ id: "cmd-status" }), async () => {
-          await withPatched(JobService.prototype as any, "finishCommandRun", async (_id: string, status: string) => {
-            finishes.push(status);
-          }, async () => {
-            const logs = await captureLogs(async () => {
-              await JobsCommands.run(["status", "job-json-status", "--json"]);
-            });
-            const payload = JSON.parse(logs.join("\n"));
-            assert.equal(payload.job.job_state, "running");
-            assert.equal(payload.job.job_state_detail, "working");
-            assert.equal(payload.job.completed_units, 2);
-            assert.equal(payload.checkpoint.stage, "stage-x");
-            assert.equal(finishes.at(-1), "succeeded");
-          });
-        });
-      });
-    });
-  });
-
-  it("resume succeeds when manifest matches", async () => {
-    const finishes: string[] = [];
-    let resumeCalled = 0;
-    await withPatched(JobResumeService.prototype as any, "resume", async () => {
-      resumeCalled += 1;
-    }, async () => {
-      await withPatched(JobService.prototype as any, "startCommandRun", async () => ({ id: "cmd-resume" }), async () => {
-        await withPatched(JobService.prototype as any, "finishCommandRun", async (_id: string, status: string) => {
-          finishes.push(status);
-        }, async () => {
-          await JobsCommands.run(["resume", "job-resume"]);
-          assert.equal(resumeCalled, 1);
-          assert.equal(finishes.at(-1), "succeeded");
-        });
-      });
-    });
-  });
-
-  it("cancel succeeds in running state", async () => {
-    const finishes: string[] = [];
-    await withPatched(JobInsightsService.prototype as any, "getJob", async () => ({
-      id: "job-cancel",
-      type: "review",
-      jobState: "running",
-      commandName: "code-review",
-    }), async () => {
-      await withPatched(JobInsightsService.prototype as any, "cancelJob", async () => {}, async () => {
-        await withPatched(JobService.prototype as any, "startCommandRun", async () => ({ id: "cmd-cancel" }), async () => {
-          await withPatched(JobService.prototype as any, "finishCommandRun", async (_id: string, status: string) => {
-            finishes.push(status);
-          }, async () => {
-            await JobsCommands.run(["cancel", "job-cancel"]);
-            assert.equal(finishes.at(-1), "succeeded");
-          });
-        });
-      });
-    });
-  });
-});

package/packages/cli/src/__tests__/JobsCommands.test.ts

@@ -1,49 +0,0 @@
-import assert from "node:assert/strict";
-import path from "node:path";
-import { describe, it } from "node:test";
-import { parseJobArgs } from "../commands/jobs/JobsCommands.js";
-
-describe("job CLI parsing", () => {
-  it("parses list filters and json flag", () => {
-    const parsed = parseJobArgs(["list", "--project", "PROJ", "--status", "running", "--type", "work", "--since", "1h", "--limit", "5", "--json"]);
-    assert.equal(parsed.subcommand, "list");
-    assert.equal(parsed.project, "PROJ");
-    assert.equal(parsed.status, "running");
-    assert.equal(parsed.type, "work");
-    assert.equal(parsed.since, "1h");
-    assert.equal(parsed.limit, 5);
-    assert.equal(parsed.json, true);
-  });
-
-  it("accepts positional job id for status/logs/watch", () => {
-    const parsed = parseJobArgs(["status", "job-123"]);
-    assert.equal(parsed.subcommand, "status");
-    assert.equal(parsed.jobId, "job-123");
-  });
-
-  it("parses watch interval and no-logs with workspace root", () => {
-    const root = path.resolve("/tmp/demo");
-    const parsed = parseJobArgs(["watch", "job-5", "--interval", "2", "--no-logs", "--workspace-root", root]);
-    assert.equal(parsed.subcommand, "watch");
-    assert.equal(parsed.jobId, "job-5");
-    assert.equal(parsed.intervalSeconds, 2);
-    assert.equal(parsed.noLogs, true);
-    assert.equal(parsed.workspaceRoot, root);
-  });
-
-  it("captures resume agent flag", () => {
-    const parsed = parseJobArgs(["resume", "job-9", "--agent", "codex"]);
-    assert.equal(parsed.subcommand, "resume");
-    assert.equal(parsed.jobId, "job-9");
-    assert.equal(parsed.agent, "codex");
-  });
-
-  it("parses logs follow and since", () => {
-    const parsed = parseJobArgs(["logs", "job-10", "--since", "2025-01-01T00:00:00Z", "--follow"]);
-    assert.equal(parsed.subcommand, "logs");
-    assert.equal(parsed.jobId, "job-10");
-    assert.equal(parsed.since, "2025-01-01T00:00:00Z");
-    assert.equal(parsed.follow, true);
-  });
-});
-

package/packages/cli/src/__tests__/MigrateTasksCommand.test.ts

@@ -1,36 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { parseMigrateTasksArgs } from "../commands/planning/MigrateTasksCommand.js";
-
-describe("migrate-tasks argument parsing", () => {
-  it("captures refine plans and flags", () => {
-    const parsed = parseMigrateTasksArgs([
-      "--workspace-root",
-      "/tmp/ws",
-      "--project-key",
-      "proj",
-      "--plan-dir",
-      "./plans",
-      "--refine-plan",
-      "a.json",
-      "--refine-plan",
-      "b.json",
-      "--refine-plans-dir",
-      "./refines",
-      "--force",
-      "--quiet",
-    ]);
-    assert.equal(parsed.workspaceRoot, "/tmp/ws");
-    assert.equal(parsed.projectKey, "proj");
-    assert.equal(parsed.planDir, "./plans");
-    assert.deepEqual(parsed.refinePlans, ["a.json", "b.json"]);
-    assert.equal(parsed.refinePlansDir, "./refines");
-    assert.equal(parsed.force, true);
-    assert.equal(parsed.quiet, true);
-  });
-
-  it("flags help when requested", () => {
-    const parsed = parseMigrateTasksArgs(["--help"]);
-    assert.equal(parsed.help, true);
-  });
-});

package/packages/cli/src/__tests__/OpenapiCommands.test.ts

@@ -1,34 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import path from "node:path";
-import { parseOpenapiArgs } from "../commands/openapi/OpenapiCommands.js";
-
-describe("openapi-from-docs argument parsing", () => {
-  it("defaults agentStream to true", () => {
-    const parsed = parseOpenapiArgs([]);
-    assert.equal(parsed.agentStream, true);
-  });
-
-  it("parses agentStream false", () => {
-    const parsed = parseOpenapiArgs(["--agent-stream", "false"]);
-    assert.equal(parsed.agentStream, false);
-  });
-
-  it("parses agentStream with inline value", () => {
-    const parsed = parseOpenapiArgs(["--agent-stream=false"]);
-    assert.equal(parsed.agentStream, false);
-  });
-
-  it("captures workspace root when provided", () => {
-    const root = path.resolve("/tmp/my-workspace");
-    const parsed = parseOpenapiArgs(["--workspace-root", root]);
-    assert.equal(parsed.workspaceRoot, root);
-  });
-
-  it("captures force, dry-run, and validate-only flags", () => {
-    const parsed = parseOpenapiArgs(["--force", "--dry-run", "--validate-only"]);
-    assert.equal(parsed.force, true);
-    assert.equal(parsed.dryRun, true);
-    assert.equal(parsed.validateOnly, true);
-  });
-});

package/packages/cli/src/__tests__/OrderTasksCommand.test.ts

@@ -1,150 +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 { PathHelper } from "@mcoda/shared";
-import { parseOrderTasksArgs, OrderTasksCommand } from "../commands/backlog/OrderTasksCommand.js";
-
-const setupWorkspace = async () => {
-  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "mcoda-cli-order-"));
-  const mcodaDir = path.join(dir, ".mcoda");
-  await fs.mkdir(mcodaDir, { recursive: true });
-  const dbPath = PathHelper.getWorkspaceDbPath(dir);
-  const connection = await Connection.open(dbPath);
-  await WorkspaceMigrations.run(connection.db);
-  const repo = new WorkspaceRepository(connection.db, connection);
-
-  const project = await repo.createProjectIfMissing({ key: "CLI", name: "CLI" });
-  const [epic] = await repo.insertEpics(
-    [
-      {
-        projectId: project.id,
-        key: "cli-01",
-        title: "Epic",
-        description: "",
-      },
-    ],
-    true,
-  );
-  const [story] = await repo.insertStories(
-    [
-      {
-        projectId: project.id,
-        epicId: epic.id,
-        key: "cli-01-us-01",
-        title: "Story",
-        description: "",
-      },
-    ],
-    true,
-  );
-  const [t1, t2, t3] = await repo.insertTasks(
-    [
-      {
-        projectId: project.id,
-        epicId: epic.id,
-        userStoryId: story.id,
-        key: "CLI-01-T01",
-        title: "Root complete",
-        description: "",
-        status: "completed",
-      },
-      {
-        projectId: project.id,
-        epicId: epic.id,
-        userStoryId: story.id,
-        key: "CLI-01-T02",
-        title: "Next",
-        description: "",
-        status: "not_started",
-      },
-      {
-        projectId: project.id,
-        epicId: epic.id,
-        userStoryId: story.id,
-        key: "CLI-01-T03",
-        title: "Blocked child",
-        description: "",
-        status: "not_started",
-      },
-    ],
-    true,
-  );
-  await repo.insertTaskDependencies(
-    [
-      { taskId: t2.id, dependsOnTaskId: t1.id, relationType: "blocks" },
-      { taskId: t3.id, dependsOnTaskId: t2.id, relationType: "blocks" },
-    ],
-    true,
-  );
-
-  return { dir, repo, project };
-};
-
-const cleanupWorkspace = async (dir: string, repo: WorkspaceRepository) => {
-  try {
-    await repo.close();
-  } catch {
-    /* ignore */
-  }
-  await fs.rm(dir, { recursive: true, force: true });
-};
-
-test("parseOrderTasksArgs respects defaults and flags", () => {
-  const parsed = parseOrderTasksArgs([
-    "--workspace-root",
-    "/tmp/ws",
-    "--project",
-    "CLI",
-    "--epic",
-    "E1",
-    "--status",
-    "not_started,in_progress",
-    "--include-blocked",
-    "--agent",
-    "codex",
-    "--agent-stream",
-    "false",
-    "--json",
-  ]);
-  assert.equal(parsed.workspaceRoot, path.resolve("/tmp/ws"));
-  assert.equal(parsed.project, "CLI");
-  assert.equal(parsed.epic, "E1");
-  assert.deepEqual(parsed.status, ["not_started", "in_progress"]);
-  assert.equal(parsed.includeBlocked, true);
-  assert.equal(parsed.agentName, "codex");
-  assert.equal(parsed.agentStream, false);
-  assert.equal(parsed.json, true);
-});
-
-test("order-tasks command prints ordering and records telemetry", async () => {
-  const ctx = await setupWorkspace();
-  const logs: string[] = [];
-  const origLog = console.log;
-  console.log = (...args: unknown[]) => logs.push(args.join(" "));
-  try {
-    await OrderTasksCommand.run([
-      "--workspace-root",
-      ctx.dir,
-      "--project",
-      ctx.project.key,
-      "--status",
-      "not_started,completed",
-    ]);
-  } finally {
-    console.log = origLog;
-  }
-
-  const output = logs.join("\n");
-  assert.ok(output.includes("CLI-01-T01"));
-  assert.ok(output.includes("CLI-01-T02"));
-
-  const commandRuns = await ctx.repo
-    .getDb()
-    .all<{ command_name: string }[]>("SELECT command_name FROM command_runs WHERE command_name = 'order-tasks'");
-  assert.ok(commandRuns.length >= 1);
-
-  await cleanupWorkspace(ctx.dir, ctx.repo);
-});

package/packages/cli/src/__tests__/PlanningCommands.test.ts

@@ -1,9 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { PlanningCommands } from "../commands/planning/PlanningCommands.js";
-
-describe("planning commands", () => {
-  it("exports a planning commands class", () => {
-    assert.equal(typeof PlanningCommands, "function");
-  });
-});