mcoda 0.1.0

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

@@ -0,0 +1,285 @@
+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";
+import { TaskStateService } from "../TaskStateService.js";
+import { WorkOnTasksService } from "../WorkOnTasksService.js";
+import { JobService } from "../../jobs/JobService.js";
+
+class StubAgentService {
+  async resolveAgent() {
+    return { id: "agent-1", slug: "agent-1", adapter: "local-model", defaultModel: "stub" } as any;
+  }
+  async invoke(_id: string, _req: any) {
+    const patch = "```patch\n--- a/tmp.txt\n+++ b/tmp.txt\n@@\n-foo\n+bar\n```";
+    return { output: patch, adapter: "local-model" };
+  }
+  async getPrompts() {
+    return {
+      jobPrompt: "You are a worker.",
+      characterPrompt: "Be concise.",
+      commandPrompts: { "work-on-tasks": "Apply patches carefully." },
+    };
+  }
+}
+
+class StubAgentServiceNoPlus {
+  async resolveAgent() {
+    return { id: "agent-1", slug: "agent-1", adapter: "local-model", defaultModel: "stub" } as any;
+  }
+  async invoke(_id: string, _req: any) {
+    const patch = [
+      "```patch",
+      "*** Begin Patch",
+      "*** Add File: hello.txt",
+      "hello world",
+      "*** End Patch",
+      "```",
+    ].join("\n");
+    return { output: patch, adapter: "local-model" };
+  }
+  async getPrompts() {
+    return {
+      jobPrompt: "You are a worker.",
+      characterPrompt: "Be concise.",
+      commandPrompts: { "work-on-tasks": "Apply patches carefully." },
+    };
+  }
+}
+
+class StubDocdex {
+  async search() {
+    return [];
+  }
+  async close() {}
+}
+
+class StubRepo {
+  async getWorkspaceDefaults() {
+    return [];
+  }
+  async close() {}
+}
+
+class StubRoutingService {
+  async resolveAgentForCommand() {
+    return {
+      agent: { id: "agent-1", slug: "agent-1", adapter: "local-model", defaultModel: "stub" } as any,
+      agentId: "agent-1",
+      agentSlug: "agent-1",
+      model: "stub",
+      capabilities: [],
+      healthStatus: "healthy",
+      source: "override",
+      routingPreview: { workspaceId: "ws", commandName: "work-on-tasks" } as any,
+    };
+  }
+}
+
+class StubVcs {
+  async ensureRepo(_cwd: string) {}
+  async ensureBaseBranch(_cwd: string, _base: string) {}
+  async branchExists(_cwd: string, _branch: string) {
+    return false;
+  }
+  async checkoutBranch(_cwd: string, _branch: string) {}
+  async createOrCheckoutBranch(_cwd: string, _branch: string, _base: string) {}
+  async applyPatch(_cwd: string, _patch: string) {}
+  async pull(_cwd: string, _remote: string, _branch: string, _ffOnly = true) {}
+  async conflictPaths(_cwd?: string) {
+    return [];
+  }
+  async currentBranch(_cwd?: string) {
+    return "mcoda-dev";
+  }
+  async ensureClean(_cwd: string, _ignoreDotMcoda = true) {}
+  async dirtyPaths(_cwd?: string) {
+    return [];
+  }
+  async stage(_cwd: string, _paths: string[]) {}
+  async status(_cwd?: string) {
+    return " M tmp.txt";
+  }
+  async commit(_cwd: string, _message: string) {}
+  async lastCommitSha(_cwd?: string) {
+    return "abc123";
+  }
+  async hasRemote(_cwd?: string) {
+    return false;
+  }
+  async push(_cwd: string, _remote: string, _branch: string) {}
+  async merge(_cwd: string, _source: string, _target: string) {}
+}
+
+class RecordingVcs extends StubVcs {
+  patches: string[] = [];
+  override async applyPatch(_cwd: string, patch: string) {
+    this.patches.push(patch);
+    if (!patch.includes("+hello world")) {
+      throw new Error("patch missing content");
+    }
+  }
+  override async status() {
+    return "";
+  }
+}
+
+const setupWorkspace = async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "mcoda-work-"));
+  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: "",
+        priority: 1,
+      },
+    ],
+    false,
+  );
+  const [story] = await repo.insertStories(
+    [
+      {
+        projectId: project.id,
+        epicId: epic.id,
+        key: "proj-epic-us-01",
+        title: "Story",
+        description: "",
+      },
+    ],
+    false,
+  );
+  const tasks = await repo.insertTasks(
+    [
+      {
+        projectId: project.id,
+        epicId: epic.id,
+        userStoryId: story.id,
+        key: "proj-epic-us-01-t01",
+        title: "Task A",
+        description: "",
+        status: "not_started",
+        storyPoints: 1,
+      },
+      {
+        projectId: project.id,
+        epicId: epic.id,
+        userStoryId: story.id,
+        key: "proj-epic-us-01-t02",
+        title: "Task B",
+        description: "",
+        status: "not_started",
+        storyPoints: 2,
+      },
+    ],
+    false,
+  );
+  return { dir, workspace, repo, tasks };
+};
+
+const cleanupWorkspace = async (dir: string, repo: WorkspaceRepository) => {
+  try {
+    await repo.close();
+  } catch {
+    /* ignore */
+  }
+  await fs.rm(dir, { recursive: true, force: true });
+};
+
+test("workOnTasks marks tasks ready_to_review and records task runs", async () => {
+  const { dir, workspace, repo, tasks } = await setupWorkspace();
+  const jobService = new JobService(workspace.workspaceRoot, repo);
+  const selectionService = new TaskSelectionService(workspace, repo);
+  const stateService = new TaskStateService(repo);
+  const service = new WorkOnTasksService(workspace, {
+    agentService: new StubAgentService() as any,
+    docdex: new StubDocdex() as any,
+    jobService,
+    workspaceRepo: repo,
+    selectionService,
+    stateService,
+    repo: new StubRepo() as any,
+    routingService: new StubRoutingService() as any,
+    vcsClient: new StubVcs() as any,
+  });
+
+  try {
+    const result = await service.workOnTasks({
+      workspace,
+      projectKey: "proj",
+      agentStream: false,
+      dryRun: false,
+    });
+    assert.equal(result.results.length, 2);
+    const updatedA = await repo.getTaskByKey(tasks[0].key);
+    const updatedB = await repo.getTaskByKey(tasks[1].key);
+    assert.equal(updatedA?.status, "ready_to_review");
+    assert.equal(updatedB?.status, "ready_to_review");
+    const db = repo.getDb();
+    const taskRuns = await db.all<{ status: string }[]>("SELECT status FROM task_runs WHERE command = 'work-on-tasks'");
+    assert.equal(taskRuns.length, 2);
+    assert.ok(taskRuns.every((r) => r.status === "succeeded"));
+    const jobs = await db.all<{ state: string }[]>("SELECT state FROM jobs");
+    assert.ok(jobs.some((j) => j.state === "completed"));
+    const tokens = await db.all<{ tokens_prompt: number }[]>("SELECT tokens_prompt FROM token_usage");
+    assert.equal(tokens.length, 2);
+    const logs = await db.all<{ source: string }[]>("SELECT source FROM task_logs");
+    assert.ok(logs.some((l) => l.source === "agent"));
+    assert.ok(logs.some((l) => l.source === "finalize"));
+    const commandRunRow = await db.get<{ sp_processed: number | null }>(
+      "SELECT sp_processed FROM command_runs WHERE id = ?",
+      result.commandRunId,
+    );
+    assert.equal(commandRunRow?.sp_processed, 3);
+    const checkpointPath = path.join(workspace.workspaceRoot, ".mcoda", "jobs", result.jobId, "work", "state.json");
+    const exists = await fs.stat(checkpointPath).then(() => true, () => false);
+    assert.equal(exists, true);
+  } finally {
+    await service.close();
+    await cleanupWorkspace(dir, repo);
+  }
+});
+
+test("workOnTasks handles apply_patch add-file output without leading '+' lines", async () => {
+  const { dir, workspace, repo } = await setupWorkspace();
+  const jobService = new JobService(workspace.workspaceRoot, repo);
+  const selectionService = new TaskSelectionService(workspace, repo);
+  const stateService = new TaskStateService(repo);
+  const vcs = new RecordingVcs();
+  const service = new WorkOnTasksService(workspace, {
+    agentService: new StubAgentServiceNoPlus() as any,
+    docdex: new StubDocdex() as any,
+    jobService,
+    workspaceRepo: repo,
+    selectionService,
+    stateService,
+    repo: new StubRepo() as any,
+    routingService: new StubRoutingService() as any,
+    vcsClient: vcs as any,
+  });
+
+  try {
+    const result = await service.workOnTasks({
+      workspace,
+      projectKey: "proj",
+      agentStream: false,
+      dryRun: false,
+      noCommit: true,
+      limit: 1,
+    });
+    assert.equal(result.results.length, 1);
+    assert.equal(result.results[0]?.status, "succeeded");
+    assert.ok(vcs.patches.some((p) => p.includes("+hello world")));
+  } finally {
+    await service.close();
+    await cleanupWorkspace(dir, repo);
+  }
+});

