codex-copilot-dx 0.6.6 → 0.6.8

package/src/pm-studio-status.mjs

@@ -18,6 +18,12 @@ import {
 import { readAdapterStatus } from "./cli-status.mjs";
 import { checkRunningAdapter } from "./running-adapter.mjs";
 import { status } from "./status.mjs";
+import {
+  cliOutputFormat,
+  cliOutputWidth,
+  formatResponsiveCliTable,
+  terminalCell,
+} from "./cli-table.mjs";
 
 const PM_RELAY_HOST = "127.0.0.1";
 const PM_RELAY_PORT = 2026;
@@ -166,54 +172,106 @@ export async function inspectPmStudioStatus({
   return { ok: operational, appPath, app, claude, adapter, runtime };
 }
 
-function appStatusLine(result, commandName) {
+function appStatusItem(result, commandName) {
   const { app } = result;
   const version = app.metadata ? `${app.metadata.version} build ${app.metadata.build}` : "";
   if (app.state === "patched" && app.patchRecord?.valid === true) {
-    return status("ok", `PM Studio ${version} is patched and verified against its installed patch record`);
+    return { kind: "ok", component: "App patch", detail: `${version}; patched and verified`, message: `PM Studio ${version} is patched and verified against its installed patch record` };
   }
   if (app.state === "patched") {
     const reason = app.patchRecord?.reason || "installed patch record is missing";
-    return status("err", `PM Studio ${version} matches the patch recipe, but its installed patch record is not verified: ${reason}`);
+    return { kind: "err", component: "App patch", detail: `${version}; patch record not verified`, message: `PM Studio ${version} matches the patch recipe, but its installed patch record is not verified: ${reason}` };
   }
-  if (app.state === "clean") return status("warn", `PM Studio ${version} is supported but not patched; run ${commandName} pms setup`);
-  if (app.state === "unsupported") return status("err", `PM Studio ${version} has no exact patch recipe; no files will be changed`);
+  if (app.state === "clean") return { kind: "warn", component: "App patch", detail: `${version}; supported, not patched`, message: `PM Studio ${version} is supported but not patched; run ${commandName} pms setup` };
+  if (app.state === "unsupported") return { kind: "err", component: "App patch", detail: `${version}; unsupported version`, message: `PM Studio ${version} has no exact patch recipe; no files will be changed` };
   if (app.state === "drift" && app.patchRecipeMatched) {
-    return status("err", `PM Studio ${version} matches the patch recipe, but its installed patch record is not verified: ${app.issues.join("; ")}`);
+    return { kind: "err", component: "App patch", detail: `${version}; patch record drift`, message: `PM Studio ${version} matches the patch recipe, but its installed patch record is not verified: ${app.issues.join("; ")}` };
   }
-  if (app.state === "drift") return status("err", `PM Studio ${version} does not match the clean or patched recipe: ${app.issues.join("; ")}`);
-  if (app.state === "not_installed") return status("warn", `PM Studio is not installed at ${result.appPath}`);
-  return status("err", `PM Studio could not be inspected: ${app.issues.join("; ")}`);
+  if (app.state === "drift") return { kind: "err", component: "App patch", detail: `${version}; integrity drift`, message: `PM Studio ${version} does not match the clean or patched recipe: ${app.issues.join("; ")}` };
+  if (app.state === "not_installed") return { kind: "warn", component: "App patch", detail: "not installed", message: `PM Studio is not installed at ${result.appPath}` };
+  return { kind: "err", component: "App patch", detail: "inspection failed", message: `PM Studio could not be inspected: ${app.issues.join("; ")}` };
 }
 
-export function formatPmStudioStatus(result, { commandName = "ccdx" } = {}) {
-  const lines = [
-    `${commandName} pms status`,
-    appStatusLine(result, commandName),
-  ];
+function pmStudioStatusItems(result, commandName) {
+  const items = [appStatusItem(result, commandName)];
   if (result.claude.valid) {
     const account = result.claude.login ? ` for ${result.claude.login}` : "";
-    lines.push(status("ok", `Isolated Claude profile is valid${account}`));
+    const detail = result.claude.login ? `${result.claude.login}; isolated profile valid` : "isolated profile valid";
+    items.push({ kind: "ok", component: "Claude profile", detail, message: `Isolated Claude profile is valid${account}` });
   } else {
     const reason = result.claude.configured && result.claude.reason ? ` (${result.claude.reason})` : "";
-    lines.push(status("err", `Isolated Claude profile is not ready${reason}; run ${PM_STUDIO_CLAUDE_AUTH_COMMAND}`));
+    items.push({ kind: "err", component: "Claude profile", detail: "not ready", message: `Isolated Claude profile is not ready${reason}; run ${PM_STUDIO_CLAUDE_AUTH_COMMAND}` });
   }
   if (result.adapter?.ok && result.runtime?.ok) {
-    lines.push(status("ok", `PM relay and isolated Claude routing are verified at ${result.adapter.baseUrl}`));
+    items.push({ kind: "ok", component: "PM relay", detail: `verified at ${result.adapter.baseUrl}`, message: `PM relay and isolated Claude routing are verified at ${result.adapter.baseUrl}` });
   } else if (result.adapter?.ok) {
     const reason = result.runtime?.issues?.join("; ") || "runtime status is unavailable";
-    lines.push(status("err", `The adapter is running at ${result.adapter.baseUrl}, but PM relay routing is not ready: ${reason}; stop it and run ${commandName} start`));
+    items.push({ kind: "err", component: "PM relay", detail: "running but routing not ready", message: `The adapter is running at ${result.adapter.baseUrl}, but PM relay routing is not ready: ${reason}; stop it and run ${commandName} start` });
   } else if (result.adapter?.incompatible) {
-    lines.push(status("err", `The adapter at ${result.adapter.baseUrl} is incompatible; stop it and run ${commandName} start`));
+    items.push({ kind: "err", component: "PM relay", detail: `incompatible at ${result.adapter.baseUrl}`, message: `The adapter at ${result.adapter.baseUrl} is incompatible; stop it and run ${commandName} start` });
   } else {
-    lines.push(status("warn", `PM relay is not running at http://${PM_RELAY_HOST}:${PM_RELAY_PORT}; run ${commandName} start`));
+    items.push({ kind: "warn", component: "PM relay", detail: `not running at ${PM_RELAY_HOST}:${PM_RELAY_PORT}`, message: `PM relay is not running at http://${PM_RELAY_HOST}:${PM_RELAY_PORT}; run ${commandName} start` });
   }
   if (result.runtime?.ok) {
-    lines.push(status("info", "Routing: PM GPT uses the PM Studio bearer; eligible Claude chat uses the isolated Claude profile"));
+    items.push({ kind: "info", component: "Routing", detail: "GPT -> PM bearer; Claude -> isolated profile", message: "Routing: PM GPT uses the PM Studio bearer; eligible Claude chat uses the isolated Claude profile" });
   } else {
-    lines.push(status("info", "Expected routing: PM GPT uses the PM Studio bearer; eligible Claude chat uses the isolated Claude profile"));
+    items.push({ kind: "info", component: "Routing", detail: "expected: GPT -> PM bearer; Claude -> isolated profile", message: "Expected routing: PM GPT uses the PM Studio bearer; eligible Claude chat uses the isolated Claude profile" });
+  }
+  return items;
+}
+
+function formatPmStudioStatusPlain(result, commandName, { sanitize = false } = {}) {
+  const lines = [
+    `${commandName} pms status`,
+    ...pmStudioStatusItems(result, commandName).map((item) => status(item.kind, item.message)),
+  ];
+  return (sanitize ? lines.map((line) => terminalCell(line, { fallback: "" })) : lines).join("\n");
+}
+
+function tableState(kind) {
+  return `[${String(kind).toUpperCase()}]`;
+}
+
+function formatPmStudioStatusTable(result, { commandName, output }) {
+  const items = pmStudioStatusItems(result, commandName);
+  const rows = items.map((item) => ({
+    component: item.component,
+    state: tableState(item.kind),
+    detail: item.detail,
+  }));
+  const table = formatResponsiveCliTable({
+    columns: [
+      { key: "component", label: "COMPONENT" },
+      { key: "state", label: "STATE" },
+      { key: "detail", label: "DETAIL" },
+    ],
+    compactColumns: [
+      { key: "component", label: "COMPONENT" },
+      { key: "state", label: "STATE" },
+    ],
+    rows,
+    width: cliOutputWidth(output),
+  });
+  const lines = [`${commandName} pms status`, table.output];
+  const details = table.compact ? items : items.filter((item) => item.kind === "warn" || item.kind === "err");
+  if (details.length) {
+    lines.push("", "Details:", ...details.map((item) => terminalCell(status(item.kind, item.message), { fallback: "" })));
+  }
+  return { output: lines.join("\n"), overflow: table.overflow };
+}
+
+export function formatPmStudioStatus(result, {
+  commandName = "ccdx",
+  format = "plain",
+  output = process.stdout,
+} = {}) {
+  if (cliOutputFormat(format, output) === "plain") {
+    return formatPmStudioStatusPlain(result, commandName);
   }
-  return lines.join("\n");
+  const table = formatPmStudioStatusTable(result, { commandName, output });
+  return format === "auto" && table.overflow
+    ? formatPmStudioStatusPlain(result, commandName, { sanitize: true })
+    : table.output;
 }
 
 export async function runPmStudioStatus(options = {}) {

package/src/usage.mjs

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import readline from "node:readline";
+import { cliOutputFormat, cliOutputWidth, formatResponsiveCliTable, terminalCell } from "./cli-table.mjs";
 import { parseByteLimit, rotateFileIfNeededSync, rotatedFilePath } from "./file-rotation.mjs";
 
 const DEFAULT_USAGE_PATH = path.join(os.homedir(), ".local", "share", "codex-copilot-dx", "usage.jsonl");
@@ -219,17 +220,111 @@ function fmt(n) {
   return Number.isFinite(n) ? n.toLocaleString("en-US") : "0";
 }
 
-export async function printUsageSummary() {
-  const summary = await summarizeUsageLogs();
-  console.log(`Usage log: ${usageLogPath()}`);
+function tableNumber(n) {
+  return Number.isFinite(n) ? n.toLocaleString("en-US") : undefined;
+}
+
+function cacheReadTokens(usage = {}) {
+  const values = [usage.cache_read_input_tokens, usage.cached_input_tokens]
+    .filter((value) => Number.isFinite(value));
+  const value = values.length > 0 ? values.reduce((total, current) => total + current, 0) : undefined;
+  return Number.isFinite(value) ? value : undefined;
+}
+
+function formatPlainUsageSummary(summary, filePath, { sanitize = false } = {}) {
+  const lines = [`Usage log: ${filePath}`];
   if (summary.requests === 0) {
-    console.log("No usage records yet.");
-    return;
+    lines.push("No usage records yet.");
+    return (sanitize ? lines.map((line) => terminalCell(line, { fallback: "" })) : lines).join("\n");
   }
-  console.log(`Requests: ${fmt(summary.requests)}`);
-  console.log(`Tokens: input=${fmt(summary.totals.input_tokens)} cache_read=${fmt(summary.totals.cache_read_input_tokens || summary.totals.cached_input_tokens)} output=${fmt(summary.totals.output_tokens)} total=${fmt(summary.totals.total_tokens)}`);
-  console.log("\nBy model:");
+  lines.push(
+    `Requests: ${fmt(summary.requests)}`,
+    `Tokens: input=${fmt(summary.totals.input_tokens)} cache_read=${fmt(cacheReadTokens(summary.totals))} output=${fmt(summary.totals.output_tokens)} total=${fmt(summary.totals.total_tokens)}`,
+    "",
+    "By model:",
+  );
   for (const [model, row] of Object.entries(summary.byModel)) {
-    console.log(`  ${model}: requests=${fmt(row.requests)} input=${fmt(row.input_tokens)} cache_read=${fmt(row.cache_read_input_tokens || row.cached_input_tokens)} output=${fmt(row.output_tokens)} total=${fmt(row.total_tokens)}`);
+    lines.push(`  ${model}: requests=${fmt(row.requests)} input=${fmt(row.input_tokens)} cache_read=${fmt(cacheReadTokens(row))} output=${fmt(row.output_tokens)} total=${fmt(row.total_tokens)}`);
+  }
+  return (sanitize ? lines.map((line) => terminalCell(line, { fallback: "" })) : lines).join("\n");
+}
+
+function compareModelUsage(left, right) {
+  const leftTotal = Number.isFinite(left.row.total_tokens) ? left.row.total_tokens : -Infinity;
+  const rightTotal = Number.isFinite(right.row.total_tokens) ? right.row.total_tokens : -Infinity;
+  if (leftTotal !== rightTotal) return rightTotal - leftTotal;
+  return left.model < right.model ? -1 : left.model > right.model ? 1 : 0;
+}
+
+function usageTableRow(model, usage) {
+  return {
+    model,
+    records: tableNumber(usage.requests),
+    input: tableNumber(usage.input_tokens),
+    cacheRead: tableNumber(cacheReadTokens(usage)),
+    output: tableNumber(usage.output_tokens),
+    total: tableNumber(usage.total_tokens),
+  };
+}
+
+function usageDetailLine(model, usage) {
+  return `${terminalCell(model)}: input=${fmt(usage.input_tokens)} cache_read=${fmt(cacheReadTokens(usage))} output=${fmt(usage.output_tokens)}`;
+}
+
+function formatTableUsageSummary(summary, filePath, output) {
+  const safePath = terminalCell(filePath, { fallback: "" });
+  if (summary.requests === 0) return { output: `Usage log: ${safePath}\nNo usage records yet.`, overflow: false };
+  const columns = [
+    { key: "model", label: "MODEL" },
+    { key: "records", label: "RECORDS", align: "right" },
+    { key: "input", label: "INPUT", align: "right" },
+    { key: "cacheRead", label: "CACHE READ", align: "right" },
+    { key: "output", label: "OUTPUT", align: "right" },
+    { key: "total", label: "TOTAL", align: "right" },
+  ];
+  const compactColumns = [columns[0], columns[1], columns[5]];
+  const modelUsage = Object.entries(summary.byModel)
+    .map(([model, row]) => ({ model, row }))
+    .sort(compareModelUsage);
+  const totalUsage = { requests: summary.requests, ...summary.totals };
+  const rows = [usageTableRow("TOTAL", totalUsage), ...modelUsage.map(({ model, row }) => usageTableRow(model, row))];
+  const table = formatResponsiveCliTable({
+    columns,
+    compactColumns,
+    rows,
+    width: cliOutputWidth(output),
+    gap: 1,
+  });
+  const lines = [`Usage log: ${safePath}`, "", table.output];
+  if (table.compact) {
+    lines.push(
+      "",
+      "Details:",
+      usageDetailLine("TOTAL", totalUsage),
+      ...modelUsage.map(({ model, row }) => usageDetailLine(model, row)),
+    );
   }
+  return { output: lines.join("\n"), overflow: table.overflow };
+}
+
+export function formatUsageSummary(summary, {
+  filePath = usageLogPath(),
+  format = "auto",
+  output = process.stdout,
+} = {}) {
+  if (cliOutputFormat(format, output) === "plain") return formatPlainUsageSummary(summary, filePath);
+  const table = formatTableUsageSummary(summary, filePath, output);
+  return format === "auto" && table.overflow
+    ? formatPlainUsageSummary(summary, filePath, { sanitize: true })
+    : table.output;
+}
+
+export async function printUsageSummary({
+  filePath = usageLogPath(),
+  format = "auto",
+  output = process.stdout,
+  log = console.log,
+} = {}) {
+  const summary = await summarizeUsageLogs(filePath);
+  log(formatUsageSummary(summary, { filePath, format, output }));
 }