mcoda 0.1.2 → 0.1.4

package/packages/core/src/services/review/__tests__/CodeReviewService.test.ts

@@ -1,89 +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 { JobService } from "../../jobs/JobService.js";
-import { CodeReviewService } from "../CodeReviewService.js";
-
-test("CodeReviewService records approvals and updates status", async () => {
-  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "mcoda-review-"));
-  const workspace = await WorkspaceResolver.resolveWorkspace({ cwd: dir, explicitWorkspace: dir });
-  const repo = await WorkspaceRepository.create(workspace.workspaceRoot);
-  const jobService = new JobService(workspace.workspaceRoot, repo);
-
-  const diffStub = [
-    "diff --git a/file.txt b/file.txt",
-    "index 1111111..2222222 100644",
-    "--- a/file.txt",
-    "+++ b/file.txt",
-    "@@ -1 +1 @@",
-    "-foo",
-    "+bar",
-    "",
-  ].join("\n");
-
-  const service = new CodeReviewService(workspace, {
-    agentService: {
-      invoke: async () => ({ output: '{"decision":"approve","summary":"ok","findings":[]}', adapter: "local" }),
-      getPrompts: async () => ({
-        jobPrompt: "Job",
-        characterPrompt: "Char",
-        commandPrompts: { "code-review": "Review prompt" },
-      }),
-    } as any,
-    docdex: { search: async () => [] } as any,
-    jobService,
-    workspaceRepo: repo,
-    repo: { close: async () => {} } as any,
-    routingService: {
-      resolveAgentForCommand: async () => ({
-        agent: { id: "agent-1", slug: "agent-1", adapter: "local", defaultModel: "stub" },
-      }),
-    } as any,
-    vcsClient: {
-      ensureRepo: async () => {},
-      diff: async () => diffStub,
-    } as any,
-  });
-
-  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_review",
-      },
-    ]);
-    await repo.updateTask(task.id, { vcsBranch: "feature/task" });
-
-    const result = await service.reviewTasks({
-      workspace,
-      projectKey: project.key,
-      agentStream: false,
-      dryRun: false,
-    });
-
-    assert.equal(result.tasks.length, 1);
-    assert.equal(result.tasks[0]?.decision, "approve");
-
-    const updated = await repo.getTaskByKey(task.key);
-    assert.equal(updated?.status, "ready_to_qa");
-  } finally {
-    await service.close();
-    await fs.rm(dir, { recursive: true, force: true });
-  }
-});

package/packages/core/src/services/system/SystemUpdateService.ts

@@ -1,177 +0,0 @@
-import path from "node:path";
-import { promises as fs } from "node:fs";
-import { spawn } from "node:child_process";
-import { ApplyUpdateResponse, PathHelper, UpdateChannel, UpdateInfo } from "@mcoda/shared";
-import { GlobalCommandStatus, GlobalRepository } from "@mcoda/db";
-import { SystemClient } from "@mcoda/integrations";
-
-const nowIso = (): string => new Date().toISOString();
-
-interface ReleasesState {
-  lastCheck?: (UpdateInfo & { checkedAt: string });
-  preferences?: { channel?: UpdateChannel };
-}
-
-export interface UpdateCheckResult {
-  info: UpdateInfo;
-  checkedAt: string;
-  channel: UpdateChannel;
-}
-
-export type ApplyStatus = ApplyUpdateResponse["status"];
-
-export interface ApplyResult extends ApplyUpdateResponse {
-  targetVersion: string;
-  npmCommand: string;
-}
-
-const normalizeChannel = (channel?: string): UpdateChannel => {
-  if (!channel) return "stable";
-  if (channel === "stable" || channel === "beta" || channel === "nightly") return channel;
-  throw new Error(`Unsupported channel: ${channel}`);
-};
-
-const parseJson = async <T>(filePath: string): Promise<T | undefined> => {
-  try {
-    const raw = await fs.readFile(filePath, "utf8");
-    return JSON.parse(raw) as T;
-  } catch {
-    return undefined;
-  }
-};
-
-export class SystemUpdateService {
-  private mcodaDir: string;
-
-  private constructor(
-    private client: SystemClient,
-    private repo?: GlobalRepository,
-    options: { mcodaDir?: string } = {},
-  ) {
-    this.mcodaDir = options.mcodaDir ?? PathHelper.getGlobalMcodaDir();
-  }
-
-  static async create(
-    baseUrl?: string,
-    options: { client?: SystemClient; repo?: GlobalRepository; mcodaDir?: string } = {},
-  ): Promise<SystemUpdateService> {
-    const client =
-      options.client ??
-      new SystemClient(baseUrl ?? process.env.MCODA_API_BASE_URL ?? process.env.MCODA_SYSTEM_API_URL);
-    let repo = options.repo;
-    if (!repo) {
-      try {
-        repo = await GlobalRepository.create();
-      } catch {
-        repo = undefined;
-      }
-    }
-    return new SystemUpdateService(client, repo, { mcodaDir: options.mcodaDir });
-  }
-
-  async close(): Promise<void> {
-    if (this.repo) {
-      await this.repo.close();
-    }
-  }
-
-  private releasesPath(): string {
-    return path.join(this.mcodaDir, "releases.json");
-  }
-
-  async readState(): Promise<ReleasesState> {
-    return (await parseJson<ReleasesState>(this.releasesPath())) ?? {};
-  }
-
-  private async writeState(state: ReleasesState): Promise<void> {
-    await PathHelper.ensureDir(this.mcodaDir);
-    await fs.writeFile(this.releasesPath(), JSON.stringify(state, null, 2), "utf8");
-  }
-
-  async startRun(payload: Record<string, unknown>): Promise<string | undefined> {
-    const startedAt = nowIso();
-    const run = await this.repo?.createCommandRun({
-      commandName: "update",
-      startedAt,
-      status: "running",
-      payload,
-    });
-    return run?.id;
-  }
-
-  async finishRun(
-    id: string | undefined,
-    update: { status: GlobalCommandStatus; exitCode?: number; errorSummary?: string | null; result?: Record<string, unknown> },
-  ): Promise<void> {
-    if (!id || !this.repo) return;
-    await this.repo.completeCommandRun(id, {
-      status: update.status,
-      completedAt: nowIso(),
-      exitCode: update.exitCode ?? null,
-      errorSummary: update.errorSummary ?? null,
-      result: update.result,
-    });
-  }
-
-  async resolveChannel(preferred?: UpdateChannel): Promise<UpdateChannel> {
-    const state = await this.readState();
-    return normalizeChannel(preferred ?? state.preferences?.channel ?? "stable");
-  }
-
-  async savePreferredChannel(channel: UpdateChannel): Promise<void> {
-    const state = await this.readState();
-    await this.writeState({
-      ...state,
-      preferences: { ...(state.preferences ?? {}), channel },
-    });
-  }
-
-  async checkUpdate(channel?: UpdateChannel): Promise<UpdateCheckResult> {
-    const resolved = await this.resolveChannel(channel);
-    const info = await this.client.checkUpdate(resolved);
-    const checkedAt = nowIso();
-    const state = await this.readState();
-    await this.writeState({
-      ...state,
-      preferences: { ...(state.preferences ?? {}), channel: resolved },
-      lastCheck: {
-        ...info,
-        checkedAt,
-        channel: resolved,
-      },
-    });
-    return { info, checkedAt, channel: resolved };
-  }
-
-  async applyUpdate(channel?: UpdateChannel): Promise<ApplyUpdateResponse> {
-    const resolved = channel ? normalizeChannel(channel) : undefined;
-    return this.client.applyUpdate(resolved ? { channel: resolved } : undefined);
-  }
-
-  async recordApplyState(info: UpdateInfo, channel: UpdateChannel, targetVersion: string): Promise<void> {
-    const checkedAt = nowIso();
-    const state = await this.readState();
-    await this.writeState({
-      ...state,
-      preferences: { ...(state.preferences ?? {}), channel },
-      lastCheck: {
-        ...info,
-        currentVersion: targetVersion,
-        latestVersion: targetVersion,
-        updateAvailable: false,
-        channel,
-        checkedAt,
-      },
-    });
-  }
-
-  async runNpmInstall(targetVersion: string, options: { quiet?: boolean } = {}): Promise<{ code: number }> {
-    return new Promise((resolve, reject) => {
-      const child = spawn("npm", ["install", "-g", `mcoda@${targetVersion}`], {
-        stdio: options.quiet ? "ignore" : "inherit",
-      });
-      child.on("error", (error) => reject(error));
-      child.on("close", (code) => resolve({ code: code ?? 0 }));
-    });
-  }
-}

