mcoda 0.1.2 → 0.1.4

package/packages/cli/src/commands/telemetry/TelemetryCommands.ts

@@ -1,348 +0,0 @@
-import path from "node:path";
-import { JobService, TelemetryService, TokenUsageSummaryRow, TelemetryConfigState, WorkspaceResolver } from "@mcoda/core";
-
-type OutputFormat = "table" | "json";
-
-interface TokensArgs {
-  workspaceRoot?: string;
-  project?: string;
-  agent?: string;
-  command?: string;
-  job?: string;
-  since?: string;
-  until?: string;
-  groupBy: string[];
-  format: OutputFormat;
-}
-
-interface TelemetryArgs {
-  workspaceRoot?: string;
-  subcommand: "show" | "opt-out" | "opt-in";
-  format: OutputFormat;
-  strict?: boolean;
-}
-
-const tokensUsage = `mcoda tokens \\
-  [--workspace-root <PATH>] \\
-  [--project <PROJECT_KEY|ID>] \\
-  [--agent <NAME|ID>] \\
-  [--command <COMMAND_NAME>] \\
-  [--job <JOB_ID>] \\
-  [--since <ISO_TIMESTAMP|DURATION>] \\
-  [--until <ISO_TIMESTAMP>] \\
-  [--group-by <project|agent|command|day|model|job|action>] \\
-  [--format <table|json>]`;
-
-const telemetryUsage = `mcoda telemetry <show|opt-out|opt-in> \\
-  [--workspace-root <PATH>] \\
-  [--format <table|json>] \\
-  [--strict] (opt-out only)`;
-
-const normalizeGroupBy = (input?: string[]): string[] => {
-  const allowed = new Set(["project", "agent", "command", "day", "model", "job", "action"]);
-  const selected = (input ?? []).filter((dim) => allowed.has(dim));
-  if (selected.length === 0) {
-    return ["project", "command", "agent"];
-  }
-  return Array.from(new Set(selected));
-};
-
-export const parseTokensArgs = (argv: string[]): TokensArgs => {
-  const parsed: TokensArgs = {
-    groupBy: [],
-    format: "table",
-  };
-  for (let i = 0; i < argv.length; i += 1) {
-    const arg = argv[i];
-    switch (arg) {
-      case "--workspace-root":
-      case "--workspace":
-        parsed.workspaceRoot = argv[i + 1] ? path.resolve(argv[i + 1]) : undefined;
-        i += 1;
-        break;
-      case "--project":
-        parsed.project = argv[i + 1];
-        i += 1;
-        break;
-      case "--agent":
-        parsed.agent = argv[i + 1];
-        i += 1;
-        break;
-      case "--command":
-        parsed.command = argv[i + 1];
-        i += 1;
-        break;
-      case "--job":
-        parsed.job = argv[i + 1];
-        i += 1;
-        break;
-      case "--since":
-        parsed.since = argv[i + 1];
-        i += 1;
-        break;
-      case "--until":
-        parsed.until = argv[i + 1];
-        i += 1;
-        break;
-      case "--group-by":
-        parsed.groupBy = (argv[i + 1] ?? "").split(",").map((v) => v.trim()).filter(Boolean);
-        i += 1;
-        break;
-      case "--format":
-        parsed.format = argv[i + 1] === "json" ? "json" : "table";
-        i += 1;
-        break;
-      case "--help":
-      case "-h":
-        // eslint-disable-next-line no-console
-        console.log(tokensUsage);
-        process.exit(0);
-        break;
-      default:
-        if (arg.startsWith("--group-by=")) {
-          parsed.groupBy = arg
-            .split("=")[1]
-            .split(",")
-            .map((v) => v.trim())
-            .filter(Boolean);
-        } else if (arg.startsWith("--format=")) {
-          parsed.format = arg.endsWith("json") ? "json" : "table";
-        } else if (arg.startsWith("--job=")) {
-          parsed.job = arg.split("=")[1];
-        }
-        break;
-    }
-  }
-  parsed.groupBy = normalizeGroupBy(parsed.groupBy);
-  return parsed;
-};
-
-export const parseTelemetryArgs = (argv: string[]): TelemetryArgs => {
-  let subcommand: TelemetryArgs["subcommand"] = "show";
-  const parsed: TelemetryArgs = {
-    subcommand,
-    format: "table",
-  };
-  for (let i = 0; i < argv.length; i += 1) {
-    const arg = argv[i];
-    if (!arg.startsWith("--") && i === 0) {
-      subcommand = (arg as TelemetryArgs["subcommand"]) ?? "show";
-      parsed.subcommand = subcommand;
-      continue;
-    }
-    switch (arg) {
-      case "--workspace-root":
-      case "--workspace":
-        parsed.workspaceRoot = argv[i + 1] ? path.resolve(argv[i + 1]) : undefined;
-        i += 1;
-        break;
-      case "--format":
-        parsed.format = argv[i + 1] === "json" ? "json" : "table";
-        i += 1;
-        break;
-      case "--strict":
-        parsed.strict = true;
-        break;
-      case "--help":
-      case "-h":
-        // eslint-disable-next-line no-console
-        console.log(telemetryUsage);
-        process.exit(0);
-        break;
-      default:
-        if (arg.startsWith("--format=")) {
-          parsed.format = arg.endsWith("json") ? "json" : "table";
-        }
-        break;
-    }
-  }
-  return parsed;
-};
-
-const pad = (value: string, width: number): string => value.padEnd(width, " ");
-
-const formatTable = (headers: string[], rows: string[][]): string => {
-  const widths = headers.map((header, idx) => Math.max(header.length, ...rows.map((row) => (row[idx] ?? "").length)));
-  const headerLine = headers.map((h, idx) => pad(h, widths[idx])).join(" | ");
-  const sepLine = widths.map((w) => "-".repeat(w)).join("-+-");
-  const body = rows.map((row) => row.map((cell, idx) => pad(cell ?? "", widths[idx])).join(" | ")).join("\n");
-  return [headerLine, sepLine, body].filter(Boolean).join("\n");
-};
-
-const formatNumber = (value: number | null | undefined, digits = 0): string => {
-  if (value === null || value === undefined) return "-";
-  if (digits > 0) return value.toFixed(digits);
-  return `${value}`;
-};
-
-const renderTokensTable = (rows: TokenUsageSummaryRow[], groupBy: string[]): void => {
-  const dims = new Set(groupBy);
-  const headers: string[] = [];
-  const extractors: ((row: TokenUsageSummaryRow) => string)[] = [];
-
-  if (dims.has("project")) {
-    headers.push("PROJECT");
-    extractors.push((row) => row.project_id ?? "-");
-  }
-  if (dims.has("command")) {
-    headers.push("COMMAND");
-    extractors.push((row) => row.command_name ?? "-");
-  }
-  if (dims.has("agent")) {
-    headers.push("AGENT");
-    extractors.push((row) => row.agent_id ?? "-");
-  }
-  if (dims.has("model")) {
-    headers.push("MODEL");
-    extractors.push((row) => row.model_name ?? "-");
-  }
-  if (dims.has("day")) {
-    headers.push("DAY");
-    extractors.push((row) => row.day ?? "-");
-  }
-  if (dims.has("job")) {
-    headers.push("JOB");
-    extractors.push((row) => row.job_id ?? "-");
-  }
-  if (dims.has("action")) {
-    headers.push("ACTION");
-    extractors.push((row) => row.action ?? "-");
-  }
-
-  headers.push("CALLS", "TOKENS_IN", "TOKENS_OUT", "TOKENS_TOTAL", "COST");
-  extractors.push(
-    (row) => `${row.calls}`,
-    (row) => formatNumber(row.tokens_prompt),
-    (row) => formatNumber(row.tokens_completion),
-    (row) => formatNumber(row.tokens_total),
-    (row) => formatNumber(row.cost_estimate, 4),
-  );
-
-  const tableRows = rows.map((row) => extractors.map((fn) => fn(row)));
-  // eslint-disable-next-line no-console
-  console.log(formatTable(headers, tableRows));
-};
-
-const renderTelemetryConfig = (config: TelemetryConfigState): void => {
-  const rows = [
-    ["Local recording", config.localRecording ? "enabled" : "disabled"],
-    ["Remote export", config.remoteExport ? "enabled" : "disabled"],
-    ["Strict mode", config.strict ? "on" : "off"],
-    ["Config path", config.configPath],
-  ];
-  // eslint-disable-next-line no-console
-  console.log(formatTable(["SETTING", "VALUE"], rows));
-};
-
-export class TelemetryCommands {
-  static async runTokens(argv: string[]): Promise<void> {
-    const parsed = parseTokensArgs(argv);
-    const workspace = await WorkspaceResolver.resolveWorkspace({
-      cwd: process.cwd(),
-      explicitWorkspace: parsed.workspaceRoot,
-    });
-    const jobService = new JobService(workspace, undefined, { noTelemetry: true });
-    const commandRun = await jobService.startCommandRun("tokens", parsed.project);
-    const telemetry = await TelemetryService.create(workspace);
-    try {
-      const config = await telemetry.getConfig();
-      const summary = await telemetry.getSummary({
-        projectKey: parsed.project,
-        agent: parsed.agent,
-        command: parsed.command,
-        jobId: parsed.job,
-        since: parsed.since,
-        until: parsed.until,
-        groupBy: parsed.groupBy as any,
-      });
-      if (!config.localRecording && summary.length === 0) {
-        // eslint-disable-next-line no-console
-        console.log("Local token tracking is disabled; no data available.");
-        return;
-      }
-      if (summary.length === 0) {
-        // eslint-disable-next-line no-console
-        console.log("No telemetry data for the selected filters/time window.");
-        await jobService.finishCommandRun(commandRun.id, "succeeded");
-        return;
-      }
-      if (parsed.format === "json") {
-        // eslint-disable-next-line no-console
-        console.log(JSON.stringify(summary, null, 2));
-        await jobService.finishCommandRun(commandRun.id, "succeeded");
-        return;
-      }
-      renderTokensTable(summary, parsed.groupBy);
-      await jobService.finishCommandRun(commandRun.id, "succeeded");
-    } catch (error) {
-      await jobService.finishCommandRun(commandRun.id, "failed", (error as Error).message);
-      const message = (error as Error).message ?? "Unknown error";
-      if (message.includes("workspace DB") || message.includes("workspace")) {
-        // eslint-disable-next-line no-console
-        console.error("No mcoda workspace/DB found. Run mcoda init or create-tasks in this repo first.");
-      } else {
-        // eslint-disable-next-line no-console
-        console.error(`tokens failed: ${message}`);
-      }
-      process.exitCode = 1;
-    } finally {
-      await jobService.close();
-      await telemetry.close();
-    }
-  }
-
-  static async runTelemetry(argv: string[]): Promise<void> {
-    const parsed = parseTelemetryArgs(argv);
-    const workspace = await WorkspaceResolver.resolveWorkspace({
-      cwd: process.cwd(),
-      explicitWorkspace: parsed.workspaceRoot,
-    });
-    const jobService = new JobService(workspace, undefined, { noTelemetry: true });
-    const commandRun = await jobService.startCommandRun(`telemetry-${parsed.subcommand}`, undefined);
-    const telemetry = await TelemetryService.create(workspace, { allowMissingTelemetry: true });
-    try {
-      if (parsed.subcommand === "show") {
-        const config = await telemetry.getConfig();
-        if (parsed.format === "json") {
-          // eslint-disable-next-line no-console
-          console.log(JSON.stringify(config, null, 2));
-        } else {
-          renderTelemetryConfig(config);
-        }
-        await jobService.finishCommandRun(commandRun.id, "succeeded");
-        return;
-      }
-      if (parsed.subcommand === "opt-out") {
-        const config = await telemetry.optOut(parsed.strict ?? false);
-        // eslint-disable-next-line no-console
-        console.log(
-          `Telemetry opted out.${config.strict ? " Strict mode enabled; local recording disabled." : " Local recording still enabled."}`,
-        );
-        await jobService.finishCommandRun(commandRun.id, "succeeded");
-        return;
-      }
-      if (parsed.subcommand === "opt-in") {
-        const config = await telemetry.optIn();
-        // eslint-disable-next-line no-console
-        console.log(
-          `Telemetry opted in. Local recording ${config.localRecording ? "enabled" : "disabled"}, remote export ${config.remoteExport ? "enabled" : "disabled"}.`,
-        );
-        await jobService.finishCommandRun(commandRun.id, "succeeded");
-      }
-    } catch (error) {
-      await jobService.finishCommandRun(commandRun.id, "failed", (error as Error).message);
-      const message = (error as Error).message ?? "Unknown error";
-      if (message.includes("workspace DB") || message.includes("workspace")) {
-        // eslint-disable-next-line no-console
-        console.error("No mcoda workspace/DB found. Run mcoda init or create-tasks in this repo first.");
-      } else {
-        // eslint-disable-next-line no-console
-        console.error(`telemetry ${parsed.subcommand} failed: ${message}`);
-      }
-      process.exitCode = 1;
-    } finally {
-      await jobService.close();
-      await telemetry.close();
-    }
-  }
-}

