chainlesschain 0.162.30 → 0.162.31

package/src/commands/checkpoint.js

@@ -0,0 +1,239 @@
+/**
+ * cc checkpoint — manual file-state snapshot / rewind (Claude-Code rewind parity).
+ *
+ *   cc checkpoint create <paths...> [--label <l>]   snapshot files/dirs
+ *   cc checkpoint list                              list checkpoints
+ *   cc checkpoint show <id> [--diff]                manifest, or diff vs current
+ *   cc checkpoint restore <id> [--dry-run] [--force]  roll files back
+ *   cc checkpoint delete <id> [--force]             remove a checkpoint
+ *
+ * Restore takes an automatic safety snapshot of the current contents first, so
+ * a rewind is itself reversible. Distinct from `cc workflow checkpoint`
+ * (workflow execution state, not files).
+ */
+
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+
+export function registerCheckpointCommand(program) {
+  const cp = program
+    .command("checkpoint")
+    .description("Snapshot / rewind file state (manual checkpoints)");
+
+  cp.command("create <paths...>")
+    .description("Snapshot the given files/directories")
+    .option("--label <label>", "Human label for this checkpoint")
+    .option("--json", "Output as JSON")
+    .action(async (paths, options) => {
+      try {
+        const { createCheckpoint } = await import("../lib/file-checkpoint.js");
+        const m = createCheckpoint(paths, { label: options.label });
+        if (options.json) {
+          console.log(JSON.stringify(m, null, 2));
+          return;
+        }
+        logger.log(
+          chalk.green(`✓ checkpoint ${chalk.bold(m.id)}`) +
+            (m.label ? chalk.gray(`  "${m.label}"`) : ""),
+        );
+        logger.log(chalk.gray(`  ${m.fileCount} file(s) snapshotted`));
+      } catch (err) {
+        logger.error(chalk.red(`checkpoint create failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  cp.command("list")
+    .alias("ls")
+    .description("List checkpoints (newest first)")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const { listCheckpoints } = await import("../lib/file-checkpoint.js");
+        const all = listCheckpoints();
+        if (options.json) {
+          console.log(JSON.stringify(all, null, 2));
+          return;
+        }
+        if (all.length === 0) {
+          logger.log(
+            chalk.gray(
+              "No checkpoints. Create one: cc checkpoint create <paths...>",
+            ),
+          );
+          return;
+        }
+        for (const c of all) {
+          logger.log(
+            `${chalk.cyan(c.id.padEnd(22))} ${chalk.gray(c.createdAt)}  ` +
+              `${String(c.fileCount).padStart(4)} files` +
+              (c.label ? chalk.gray(`  "${c.label}"`) : ""),
+          );
+        }
+      } catch (err) {
+        logger.error(chalk.red(`checkpoint list failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  cp.command("show <id>")
+    .description("Show a checkpoint's files, or its diff vs current state")
+    .option("--diff", "Compare snapshot against current on-disk files")
+    .option("--json", "Output as JSON")
+    .action(async (id, options) => {
+      try {
+        const { getCheckpoint, diffCheckpoint } =
+          await import("../lib/file-checkpoint.js");
+        if (options.diff) {
+          const d = diffCheckpoint(id);
+          if (options.json) {
+            console.log(JSON.stringify(d, null, 2));
+            return;
+          }
+          logger.log(chalk.bold(`Diff vs current — ${id}`));
+          logger.log(`  ${chalk.yellow("modified")}: ${d.modified.length}`);
+          d.modified.forEach((f) => logger.log(chalk.yellow(`    M ${f}`)));
+          logger.log(`  ${chalk.red("deleted")}:  ${d.deleted.length}`);
+          d.deleted.forEach((f) => logger.log(chalk.red(`    D ${f}`)));
+          logger.log(chalk.gray(`  unchanged: ${d.unchanged.length}`));
+          return;
+        }
+        const m = getCheckpoint(id);
+        if (!m) {
+          logger.error(chalk.red(`no such checkpoint: ${id}`));
+          process.exitCode = 1;
+          return;
+        }
+        if (options.json) {
+          console.log(JSON.stringify(m, null, 2));
+          return;
+        }
+        logger.log(chalk.bold(`Checkpoint ${m.id}`));
+        if (m.label) logger.log(chalk.gray(`  label: ${m.label}`));
+        logger.log(
+          chalk.gray(`  created: ${m.createdAt}  files: ${m.fileCount}`),
+        );
+        for (const f of m.files) {
+          logger.log(`  ${chalk.gray(String(f.bytes).padStart(8))}  ${f.rel}`);
+        }
+      } catch (err) {
+        logger.error(chalk.red(`checkpoint show failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  cp.command("restore <id>")
+    .description(
+      "Restore files from a checkpoint (auto-snapshots current state first)",
+    )
+    .option("--dry-run", "Show what would change without writing")
+    .option("--force", "Restore without the interactive confirm prompt")
+    .option("--json", "Output as JSON")
+    .action(async (id, options) => {
+      try {
+        const { restoreCheckpoint, diffCheckpoint } =
+          await import("../lib/file-checkpoint.js");
+
+        if (options.dryRun) {
+          const r = restoreCheckpoint(id, { dryRun: true });
+          if (options.json) {
+            console.log(JSON.stringify(r, null, 2));
+            return;
+          }
+          logger.log(chalk.bold(`Dry-run restore — ${id}`));
+          logger.log(`  would restore: ${r.restored.length} file(s)`);
+          r.restored.forEach((f) => logger.log(chalk.yellow(`    ~ ${f}`)));
+          logger.log(chalk.gray(`  already matching: ${r.unchanged.length}`));
+          if (r.missingBlob.length) {
+            logger.log(
+              chalk.red(`  missing blobs: ${r.missingBlob.join(", ")}`),
+            );
+          }
+          return;
+        }
+
+        // Destructive: overwrites current files. Require --force when not a TTY;
+        // prompt when interactive.
+        if (!options.force) {
+          const d = diffCheckpoint(id);
+          const willChange = d.modified.length + d.deleted.length;
+          if (process.stdin.isTTY) {
+            const { confirm } = await import("@inquirer/prompts");
+            const ok = await confirm({
+              message: `Restore ${id}? ${willChange} file(s) will be overwritten (a safety checkpoint is taken first).`,
+              default: false,
+            }).catch(() => false);
+            if (!ok) {
+              logger.log(chalk.gray("Aborted."));
+              return;
+            }
+          } else {
+            logger.error(
+              chalk.red(
+                `Refusing to restore without --force (non-interactive). ${willChange} file(s) would change. Re-run with --dry-run to preview or --force to proceed.`,
+              ),
+            );
+            process.exitCode = 1;
+            return;
+          }
+        }
+
+        const r = restoreCheckpoint(id);
+        if (options.json) {
+          console.log(JSON.stringify(r, null, 2));
+          return;
+        }
+        logger.log(
+          chalk.green(`✓ restored ${r.restored.length} file(s) from ${id}`),
+        );
+        r.restored.forEach((f) => logger.log(chalk.gray(`    ~ ${f}`)));
+        if (r.safetyId) {
+          logger.log(
+            chalk.gray(
+              `  safety checkpoint of prior state: ${r.safetyId} (undo with: cc checkpoint restore ${r.safetyId})`,
+            ),
+          );
+        }
+        if (r.missingBlob.length) {
+          logger.log(
+            chalk.red(`  missing blobs (skipped): ${r.missingBlob.join(", ")}`),
+          );
+        }
+      } catch (err) {
+        logger.error(chalk.red(`checkpoint restore failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  cp.command("delete <id>")
+    .alias("rm")
+    .description("Delete a checkpoint")
+    .option("--force", "Skip confirmation")
+    .action(async (id, options) => {
+      try {
+        const { deleteCheckpoint, getCheckpoint } =
+          await import("../lib/file-checkpoint.js");
+        if (!getCheckpoint(id)) {
+          logger.error(chalk.red(`no such checkpoint: ${id}`));
+          process.exitCode = 1;
+          return;
+        }
+        if (!options.force && process.stdin.isTTY) {
+          const { confirm } = await import("@inquirer/prompts");
+          const ok = await confirm({
+            message: `Delete checkpoint ${id}?`,
+            default: false,
+          }).catch(() => false);
+          if (!ok) {
+            logger.log(chalk.gray("Aborted."));
+            return;
+          }
+        }
+        deleteCheckpoint(id);
+        logger.log(chalk.green(`✓ deleted ${id}`));
+      } catch (err) {
+        logger.error(chalk.red(`checkpoint delete failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+}

package/src/commands/cost.js

@@ -0,0 +1,114 @@
+/**
+ * cc cost [sessionId] — estimated $ spend from recorded token usage.
+ *
+ * Builds on `cc session usage` (token aggregation) by layering the
+ * llm-pricing rate table on top. Reads the same JSONL token_usage events,
+ * so no new data is collected — this is purely a reporting view.
+ *
+ *   cc cost                 # global rollup across all sessions
+ *   cc cost <sessionId>     # one session
+ *   cc cost --json          # machine-readable
+ */
+
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+
+function fmtUsd(n) {
+  const v = Number(n) || 0;
+  // Sub-cent costs are common with cheap models — show enough precision.
+  if (v === 0) return "$0.00";
+  if (v < 0.01) return `$${v.toFixed(6)}`;
+  return `$${v.toFixed(4)}`;
+}
+
+export function registerCostCommand(program) {
+  program
+    .command("cost")
+    .description(
+      "Estimated $ cost from recorded token usage (per-session or global)",
+    )
+    .argument("[id]", "Session ID (omit for global rollup)")
+    .option("--json", "Output as JSON")
+    .option("--limit <n>", "Max sessions for global rollup", "1000")
+    .action(async (id, options) => {
+      try {
+        const { sessionUsage, allSessionsUsage } =
+          await import("../lib/session-usage.js");
+        const { priceRollup, mergePricing } =
+          await import("../lib/llm-pricing.js");
+        const { loadConfig } = await import("../lib/config-manager.js");
+
+        // User price overrides live under config.llm.pricing — no need to edit
+        // source to correct/add a model rate.
+        const config = loadConfig();
+        const overrides = config?.llm?.pricing;
+        const table = mergePricing(overrides);
+
+        const raw = id
+          ? sessionUsage(id)
+          : allSessionsUsage({ limit: parseInt(options.limit, 10) || 1000 });
+        const result = priceRollup(raw, { table });
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+          return;
+        }
+
+        const header = id
+          ? `Cost — session ${chalk.gray(id.slice(0, 16))}`
+          : "Cost — global";
+        logger.log(chalk.bold(header));
+        logger.log(
+          `  total: ${chalk.green(fmtUsd(result.cost.totalCost))} USD  ` +
+            `(${result.total.totalTokens.toLocaleString()} tokens, ${result.total.calls} calls)`,
+        );
+
+        if (result.byModel.length === 0) {
+          logger.log(chalk.gray("  (no token_usage events recorded)"));
+          return;
+        }
+
+        for (const row of result.byModel) {
+          const provider = (row.provider || "?").padEnd(10);
+          const model = (row.model || "?").padEnd(24);
+          const tokens = `in=${row.inputTokens} out=${row.outputTokens}`;
+          if (row.free) {
+            logger.log(
+              `  ${chalk.gray(provider)} ${chalk.white(model)} ${chalk.gray("free (local)")}  ${chalk.gray(tokens)}`,
+            );
+          } else if (row.matched) {
+            logger.log(
+              `  ${chalk.gray(provider)} ${chalk.white(model)} ${chalk.green(fmtUsd(row.cost).padStart(12))}  ${chalk.gray(tokens)}`,
+            );
+          } else {
+            logger.log(
+              `  ${chalk.gray(provider)} ${chalk.white(model)} ${chalk.yellow("unpriced".padStart(12))}  ${chalk.gray(tokens)}`,
+            );
+          }
+        }
+
+        if (result.unpriced.length > 0) {
+          logger.log(
+            chalk.yellow(
+              `  note: ${result.unpriced.length} model(s) have no rate — tokens excluded from total. Add rates via config: llm.pricing.`,
+            ),
+          );
+        }
+        if (overrides && typeof overrides === "object") {
+          logger.log(
+            chalk.gray(
+              `  (price overrides active from config.llm.pricing: ${Object.keys(overrides).join(", ")})`,
+            ),
+          );
+        }
+        logger.log(
+          chalk.gray(
+            "  prices are estimates of public list rates (USD/1M tokens).",
+          ),
+        );
+      } catch (err) {
+        logger.error(chalk.red(`cost failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+}

package/src/commands/session.js

@@ -209,8 +209,13 @@ export function registerSessionCommand(program) {
   // session resume
   session
     .command("resume")
-    .description("Resume a session in chat mode")
-    .argument("<id>", "Session ID (or prefix)")
+    .description(
+      "Resume a session in chat mode (id optional — interactive picker, or most recent when piped)",
+    )
+    .argument(
+      "[id]",
+      "Session ID (or prefix); omit to pick / resume the most recent",
+    )
     .option("--model <model>", "Model name")
     .option("--provider <provider>", "LLM provider")
     .action(async (id, options) => {
@@ -218,6 +223,21 @@ export function registerSessionCommand(program) {
         const ctx = await bootstrap({ verbose: program.opts().verbose });
         let sess = null;
 
+        // No id → shared interactive picker (TTY + >1) or most-recent fallback
+        // (single / non-TTY / Ctrl-C). Same helper as `cc agent --resume`.
+        if (!id) {
+          const { pickRecentSession } =
+            await import("../lib/session-picker.js");
+          const picked = await pickRecentSession(ctx);
+          if (!picked.id) {
+            logger.error(
+              "No saved sessions to resume. Use 'chat' or 'agent' to create one.",
+            );
+            process.exit(1);
+          }
+          id = picked.id;
+        }
+
         // Try JSONL first
         if (feature("JSONL_SESSION") && sessionExists(id)) {
           const events = readEvents(id);

package/src/index.js

@@ -56,6 +56,8 @@ import { registerMemoryCommand } from "./commands/memory.js";
 import { registerPermMemCommand } from "./commands/permmem.js";
 import { registerRCacheCommand } from "./commands/rcache.js";
 import { registerSessionCommand } from "./commands/session.js";
+import { registerCostCommand } from "./commands/cost.js";
+import { registerCheckpointCommand } from "./commands/checkpoint.js";
 import { registerConsolCommand } from "./commands/consol.js";
 import { registerImportCommand } from "./commands/import.js";
 import { registerExportCommand } from "./commands/export.js";
@@ -448,6 +450,8 @@ export function createProgram(opts = {}) {
   registerPermMemCommand(program);
   registerRCacheCommand(program);
   registerSessionCommand(program);
+  registerCostCommand(program);
+  registerCheckpointCommand(program);
   registerConsolCommand(program);
 
   // Phase 2: Knowledge & content management