package/packages/core/src/services/system/__tests__/SystemUpdateService.test.ts

@@ -1,40 +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 { SystemUpdateService } from "../SystemUpdateService.js";
-
-test("SystemUpdateService persists channel preferences and update state", async () => {
-  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "mcoda-update-"));
-  const service = await SystemUpdateService.create(undefined, {
-    mcodaDir: dir,
-    client: {
-      checkUpdate: async () => ({
-        currentVersion: "0.1.2",
-        latestVersion: "0.1.2",
-        channel: "stable",
-        updateAvailable: true,
-      }),
-      applyUpdate: async () => ({ status: "started" }),
-    } as any,
-    repo: undefined,
-  });
-
-  try {
-    await service.savePreferredChannel("beta");
-    const channel = await service.resolveChannel();
-    assert.equal(channel, "beta");
-
-    const result = await service.checkUpdate("stable");
-    assert.equal(result.info.latestVersion, "0.1.2");
-
-    const statePath = path.join(dir, "releases.json");
-    const state = JSON.parse(await fs.readFile(statePath, "utf8")) as any;
-    assert.equal(state.lastCheck.channel, "stable");
-    assert.equal(state.preferences.channel, "stable");
-  } finally {
-    await service.close();
-    await fs.rm(dir, { recursive: true, force: true });
-  }
-});

package/packages/core/src/services/tasks/TaskApiResolver.ts

@@ -1,37 +0,0 @@
-export class TaskApiResolver {
-  constructor(private baseUrl?: string) {}
-
-  private getBaseUrl(): string | undefined {
-    return this.baseUrl ?? process.env.MCODA_API_BASE_URL ?? process.env.MCODA_TASKS_API_URL;
-  }
-
-  async resolveTaskId(taskKey: string, projectKey?: string): Promise<string | undefined> {
-    const base = this.getBaseUrl();
-    if (!base) return undefined;
-    try {
-      const url = new URL("/tasks", base);
-      url.searchParams.set("key", taskKey);
-      if (projectKey) {
-        url.searchParams.set("project", projectKey);
-      }
-      const resp = await fetch(url, { headers: { accept: "application/json" } });
-      if (!resp.ok) return undefined;
-      const body = await resp.json();
-      const candidates: any[] = Array.isArray(body)
-        ? body
-        : Array.isArray(body?.tasks)
-          ? body.tasks
-          : Array.isArray(body?.data)
-            ? body.data
-            : [];
-      if (!candidates.length) return undefined;
-      if (candidates.length > 1 && !projectKey) {
-        throw new Error(`Multiple tasks found with key "${taskKey}" via OpenAPI; please specify --project.`);
-      }
-      const taskId = candidates[0]?.id ?? candidates[0]?.task_id;
-      return typeof taskId === "string" ? taskId : undefined;
-    } catch {
-      return undefined;
-    }
-  }
-}