package/packages/cli/src/commands/update/UpdateCommands.ts

@@ -1,301 +0,0 @@
-import { createRequire } from "node:module";
-import readline from "node:readline/promises";
-import { stdin as input, stdout as output } from "node:process";
-import { SystemUpdateService } from "@mcoda/core";
-import { ApplyUpdateResponse, UpdateChannel } from "@mcoda/shared";
-
-interface UpdateArgs {
-  checkOnly: boolean;
-  channel?: UpdateChannel;
-  version?: string;
-  force: boolean;
-  json: boolean;
-  quiet: boolean;
-  debug: boolean;
-}
-
-const usage = `mcoda update \\
-  [--check] \\
-  [--channel <stable|beta|nightly>] \\
-  [--version <SEMVER>] \\
-  [--force] \\
-  [--json] \\
-  [--quiet]`;
-
-const readCliVersion = (): string => {
-  const require = createRequire(import.meta.url);
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const pkg = require("../../package.json") as { version?: string };
-    return pkg.version ?? "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-};
-
-const parseUpdateArgs = (argv: string[]): UpdateArgs => {
-  const parsed: UpdateArgs = {
-    checkOnly: false,
-    force: false,
-    json: false,
-    quiet: false,
-    debug: false,
-  };
-  for (let i = 0; i < argv.length; i += 1) {
-    const arg = argv[i];
-    switch (arg) {
-      case "--check":
-        parsed.checkOnly = true;
-        break;
-      case "--channel":
-        parsed.channel = argv[i + 1] as UpdateChannel | undefined;
-        i += 1;
-        break;
-      case "--version":
-        parsed.version = argv[i + 1];
-        i += 1;
-        break;
-      case "--force":
-        parsed.force = true;
-        break;
-      case "--json":
-        parsed.json = true;
-        break;
-      case "--quiet":
-        parsed.quiet = true;
-        break;
-      case "--debug":
-        parsed.debug = true;
-        break;
-      case "--workspace":
-      case "--workspace-root":
-        i += 1;
-        break;
-      case "--help":
-      case "-h":
-        // eslint-disable-next-line no-console
-        console.log(usage);
-        process.exit(0);
-        break;
-      case "--no-color":
-      case "--no-telemetry":
-        // ignored global flags
-        break;
-      default:
-        if (arg.startsWith("--channel=")) {
-          parsed.channel = arg.split("=")[1] as UpdateChannel;
-        } else if (arg.startsWith("--version=")) {
-          parsed.version = arg.split("=")[1];
-        } else {
-          throw new Error(`Unknown flag: ${arg}\n\n${usage}`);
-        }
-        break;
-    }
-  }
-  return parsed;
-};
-
-const isValidVersion = (value?: string): boolean => {
-  if (!value) return true;
-  return /^\d+\.\d+\.\d+(-[\w.-]+)?$/.test(value);
-};
-
-const confirmInteractive = async (prompt: string): Promise<boolean> => {
-  const rl = readline.createInterface({ input, output });
-  const answer = await rl.question(prompt);
-  rl.close();
-  return /^y(es)?$/i.test(answer.trim());
-};
-
-export class UpdateCommands {
-  static async run(argv: string[]): Promise<void> {
-    let runId: string | undefined;
-    let service: SystemUpdateService | undefined;
-    let exitCode = 0;
-    let errorSummary: string | null = null;
-    let result: Record<string, unknown> | undefined;
-    const cliVersion = readCliVersion();
-    try {
-      const parsed = parseUpdateArgs(argv);
-      if (!isValidVersion(parsed.version)) {
-        throw new Error(`Invalid --version value (expected semver): ${parsed.version}`);
-      }
-      service = await SystemUpdateService.create();
-
-      runId = await service.startRun({
-        cliVersion,
-        channel: parsed.channel ?? "stable",
-        versionOverride: parsed.version,
-        checkOnly: parsed.checkOnly,
-        force: parsed.force,
-      });
-
-      const channel = await service.resolveChannel(parsed.channel);
-      if (parsed.channel) {
-        await service.savePreferredChannel(channel);
-      }
-
-      let check;
-      try {
-        check = await service.checkUpdate(channel);
-      } catch (error) {
-        errorSummary = error instanceof Error ? error.message : String(error);
-        exitCode = 4;
-        if (!parsed.quiet) {
-          // eslint-disable-next-line no-console
-          console.error(errorSummary);
-        }
-        return;
-      }
-
-      const targetVersion = parsed.version ?? check.info.latestVersion;
-      const npmCommand = `npm install -g mcoda@${targetVersion}`;
-      result = { check, targetVersion, npmCommand };
-
-      if (parsed.checkOnly) {
-        if (parsed.json) {
-          // eslint-disable-next-line no-console
-          console.log(JSON.stringify({ ...check.info, channel: check.channel, checkedAt: check.checkedAt }, null, 2));
-        } else if (!parsed.quiet) {
-          const summary = `Current: ${check.info.currentVersion}, Latest (channel=${check.channel}): ${check.info.latestVersion}, updateAvailable: ${check.info.updateAvailable}`;
-          // eslint-disable-next-line no-console
-          console.log(summary);
-          if (check.info.notes) {
-            // eslint-disable-next-line no-console
-            console.log(check.info.notes);
-          }
-        }
-        return;
-      }
-
-      const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
-      const requiresForce = !interactive || Boolean(process.env.CI);
-      if (requiresForce && !parsed.force) {
-        exitCode = 2;
-        errorSummary = "Non-interactive update requires --force.";
-        if (!parsed.quiet) {
-          // eslint-disable-next-line no-console
-          console.error(`${errorSummary} Planned npm command: ${npmCommand}`);
-        }
-        return;
-      }
-
-      if (interactive && !parsed.force) {
-        const proceed = await confirmInteractive(
-          `Update mcoda from ${check.info.currentVersion} -> ${targetVersion} on channel ${channel}? [y/N] `,
-        );
-        if (!proceed) {
-          exitCode = 2;
-          errorSummary = "Update cancelled by user.";
-          return;
-        }
-      }
-
-      if (!check.info.updateAvailable && !parsed.version) {
-        if (!parsed.quiet) {
-          // eslint-disable-next-line no-console
-          console.log("Already up to date.");
-        }
-        await service.recordApplyState(check.info, channel, check.info.currentVersion);
-        return;
-      }
-
-      if (!parsed.quiet) {
-        // eslint-disable-next-line no-console
-        console.log(`Applying update via API (npm command: ${npmCommand})...`);
-      }
-
-      let applyResponse: ApplyUpdateResponse | undefined;
-      let npmFallbackSucceeded = false;
-      try {
-        applyResponse = await service.applyUpdate(channel);
-        result = { ...result, applyResponse };
-      } catch (error) {
-        errorSummary = error instanceof Error ? error.message : String(error);
-        try {
-          const npmResult = await service.runNpmInstall(targetVersion, { quiet: parsed.quiet });
-          result = { ...result, npmResult };
-          if (npmResult.code !== 0) {
-            exitCode = 6;
-            errorSummary = `npm install exited with code ${npmResult.code}`;
-          } else {
-            npmFallbackSucceeded = true;
-            exitCode = 0;
-            errorSummary = null;
-          }
-        } catch (installError) {
-          exitCode = 6;
-          errorSummary = installError instanceof Error ? installError.message : String(installError);
-        }
-      }
-
-      if (applyResponse) {
-        if (applyResponse.status === "already_up_to_date") {
-          if (!parsed.quiet) {
-            // eslint-disable-next-line no-console
-            console.log("Already up to date.");
-          }
-          exitCode = 0;
-        } else if (applyResponse.status === "started") {
-          if (!parsed.quiet) {
-            // eslint-disable-next-line no-console
-            console.log(`Update started. Logs: ${applyResponse.logFile ?? "n/a"}`);
-          }
-        } else if (applyResponse.status === "completed") {
-          if (!parsed.quiet) {
-            // eslint-disable-next-line no-console
-            console.log(`Update completed. Logs: ${applyResponse.logFile ?? "n/a"}`);
-          }
-        }
-        await service.recordApplyState(check.info, channel, targetVersion);
-        if (parsed.json) {
-          // eslint-disable-next-line no-console
-          console.log(
-            JSON.stringify(
-              {
-                status: applyResponse.status,
-                logFile: applyResponse.logFile,
-                targetVersion,
-                channel,
-                npmCommand,
-              },
-              null,
-              2,
-            ),
-          );
-        }
-      } else if (npmFallbackSucceeded) {
-        // npm fallback succeeded
-        await service.recordApplyState(check.info, channel, targetVersion);
-        if (parsed.json) {
-          // eslint-disable-next-line no-console
-          console.log(JSON.stringify({ status: "completed", targetVersion, channel, npmCommand }, null, 2));
-        }
-      } else if (exitCode === 4 && !parsed.quiet) {
-        // eslint-disable-next-line no-console
-        console.error(`Update apply failed; run manually: ${npmCommand}`);
-      }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      // eslint-disable-next-line no-console
-      console.error(message);
-      exitCode = exitCode || 1;
-      errorSummary = message;
-    } finally {
-      if (service && runId) {
-        await service.finishRun(runId, {
-          status: exitCode === 0 ? "succeeded" : "failed",
-          exitCode,
-          errorSummary,
-          result,
-        });
-      }
-      if (service) {
-        await service.close();
-      }
-      if (exitCode) {
-        process.exitCode = exitCode;
-      }
-    }
-  }
-}