package/packages/core/src/services/jobs/JobInsightsService.ts

@@ -0,0 +1,355 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { PathHelper } from "@mcoda/shared";
+import { WorkspaceResolution } from "../../workspace/WorkspaceManager.js";
+import { JobRecord, JobService, JobState } from "./JobService.js";
+import { JobsApiClient } from "./JobsApiClient.js";
+import { TelemetryService, TokenUsageRow } from "../telemetry/TelemetryService.js";
+
+export interface JobListFilters {
+  status?: string;
+  type?: string;
+  projectKey?: string;
+  since?: string;
+  limit?: number;
+}
+
+export interface JobSummary extends JobRecord {
+  progressPct?: number | null;
+  lastCheckpointStage?: string;
+  lastCheckpointAt?: string;
+  stateDetail?: string;
+  jobState?: JobState;
+  jobStateDetail?: string;
+  totalUnits?: number;
+  completedUnits?: number;
+}
+
+export interface CheckpointSummary {
+  stage?: string;
+  timestamp?: string;
+  details?: Record<string, unknown>;
+  path?: string;
+}
+
+export interface JobLogEntry {
+  timestamp: string;
+  sequence?: number | null;
+  level?: string | null;
+  source?: string | null;
+  message?: string | null;
+  taskId?: string | null;
+  taskKey?: string | null;
+  phase?: string | null;
+  details?: Record<string, unknown> | null;
+}
+
+export interface JobLogsResult {
+  entries: JobLogEntry[];
+  cursor?: { timestamp: string; sequence?: number | null };
+}
+
+export interface TaskRunSnapshot {
+  taskId?: string | null;
+  taskKey?: string | null;
+  status?: string | null;
+  startedAt?: string | null;
+  finishedAt?: string | null;
+  command?: string | null;
+}
+
+export interface TaskRunSummary {
+  totals: Record<string, number>;
+  tasks: TaskRunSnapshot[];
+}
+
+export interface TokenUsageSummary {
+  agentId?: string | null;
+  modelName?: string | null;
+  commandName?: string | null;
+  commandRunId?: string | null;
+  taskId?: string | null;
+  tokensPrompt?: number | null;
+  tokensCompletion?: number | null;
+  tokensTotal?: number | null;
+  cost?: number | null;
+}
+
+const parseSinceInput = (input?: string): string | undefined => {
+  if (!input) return undefined;
+  const trimmed = input.trim();
+  const durationMatch = trimmed.match(/^(\d+)([smhdw])$/i);
+  if (durationMatch) {
+    const amount = Number(durationMatch[1]);
+    const unit = durationMatch[2].toLowerCase();
+    const multipliers: Record<string, number> = {
+      s: 1000,
+      m: 60 * 1000,
+      h: 60 * 60 * 1000,
+      d: 24 * 60 * 60 * 1000,
+      w: 7 * 24 * 60 * 60 * 1000,
+    };
+    if (multipliers[unit]) {
+      return new Date(Date.now() - amount * multipliers[unit]).toISOString();
+    }
+  }
+  const parsed = Date.parse(trimmed);
+  if (!Number.isNaN(parsed)) {
+    return new Date(parsed).toISOString();
+  }
+  return undefined;
+};
+
+const computeProgress = (job: { totalItems?: number | null; processedItems?: number | null }): number | null => {
+  const total = (job as any).totalUnits ?? job.totalItems ?? null;
+  const completed = (job as any).completedUnits ?? job.processedItems ?? 0;
+  if (!total || total <= 0) return null;
+  return Math.round((completed / total) * 100);
+};
+
+const mapJobRow = (row: any): JobSummary => {
+  const payload = row.payload_json ? JSON.parse(row.payload_json) : undefined;
+  const totalUnits = row.total_units ?? row.totalUnits ?? row.total_items ?? row.totalItems ?? undefined;
+  const completedUnits = row.completed_units ?? row.completedUnits ?? row.processed_items ?? row.processedItems ?? undefined;
+  const progressPct = computeProgress({ totalItems: totalUnits, processedItems: completedUnits });
+  return {
+    id: row.id,
+    type: row.type,
+    state: row.state ?? row.job_state,
+    jobState: row.job_state ?? row.state,
+    jobStateDetail: row.job_state_detail ?? row.state_detail ?? row.errorSummary,
+    stateDetail: row.job_state_detail ?? row.state_detail ?? row.errorSummary,
+    commandName: row.command_name ?? row.commandName,
+    commandRunId: row.command_run_id ?? row.commandRunId,
+    workspaceId: row.workspace_id ?? row.workspaceId,
+    projectKey: row.projectKey,
+    payload,
+    totalItems: totalUnits,
+    processedItems: completedUnits,
+    totalUnits,
+    completedUnits,
+    lastCheckpoint: row.last_checkpoint ?? row.lastCheckpoint,
+    createdAt: row.created_at ?? row.createdAt,
+    updatedAt: row.updated_at ?? row.updatedAt,
+    completedAt: row.completed_at ?? row.completedAt,
+    errorSummary: row.error_summary ?? row.errorSummary,
+    progressPct,
+  };
+};
+
+const matchesProject = (payload: Record<string, unknown> | undefined, projectKey?: string): boolean => {
+  if (!projectKey) return true;
+  if (!payload) return false;
+  const candidates = [
+    (payload as any).projectKey,
+    (payload as any).project_id,
+    (payload as any).project,
+    (payload as any).projectId,
+  ].filter(Boolean);
+  return candidates.includes(projectKey);
+};
+
+export class JobInsightsService {
+  private apiClient?: JobsApiClient;
+
+  constructor(private workspace: WorkspaceResolution, private jobService: JobService, apiBaseUrl?: string) {
+    if (apiBaseUrl) {
+      this.apiClient = new JobsApiClient(workspace, apiBaseUrl);
+    }
+  }
+
+  static async create(workspace: WorkspaceResolution): Promise<JobInsightsService> {
+    const jobService = new JobService(workspace, undefined, { requireRepo: true });
+    const apiBaseUrl =
+      (workspace as any).config?.api?.baseUrl ??
+      process.env.MCODA_API_BASE_URL ??
+      process.env.MCODA_JOBS_API_URL ??
+      undefined;
+    return new JobInsightsService(workspace, jobService, apiBaseUrl);
+  }
+
+  async close(): Promise<void> {
+    await this.jobService.close();
+  }
+
+  async listJobs(filters: JobListFilters = {}): Promise<JobSummary[]> {
+    if (!this.apiClient) {
+      throw new Error(
+        "Jobs API is not configured; set MCODA_API_BASE_URL/MCODA_JOBS_API_URL or workspace api.baseUrl to query jobs.",
+      );
+    }
+    const remote = (await this.apiClient.listJobs({
+      status: filters.status,
+      type: filters.type,
+      project: filters.projectKey,
+      since: filters.since,
+      limit: filters.limit,
+    })) ?? [];
+    const rows = remote.map(mapJobRow);
+    const sinceIso = parseSinceInput(filters.since);
+    return rows
+      .filter((job) => {
+        const state = (job as any).jobState ?? job.state;
+        return !filters.status || state === filters.status;
+      })
+      .filter((job) => (!filters.type || job.type === filters.type))
+      .filter((job) => matchesProject(job.payload, filters.projectKey))
+      .filter((job) => {
+        if (!sinceIso) return true;
+        const updated = job.updatedAt ?? job.createdAt;
+        if (!updated) return true;
+        return Date.parse(updated) >= Date.parse(sinceIso);
+      })
+      .slice(0, Number.isFinite(filters.limit) ? (filters.limit as number) : rows.length)
+      .map((job) => ({ ...job, progressPct: computeProgress(job) }));
+  }
+
+  async getJob(jobId: string): Promise<JobSummary | undefined> {
+    if (!this.apiClient) {
+      throw new Error(
+        "Jobs API is not configured; set MCODA_API_BASE_URL/MCODA_JOBS_API_URL or workspace api.baseUrl to read job status.",
+      );
+    }
+    const remote = await this.apiClient.getJob(jobId);
+    const job = remote ? mapJobRow(remote) : undefined;
+    if (!job) return undefined;
+    const detail = (job as any).job_state_detail ?? (job as any).jobStateDetail ?? job.errorSummary;
+    const totalUnits = (job as any).totalUnits ?? job.totalItems ?? (job as any).total_units ?? undefined;
+    const completedUnits = (job as any).completedUnits ?? job.processedItems ?? (job as any).completed_units ?? undefined;
+    return {
+      ...job,
+      jobState: (job as any).job_state ?? job.state,
+      jobStateDetail: detail,
+      stateDetail: detail,
+      totalUnits,
+      completedUnits,
+      progressPct: computeProgress({ totalItems: totalUnits, processedItems: completedUnits }),
+    };
+  }
+
+  async latestCheckpoint(jobId: string): Promise<CheckpointSummary | undefined> {
+    if (!this.apiClient) {
+      throw new Error(
+        "Jobs API is not configured; set MCODA_API_BASE_URL/MCODA_JOBS_API_URL or workspace api.baseUrl to read checkpoints.",
+      );
+    }
+    const remote = await this.apiClient.getCheckpoint(jobId);
+    if (remote && ((remote as any).stage || (remote as any).status || (remote as any).timestamp)) {
+      const data = remote as any;
+      return {
+        stage: data.stage ?? data.status,
+        timestamp: data.timestamp ?? data.created_at,
+        details: data.details ?? data.progress,
+      };
+    }
+    const checkpoints = await this.jobService.readCheckpoints(jobId);
+    if (!checkpoints.length) return undefined;
+    const last = checkpoints[checkpoints.length - 1] as any;
+    return {
+      stage: last.stage ?? last.status,
+      timestamp: last.timestamp ?? last.created_at,
+      details: last.details,
+    };
+  }
+
+  async getJobLogs(
+    jobId: string,
+    options: { since?: string; after?: { timestamp: string; sequence?: number | null } } = {},
+  ): Promise<JobLogsResult> {
+    if (!this.apiClient) {
+      throw new Error(
+        "Jobs API is not configured; set MCODA_API_BASE_URL/MCODA_JOBS_API_URL or workspace api.baseUrl to stream job logs.",
+      );
+    }
+    const remote = await this.apiClient.getLogs(jobId, options);
+    if (!remote) return { entries: [], cursor: undefined };
+    return remote;
+  }
+
+  async summarizeTasks(jobId: string): Promise<TaskRunSummary> {
+    if (!this.apiClient) {
+      throw new Error(
+        "Jobs API is not configured; set MCODA_API_BASE_URL/MCODA_JOBS_API_URL or workspace api.baseUrl to read task summaries.",
+      );
+    }
+    const remote = (await this.apiClient.getTasksSummary(jobId)) ?? { totals: {}, tasks: [] };
+    const runs = (remote.tasks ?? []).map((t) => {
+      const taskId = (t as any).taskId ?? t.task_id ?? null;
+      const taskKey = (t as any).taskKey ?? t.task_key ?? null;
+      const startedAt = (t as any).startedAt ?? t.started_at ?? null;
+      const finishedAt = (t as any).finishedAt ?? t.finished_at ?? null;
+      const command = (t as any).command ?? null;
+      return { taskId, taskKey, status: t.status ?? null, startedAt, finishedAt, command };
+    });
+    const totalsRemote = remote.totals ?? {};
+    const totals: Record<string, number> = {};
+    for (const run of runs) {
+      const status = run.status ?? "unknown";
+      totals[status] = (totals[status] ?? 0) + 1;
+    }
+    Object.entries(totalsRemote ?? {}).forEach(([k, v]) => {
+      totals[k] = v as number;
+    });
+    const tasks: TaskRunSnapshot[] = runs.map((run) => ({
+      taskId: run.taskId ?? undefined,
+      taskKey: run.taskKey ?? undefined,
+      status: run.status ?? undefined,
+      startedAt: run.startedAt ?? undefined,
+      finishedAt: run.finishedAt ?? undefined,
+      command: run.command ?? undefined,
+    }));
+    return { totals, tasks };
+  }
+
+  async summarizeTokenUsage(jobId: string): Promise<TokenUsageSummary[]> {
+    const telemetry = await TelemetryService.create(this.workspace, { allowMissingTelemetry: false, requireApi: true });
+    try {
+      const summary = await telemetry.getSummary({
+        jobId,
+        groupBy: ["command", "agent", "model"],
+        since: undefined,
+        until: undefined,
+      });
+      return summary.map((row) => ({
+        commandName: row.command_name ?? null,
+        agentId: row.agent_id ?? null,
+        modelName: row.model_name ?? null,
+        tokensPrompt: row.tokens_prompt ?? null,
+        tokensCompletion: row.tokens_completion ?? null,
+        tokensTotal: row.tokens_total ?? null,
+        cost: row.cost_estimate ?? null,
+      }));
+    } finally {
+      await telemetry.close();
+    }
+  }
+
+  async readJobLog(jobId: string): Promise<string> {
+    return this.jobService.readLog(jobId);
+  }
+
+  async readJobLogTail(jobId: string, offset: number): Promise<{ content: string; nextOffset: number }> {
+    const logPath = path.join(PathHelper.getWorkspaceDir(this.workspace.workspaceRoot), "jobs", jobId, "logs", "stream.log");
+    try {
+      const content = await fs.readFile(logPath, "utf8");
+      const slice = offset > 0 ? content.slice(offset) : content;
+      return { content: slice, nextOffset: content.length };
+    } catch {
+      return { content: "", nextOffset: offset };
+    }
+  }
+
+  async updateJobState(jobId: string, state: JobState, meta?: Record<string, unknown>): Promise<void> {
+    await this.jobService.updateJobStatus(jobId, state, meta);
+  }
+
+  async cancelJob(jobId: string, options: { force?: boolean; reason?: string } = {}): Promise<void> {
+    if (this.apiClient) {
+      await this.apiClient.cancelJob(jobId, options);
+      return;
+    }
+    throw new Error(
+      "Cancel requires the jobs API; set MCODA_API_BASE_URL or workspace baseUrl so the cancel endpoint can enforce state transitions.",
+    );
+  }
+}