@xerg/cli 0.5.2 → 0.5.5

package/dist/index.js

@@ -122,23 +122,6 @@ import { closeSync, openSync, readSync } from "fs";
 function sha1(input) {
   return createHash("sha1").update(input).digest("hex");
 }
-function sha1File(path) {
-  const hash = createHash("sha1");
-  const fd = openSync(path, "r");
-  const buffer = Buffer.allocUnsafe(64 * 1024);
-  try {
-    let bytesRead = 0;
-    do {
-      bytesRead = readSync(fd, buffer, 0, buffer.length, null);
-      if (bytesRead > 0) {
-        hash.update(buffer.subarray(0, bytesRead));
-      }
-    } while (bytesRead > 0);
-  } finally {
-    closeSync(fd);
-  }
-  return hash.digest("hex");
-}
 
 // ../core/src/utils/time.ts
 function parseSince(value) {
@@ -736,354 +719,80 @@ async function inspectCursorUsageCsv(options) {
 }
 
 // ../core/src/db/client.ts
-import { mkdirSync } from "fs";
+import { existsSync, mkdirSync, readFileSync as readFileSync2, renameSync, writeFileSync } from "fs";
 import { dirname } from "path";
-import Database from "better-sqlite3";
-
-// ../core/src/db/schema.ts
-var SCHEMA_VERSION = 1;
-var SCHEMA_SQL = `
-CREATE TABLE IF NOT EXISTS source_files (
-  id TEXT PRIMARY KEY,
-  path TEXT NOT NULL,
-  kind TEXT NOT NULL,
-  file_hash TEXT NOT NULL,
-  mtime_ms INTEGER NOT NULL,
-  size_bytes INTEGER NOT NULL,
-  imported_at TEXT NOT NULL
-);
-
-CREATE TABLE IF NOT EXISTS runs (
-  id TEXT PRIMARY KEY,
-  source_path TEXT NOT NULL,
-  source_kind TEXT NOT NULL,
-  timestamp TEXT NOT NULL,
-  workflow TEXT NOT NULL,
-  environment TEXT NOT NULL,
-  tags_json TEXT NOT NULL,
-  total_cost_usd REAL NOT NULL,
-  total_tokens INTEGER NOT NULL,
-  observed_cost_usd REAL NOT NULL,
-  estimated_cost_usd REAL NOT NULL
-);
-
-CREATE TABLE IF NOT EXISTS calls (
-  id TEXT PRIMARY KEY,
-  run_id TEXT NOT NULL,
-  timestamp TEXT NOT NULL,
-  provider TEXT NOT NULL,
-  model TEXT NOT NULL,
-  input_tokens INTEGER NOT NULL,
-  output_tokens INTEGER NOT NULL,
-  cost_usd REAL NOT NULL,
-  cost_source TEXT NOT NULL,
-  latency_ms INTEGER,
-  tool_calls INTEGER NOT NULL,
-  retries INTEGER NOT NULL,
-  attempt INTEGER,
-  iteration INTEGER,
-  status TEXT,
-  task_class TEXT,
-  cache_hit INTEGER NOT NULL,
-  cache_cost_usd REAL,
-  metadata_json TEXT NOT NULL
-);
-
-CREATE TABLE IF NOT EXISTS findings (
-  id TEXT PRIMARY KEY,
-  audit_id TEXT NOT NULL,
-  classification TEXT NOT NULL,
-  confidence TEXT NOT NULL,
-  kind TEXT NOT NULL,
-  title TEXT NOT NULL,
-  summary TEXT NOT NULL,
-  scope TEXT NOT NULL,
-  scope_id TEXT NOT NULL,
-  cost_impact_usd REAL NOT NULL,
-  details_json TEXT NOT NULL
-);
-
-CREATE TABLE IF NOT EXISTS pricing_catalog (
-  id TEXT PRIMARY KEY,
-  provider TEXT NOT NULL,
-  model TEXT NOT NULL,
-  effective_date TEXT NOT NULL,
-  input_per_1m REAL NOT NULL,
-  output_per_1m REAL NOT NULL,
-  cached_input_per_1m REAL
-);
-
-CREATE TABLE IF NOT EXISTS audit_snapshots (
-  id TEXT PRIMARY KEY,
-  created_at TEXT NOT NULL,
-  summary_json TEXT NOT NULL
-);
-`;
-
-// ../core/src/db/client.ts
-function createDb(path) {
-  mkdirSync(dirname(path), { recursive: true });
-  const sqlite = new Database(path);
-  const currentVersion = sqlite.pragma("user_version", { simple: true });
-  if (currentVersion > SCHEMA_VERSION) {
-    sqlite.close();
-    throw new Error(
-      `Unsupported Xerg database schema version ${currentVersion}. This build supports up to ${SCHEMA_VERSION}.`
+var SNAPSHOT_STORE_VERSION = 1;
+function readStoredSnapshotRows(path) {
+  if (!existsSync(path)) {
+    return [];
+  }
+  try {
+    return normalizeStore(JSON.parse(readFileSync2(path, "utf8"))).auditSnapshots.sort(
+      (left, right) => right.createdAt.localeCompare(left.createdAt)
     );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    process.stderr.write(`Warning: skipping unreadable local snapshot store ${path}: ${message}
+`);
+    return [];
   }
-  sqlite.exec(SCHEMA_SQL);
-  if (currentVersion < SCHEMA_VERSION) {
-    sqlite.pragma(`user_version = ${SCHEMA_VERSION}`);
+}
+function writeStoredSnapshotRows(path, rows) {
+  mkdirSync(dirname(path), { recursive: true });
+  const store = {
+    version: SNAPSHOT_STORE_VERSION,
+    auditSnapshots: rows.sort((left, right) => right.createdAt.localeCompare(left.createdAt))
+  };
+  const tempPath = `${path}.tmp-${process.pid}-${Date.now()}`;
+  writeFileSync(tempPath, `${JSON.stringify(store, null, 2)}
+`, "utf8");
+  renameSync(tempPath, path);
+}
+function upsertStoredAuditSnapshot(path, row) {
+  const rows = readStoredSnapshotRows(path);
+  if (rows.some((existing) => existing.id === row.id)) {
+    return;
   }
-  return { sqlite };
+  writeStoredSnapshotRows(path, [...rows, row]);
 }
-
-// ../core/src/db/persist.ts
-function persistAudit(audit, dbPath) {
-  const { sqlite } = createDb(dbPath);
-  const importedAt = isoNow();
-  const pricingRows = audit.pricingCatalog.map((entry) => ({
-    ...entry,
-    cachedInputPer1m: entry.cachedInputPer1m ?? null
-  }));
-  const sourceFileRows = audit.summary.sourceFiles.map((file) => ({
-    id: sha1(`${file.path}:${file.mtimeMs}:${file.sizeBytes}`),
-    path: file.path,
-    kind: file.kind,
-    fileHash: sha1File(file.path),
-    mtimeMs: Math.trunc(file.mtimeMs),
-    sizeBytes: file.sizeBytes,
-    importedAt
-  }));
-  const runRows = audit.runs.map((run2) => ({
-    id: run2.id,
-    sourcePath: run2.sourcePath,
-    sourceKind: run2.sourceKind,
-    timestamp: run2.timestamp,
-    workflow: run2.workflow,
-    environment: run2.environment,
-    tagsJson: JSON.stringify(run2.tags),
-    totalCostUsd: run2.totalCostUsd,
-    totalTokens: run2.totalTokens,
-    observedCostUsd: run2.observedCostUsd,
-    estimatedCostUsd: run2.estimatedCostUsd
-  }));
-  const callRows = audit.runs.flatMap(
-    (run2) => run2.calls.map((call) => ({
-      id: call.id,
-      runId: call.runId,
-      timestamp: call.timestamp,
-      provider: call.provider,
-      model: call.model,
-      inputTokens: call.inputTokens,
-      outputTokens: call.outputTokens,
-      costUsd: call.costUsd,
-      costSource: call.costSource,
-      latencyMs: call.latencyMs,
-      toolCalls: call.toolCalls,
-      retries: call.retries,
-      attempt: call.attempt,
-      iteration: call.iteration,
-      status: call.status,
-      taskClass: call.taskClass,
-      cacheHit: call.cacheHit,
-      cacheCostUsd: call.cacheCostUsd,
-      metadataJson: JSON.stringify(call.metadata)
-    }))
-  );
-  const findingRows = audit.summary.findings.map((finding) => ({
-    id: finding.id,
-    auditId: audit.summary.auditId,
-    classification: finding.classification,
-    confidence: finding.confidence,
-    kind: finding.kind,
-    title: finding.title,
-    summary: finding.summary,
-    scope: finding.scope,
-    scopeId: finding.scopeId,
-    costImpactUsd: finding.costImpactUsd,
-    detailsJson: JSON.stringify(finding.details)
-  }));
-  const persistTransaction = sqlite.transaction(() => {
-    insertMany(
-      sqlite,
-      `
-        INSERT OR IGNORE INTO pricing_catalog (
-          id,
-          provider,
-          model,
-          effective_date,
-          input_per_1m,
-          output_per_1m,
-          cached_input_per_1m
-        ) VALUES (?, ?, ?, ?, ?, ?, ?)
-      `,
-      pricingRows.map((row) => [
-        row.id,
-        row.provider,
-        row.model,
-        row.effectiveDate,
-        row.inputPer1m,
-        row.outputPer1m,
-        row.cachedInputPer1m
-      ])
-    );
-    insertMany(
-      sqlite,
-      `
-        INSERT OR IGNORE INTO source_files (
-          id,
-          path,
-          kind,
-          file_hash,
-          mtime_ms,
-          size_bytes,
-          imported_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?)
-      `,
-      sourceFileRows.map((row) => [
-        row.id,
-        row.path,
-        row.kind,
-        row.fileHash,
-        row.mtimeMs,
-        row.sizeBytes,
-        row.importedAt
-      ])
-    );
-    insertMany(
-      sqlite,
-      `
-        INSERT OR IGNORE INTO runs (
-          id,
-          source_path,
-          source_kind,
-          timestamp,
-          workflow,
-          environment,
-          tags_json,
-          total_cost_usd,
-          total_tokens,
-          observed_cost_usd,
-          estimated_cost_usd
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `,
-      runRows.map((row) => [
-        row.id,
-        row.sourcePath,
-        row.sourceKind,
-        row.timestamp,
-        row.workflow,
-        row.environment,
-        row.tagsJson,
-        row.totalCostUsd,
-        row.totalTokens,
-        row.observedCostUsd,
-        row.estimatedCostUsd
-      ])
-    );
-    insertMany(
-      sqlite,
-      `
-        INSERT OR IGNORE INTO calls (
-          id,
-          run_id,
-          timestamp,
-          provider,
-          model,
-          input_tokens,
-          output_tokens,
-          cost_usd,
-          cost_source,
-          latency_ms,
-          tool_calls,
-          retries,
-          attempt,
-          iteration,
-          status,
-          task_class,
-          cache_hit,
-          cache_cost_usd,
-          metadata_json
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `,
-      callRows.map((row) => [
-        row.id,
-        row.runId,
-        row.timestamp,
-        row.provider,
-        row.model,
-        row.inputTokens,
-        row.outputTokens,
-        row.costUsd,
-        row.costSource,
-        row.latencyMs ?? null,
-        row.toolCalls,
-        row.retries,
-        row.attempt ?? null,
-        row.iteration ?? null,
-        row.status ?? null,
-        row.taskClass ?? null,
-        row.cacheHit ? 1 : 0,
-        row.cacheCostUsd ?? null,
-        row.metadataJson
-      ])
-    );
-    insertMany(
-      sqlite,
-      `
-        INSERT OR IGNORE INTO findings (
-          id,
-          audit_id,
-          classification,
-          confidence,
-          kind,
-          title,
-          summary,
-          scope,
-          scope_id,
-          cost_impact_usd,
-          details_json
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `,
-      findingRows.map((row) => [
-        row.id,
-        row.auditId,
-        row.classification,
-        row.confidence,
-        row.kind,
-        row.title,
-        row.summary,
-        row.scope,
-        row.scopeId,
-        row.costImpactUsd,
-        row.detailsJson
-      ])
-    );
-    sqlite.prepare(
-      `
-          INSERT OR IGNORE INTO audit_snapshots (
-            id,
-            created_at,
-            summary_json
-          ) VALUES (?, ?, ?)
-        `
-    ).run(audit.summary.auditId, audit.summary.generatedAt, JSON.stringify(audit.summary));
-  });
-  try {
-    persistTransaction();
-  } finally {
-    sqlite.close();
+function normalizeStore(input) {
+  if (!input || typeof input !== "object") {
+    throw new Error("Snapshot store is not an object.");
+  }
+  const store = input;
+  if (store.version !== SNAPSHOT_STORE_VERSION) {
+    throw new Error(`Unsupported snapshot store version ${String(store.version)}.`);
+  }
+  if (!Array.isArray(store.auditSnapshots)) {
+    throw new Error("Snapshot store auditSnapshots field is missing or invalid.");
   }
+  return {
+    version: SNAPSHOT_STORE_VERSION,
+    auditSnapshots: store.auditSnapshots.map(normalizeSnapshotRow)
+  };
 }
-function insertMany(sqlite, sql, rows) {
-  if (rows.length === 0) {
-    return;
+function normalizeSnapshotRow(input) {
+  if (!input || typeof input !== "object") {
+    throw new Error("Snapshot row is not an object.");
   }
-  const statement = sqlite.prepare(sql);
-  for (const row of rows) {
-    statement.run(...row);
+  const row = input;
+  if (typeof row.id !== "string" || typeof row.createdAt !== "string" || typeof row.summaryJson !== "string") {
+    throw new Error("Snapshot row is missing id, createdAt, or summaryJson.");
   }
+  return {
+    id: row.id,
+    createdAt: row.createdAt,
+    summaryJson: row.summaryJson
+  };
+}
+
+// ../core/src/db/persist.ts
+function persistAudit(audit, dbPath) {
+  upsertStoredAuditSnapshot(dbPath, {
+    id: audit.summary.auditId,
+    createdAt: audit.summary.generatedAt,
+    summaryJson: JSON.stringify(audit.summary)
+  });
 }
 
 // ../core/src/report/comparison.ts
@@ -1358,19 +1067,7 @@ function parseAuditSummary(row) {
   }
 }
 function listStoredAuditSummaries(dbPath) {
-  const { sqlite } = createDb(dbPath);
-  try {
-    const rows = sqlite.prepare(
-      `
-          SELECT id, summary_json AS summaryJson
-          FROM audit_snapshots
-          ORDER BY created_at DESC
-        `
-    ).all();
-    return rows.map((row) => parseAuditSummary(row)).filter((summary) => summary !== null);
-  } finally {
-    sqlite.close();
-  }
+  return readStoredSnapshotRows(dbPath).map((row) => parseAuditSummary(row)).filter((summary) => summary !== null);
 }
 function readLatestComparableAuditSummary(input) {
   return listStoredAuditSummaries(input.dbPath).find((summary) => {
@@ -2368,7 +2065,7 @@ import { homedir as homedir2 } from "os";
 import { basename as basename2, join as join3 } from "path";
 
 // ../core/src/normalize/hermes.ts
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 import { basename } from "path";
 
 // ../core/src/utils/records.ts
@@ -2454,7 +2151,7 @@ function parseJsonLine(line) {
   }
 }
 function parseJsonLines(path) {
-  const content = readFileSync2(path, "utf8");
+  const content = readFileSync3(path, "utf8");
   const lines = content.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
   const records = [];
   for (const line of lines) {
@@ -2807,7 +2504,7 @@ function getAppPaths() {
   };
 }
 function getDefaultDbPath() {
-  return join(getAppPaths().data, "xerg.db");
+  return join(getAppPaths().data, "xerg-snapshots.json");
 }
 function getDefaultOpenClawSessionsPattern() {
   return join(getUserHome(), ".openclaw", "agents", "*", "sessions", "*.jsonl");
@@ -2998,10 +2695,10 @@ async function detectOpenClawSources(options) {
 }
 
 // ../core/src/normalize/openclaw.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import { basename as basename3 } from "path";
 function parseJsonLines2(path) {
-  const content = readFileSync3(path, "utf8");
+  const content = readFileSync4(path, "utf8");
   const lines = content.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
   const records = [];
   for (const line of lines) {
@@ -4226,12 +3923,12 @@ async function pushAudit(payload, config) {
 }
 
 // src/push/config.ts
-import { readFileSync as readFileSync5 } from "fs";
+import { readFileSync as readFileSync6 } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join5 } from "path";
 
 // src/auth/credentials.ts
-import { existsSync, mkdirSync as mkdirSync3, readFileSync as readFileSync4, rmSync, writeFileSync } from "fs";
+import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync5, rmSync, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir3 } from "os";
 import { dirname as dirname2, join as join4 } from "path";
 function getCredentialsPath() {
@@ -4243,13 +3940,13 @@ function storeCredentials(token) {
   const dir = dirname2(credPath);
   mkdirSync3(dir, { recursive: true });
   const data = { token, storedAt: (/* @__PURE__ */ new Date()).toISOString() };
-  writeFileSync(credPath, JSON.stringify(data, null, 2), { mode: 384 });
+  writeFileSync2(credPath, JSON.stringify(data, null, 2), { mode: 384 });
 }
 function loadStoredCredentials() {
   const credPath = getCredentialsPath();
   try {
-    if (!existsSync(credPath)) return null;
-    const raw = readFileSync4(credPath, "utf8");
+    if (!existsSync2(credPath)) return null;
+    const raw = readFileSync5(credPath, "utf8");
     const parsed = JSON.parse(raw);
     return parsed.token || null;
   } catch {
@@ -4259,7 +3956,7 @@ function loadStoredCredentials() {
 function clearCredentials() {
   const credPath = getCredentialsPath();
   try {
-    if (!existsSync(credPath)) return false;
+    if (!existsSync2(credPath)) return false;
     rmSync(credPath);
     return true;
   } catch {
@@ -4281,7 +3978,7 @@ function loadPushConfig() {
     };
   }
   try {
-    const raw = readFileSync5(CONFIG_PATH, "utf8");
+    const raw = readFileSync6(CONFIG_PATH, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.apiKey) {
       return {
@@ -5100,13 +4797,13 @@ function formatBytes2(bytes) {
 }
 
 // src/transport/config.ts
-import { readFileSync as readFileSync6 } from "fs";
+import { readFileSync as readFileSync7 } from "fs";
 import { resolve as resolve3 } from "path";
 function loadRemoteConfig(configPath) {
   const resolved = resolve3(configPath);
   let raw;
   try {
-    raw = readFileSync6(resolved, "utf8");
+    raw = readFileSync7(resolved, "utf8");
   } catch {
     throw new Error(`Cannot read remote config at ${resolved}`);
   }
@@ -5253,11 +4950,11 @@ function resolveRemoteHost(target) {
 }
 
 // src/version.ts
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
 function getCliVersion() {
   try {
     const packageJsonPath = new URL("../package.json", import.meta.url);
-    const packageJson = JSON.parse(readFileSync7(packageJsonPath, "utf8"));
+    const packageJson = JSON.parse(readFileSync8(packageJsonPath, "utf8"));
     return packageJson.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -5793,7 +5490,8 @@ function renderMcpCredentialSourceMessage(config) {
 }
 
 // src/prompts.ts
-import { confirm, select } from "@inquirer/prompts";
+import confirm from "@inquirer/confirm";
+import select from "@inquirer/select";
 function hasPromptTty() {
   return Boolean(process.stdin.isTTY && process.stdout.isTTY);
 }
@@ -5811,7 +5509,7 @@ async function promptSelect(message, choices) {
 }
 
 // src/commands/push.ts
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync9 } from "fs";
 async function runPushCommand(options) {
   const payload = options.file ? loadPayloadFromFile(options.file) : loadLatestCachedAuditPayload();
   if (options.dryRun) {
@@ -5835,7 +5533,7 @@ async function runPushCommand(options) {
 function loadPayloadFromFile(filePath) {
   let raw;
   try {
-    raw = readFileSync8(filePath, "utf8");
+    raw = readFileSync9(filePath, "utf8");
   } catch {
     throw new Error(`Cannot read file: ${filePath}`);
   }
@@ -6206,7 +5904,7 @@ function renderRailwayDoctorReport(report) {
 }
 
 // src/commands/mcp-setup.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync6, readFileSync as readFileSync9, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync6, readFileSync as readFileSync10, writeFileSync as writeFileSync3 } from "fs";
 import { dirname as dirname3, join as join8 } from "path";
 var HOSTED_MCP_URL = "https://mcp.xerg.ai/mcp";
 var MCP_SERVER_NAME = "xerg";
@@ -6292,7 +5990,7 @@ async function runMcpSetupFlow() {
 async function handleCursorSetup(snippet, config) {
   const cursorDir = join8(process.cwd(), ".cursor");
   const cursorConfigPath = join8(cursorDir, "mcp.json");
-  if (existsSync2(cursorDir)) {
+  if (existsSync3(cursorDir)) {
     const shouldWrite = await promptConfirm(
       "Write a project-scoped Cursor MCP config to .cursor/mcp.json?",
       true
@@ -6339,9 +6037,9 @@ function tomlString(value) {
 function writeCursorConfig(filePath, config) {
   mkdirSync6(dirname3(filePath), { recursive: true });
   let parsed = {};
-  if (existsSync2(filePath)) {
+  if (existsSync3(filePath)) {
     try {
-      parsed = JSON.parse(readFileSync9(filePath, "utf8"));
+      parsed = JSON.parse(readFileSync10(filePath, "utf8"));
     } catch {
       throw new Error(`Cursor config is not valid JSON: ${filePath}`);
     }
@@ -6354,7 +6052,7 @@ function writeCursorConfig(filePath, config) {
     ...existingServers ?? {},
     xerg: buildHostedMcpConfig(config).mcpServers.xerg
   };
-  writeFileSync2(filePath, `${JSON.stringify(parsed, null, 2)}
+  writeFileSync3(filePath, `${JSON.stringify(parsed, null, 2)}
 `);
 }
 
@@ -6566,7 +6264,7 @@ Options:
   --compare                   Compare this audit to the newest compatible prior local snapshot
   --json                      Render the report as JSON
   --markdown                  Render the report as Markdown
-  --db <path>                 Custom SQLite database path
+  --db <path>                 Custom JSON snapshot path
   --no-db                     Skip local persistence
 
 Remote options (SSH, OpenClaw only):