@cleocode/cleo 2026.10.3 → 2026.10.4

package/dist/cli/checkpoint-37HMMKD7.js

@@ -0,0 +1,128 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliError,
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/checkpoint.ts
+import { ExitCode } from "@cleocode/contracts";
+import {
+  CleoError,
+  formatError,
+  getCleoDir,
+  gitCheckpoint,
+  gitCheckpointStatus,
+  isCleoGitInitialized
+} from "@cleocode/core/internal";
+function isGitRepo() {
+  try {
+    const cleoDir = getCleoDir();
+    return isCleoGitInitialized(cleoDir);
+  } catch {
+    return false;
+  }
+}
+var checkpointCommand = defineCommand({
+  meta: {
+    name: "checkpoint",
+    description: "Git checkpoint for CLEO state files (commits to isolated .cleo/.git repo)"
+  },
+  args: {
+    status: {
+      type: "boolean",
+      description: "Show configuration and last checkpoint time"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Show what files would be committed"
+    }
+  },
+  async run({ args }) {
+    try {
+      if (!isGitRepo()) {
+        throw new CleoError(ExitCode.GENERAL_ERROR, ".cleo/.git not initialized. Run: cleo init");
+      }
+      if (args.status) {
+        const status = await gitCheckpointStatus();
+        cliOutput(
+          {
+            config: status.config,
+            lastCheckpoint: status.status.lastCheckpoint,
+            pendingFiles: status.status.pendingChanges,
+            isGitRepo: status.status.isGitRepo
+          },
+          { command: "checkpoint" }
+        );
+        return;
+      }
+      if (args["dry-run"]) {
+        const status = await gitCheckpointStatus();
+        const count = status.status.pendingChanges;
+        cliOutput(
+          {
+            dryRun: true,
+            fileCount: count
+          },
+          {
+            command: "checkpoint",
+            message: count === 0 ? "No CLEO files to checkpoint" : `Would checkpoint ${count} file(s)`
+          }
+        );
+        return;
+      }
+      const before = await gitCheckpointStatus();
+      if (!before.config.enabled) {
+        cliOutput(
+          { enabled: false },
+          {
+            command: "checkpoint",
+            message: "Git checkpoint is disabled. Enable with: cleo config set gitCheckpoint.enabled true"
+          }
+        );
+        return;
+      }
+      if (before.status.pendingChanges === 0) {
+        cliOutput(
+          { noChange: true },
+          { command: "checkpoint", message: "No CLEO files to checkpoint" }
+        );
+        return;
+      }
+      await gitCheckpoint("manual");
+      cliOutput(
+        {
+          checkpointed: before.status.pendingChanges
+        },
+        { command: "checkpoint", message: "Checkpoint complete" }
+      );
+    } catch (err) {
+      if (err instanceof CleoError) {
+        cliError(formatError(err), err.code, { name: "E_CHECKPOINT_FAILED" });
+        process.exit(err.code);
+      }
+      throw err;
+    }
+  }
+});
+export {
+  checkpointCommand
+};
+//# sourceMappingURL=checkpoint-37HMMKD7.js.map

package/dist/cli/chunk-2JIJD2I7.js

@@ -0,0 +1,108 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliError,
+  cliOutput,
+  humanInfo
+} from "./chunk-3ZO3M37V.js";
+
+// packages/cleo/src/cli/commands/doctor-fk-check.ts
+import { repairForeignKeyViolations, verifyForeignKeyIntegrity } from "@cleocode/core/db";
+var doctorFkCheckCommand = defineCommand({
+  meta: {
+    name: "fk-check",
+    description: "Verify foreign-key integrity of the consolidated project + global cleo.db (PRAGMA foreign_key_check). Read-only; exits non-zero on any violation."
+  },
+  args: {
+    scope: {
+      type: "string",
+      description: "Limit the check to one scope ('project' or 'global'). Default: both."
+    },
+    fix: {
+      type: "boolean",
+      description: "Delete orphan rows whose foreign key declares ON DELETE CASCADE (the schema already says they should not exist). Other violations are reported, never touched."
+    }
+  },
+  async run({ args }) {
+    const scopeArg = args.scope;
+    if (scopeArg !== void 0 && scopeArg !== "project" && scopeArg !== "global") {
+      cliError(`--scope must be 'project' or 'global' (received: ${scopeArg})`, "E_INVALID_INPUT", {
+        fix: "Run 'cleo doctor fk-check --scope project' or omit --scope to check both."
+      });
+      process.exitCode = 6;
+      return;
+    }
+    const scopeOpt = scopeArg ? { scopes: [scopeArg] } : {};
+    if (args.fix === true) {
+      const fixReport = await repairForeignKeyViolations({ cwd: process.cwd(), ...scopeOpt });
+      humanInfo(
+        `  foreign_key_check --fix: ${fixReport.found.length} found, ${fixReport.repaired.length} repaired, ${fixReport.skipped.length} skipped`
+      );
+      for (const v of fixReport.repaired) {
+        humanInfo(`      repaired [${v.scope}] ${v.table} rowid=${v.rowid} \u2192 ${v.parent}`);
+      }
+      for (const v of fixReport.skipped) {
+        humanInfo(
+          `      SKIPPED  [${v.scope}] ${v.table} rowid=${v.rowid ?? "n/a"} \u2192 ${v.parent} (foreign key is not ON DELETE CASCADE \u2014 repair by hand)`
+        );
+      }
+      cliOutput(
+        { kind: "generic", ...fixReport },
+        {
+          command: "doctor fk-check",
+          message: fixReport.ok ? `foreign_key_check: repaired ${fixReport.repaired.length} orphan(s); 0 violations remain.` : `foreign_key_check: ${fixReport.skipped.length} violation(s) remain after repair.`
+        }
+      );
+      if (!fixReport.ok) process.exitCode = 1;
+      return;
+    }
+    const report = await verifyForeignKeyIntegrity({ cwd: process.cwd(), ...scopeOpt });
+    if (report.ok) {
+      humanInfo(`  foreign_key_check: OK \u2014 0 violations across ${report.scopes.join(" + ")}`);
+    } else {
+      humanInfo(`  foreign_key_check: ${report.violations.length} violation(s)`);
+      for (const v of report.violations) {
+        humanInfo(
+          `      [${v.scope}] ${v.table} rowid=${v.rowid ?? "n/a"} \u2192 missing parent ${v.parent} (fk #${v.fkid})`
+        );
+      }
+    }
+    cliOutput(
+      {
+        kind: "generic",
+        ok: report.ok,
+        scopes: report.scopes,
+        violationCount: report.violations.length,
+        violations: report.violations
+      },
+      {
+        command: "doctor fk-check",
+        message: report.ok ? `foreign_key_check: OK \u2014 0 violations across ${report.scopes.join(" + ")}.` : `foreign_key_check: ${report.violations.length} violation(s) across ${report.scopes.join(" + ")}.`
+      }
+    );
+    if (!report.ok) {
+      process.exitCode = 1;
+    }
+  }
+});
+
+export {
+  doctorFkCheckCommand
+};
+//# sourceMappingURL=chunk-2JIJD2I7.js.map

package/dist/cli/chunk-37NU2XDP.js

@@ -0,0 +1,171 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliError,
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+
+// packages/cleo/src/cli/commands/doctor-twin-collapse.ts
+import {
+  inspectProjectTwinCollapse,
+  recoverTwinCollapse,
+  releaseProjectTwinCollapseSnapshot,
+  retryTwinCollapse,
+  rollbackTwinCollapse
+} from "@cleocode/core/doctor/twin-collapse.js";
+import { CleoError } from "@cleocode/core/errors";
+import { getProjectRoot } from "@cleocode/core/paths.js";
+var doctorTwinCollapseCommand = defineCommand({
+  meta: {
+    name: "twin-collapse",
+    description: "Report the twin collapses (bare schema_meta / sticky_tags kept in step with their prefixed twins): state, last failure, snapshot path and space needed. --retry re-runs them; --recover restores what 2026.9.21 dropped; --release-snapshot lets a checked snapshot rotate."
+  },
+  args: {
+    retry: {
+      type: "boolean",
+      description: "Run the collapse once now (after clearing the reported cause)"
+    },
+    recover: {
+      type: "boolean",
+      description: "Restore twin values a 2026.9.21 collapse dropped or replaced, from its pinned pre-collapse snapshot, into twin_collapse_archive:* (T12727). Combine with --dry-run"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "With --recover: print the plan, write nothing"
+    },
+    "pin-snapshot": {
+      type: "boolean",
+      description: "With --recover: pin an unpinned pre-collapse snapshot (its .meta.json sidecar only) before applying"
+    },
+    rollback: {
+      type: "string",
+      description: "Undo one --recover apply by its receipt id (twin_collapse_recovery:<recoveredAt>)"
+    },
+    "release-snapshot": {
+      type: "string",
+      description: "Release a pre-collapse snapshot (backup id, e.g. migration-20260928-153200) after a verified recovery or a no-recovery-needed check, so it rotates normally. Needs --confirm; --dry-run shows the bytes reclaimed"
+    },
+    confirm: {
+      type: "boolean",
+      description: "With --release-snapshot: the owner's decision to release (obtained by the calling agent; the CLI never prompts)"
+    },
+    "confirm-owner-store": {
+      type: "boolean",
+      description: "From a git worktree: allow --recover, --rollback or --retry to write the owning project's live store"
+    },
+    json: { type: "boolean", description: "Output as JSON" },
+    human: { type: "boolean", description: "Force human-readable output" },
+    quiet: { type: "boolean", description: "Suppress non-essential output" }
+  },
+  async run({ args }) {
+    const projectRoot = getProjectRoot();
+    const guard = { cwd: process.cwd(), confirmOwnerStore: args["confirm-owner-store"] === true };
+    const actions = twinCollapseActions(args);
+    if (actions.length > 1) {
+      cliError(
+        `E_INVALID_INPUT: ${actions.join(" and ")} are separate actions; run them one at a time (--recover before --release-snapshot)`,
+        "E_INVALID_INPUT",
+        { name: "Error", fix: "cleo doctor twin-collapse --recover --dry-run" }
+      );
+      process.exitCode = 2;
+      return;
+    }
+    try {
+      if (typeof args.rollback === "string" && args.rollback.length > 0) {
+        const result = await rollbackTwinCollapse(projectRoot, args.rollback, guard);
+        cliOutput(
+          { kind: "generic", ...result },
+          { command: "doctor", operation: "doctor.twin-collapse.rollback" }
+        );
+        return;
+      }
+      if (typeof args["release-snapshot"] === "string" && args["release-snapshot"].length > 0) {
+        const result = await releaseProjectTwinCollapseSnapshot(
+          projectRoot,
+          args["release-snapshot"],
+          {
+            ...guard,
+            dryRun: args["dry-run"] === true,
+            confirm: args.confirm === true
+          }
+        );
+        cliOutput(
+          { kind: "generic", ...result },
+          { command: "doctor", operation: "doctor.twin-collapse.release-snapshot" }
+        );
+        return;
+      }
+      if (args.recover === true) {
+        const result = await recoverTwinCollapse(projectRoot, {
+          ...guard,
+          dryRun: args["dry-run"] === true,
+          pinSnapshot: args["pin-snapshot"] === true
+        });
+        cliOutput(
+          { kind: "generic", ...result },
+          { command: "doctor", operation: "doctor.twin-collapse.recover" }
+        );
+        return;
+      }
+      if (args.retry === true) {
+        const receipts = await retryTwinCollapse(projectRoot, guard);
+        cliOutput(
+          { kind: "generic", receipts },
+          { command: "doctor", operation: "doctor.twin-collapse.retry" }
+        );
+        return;
+      }
+    } catch (error) {
+      reportTwinCollapseError(error, args.retry === true);
+      return;
+    }
+    const report = inspectProjectTwinCollapse(projectRoot);
+    cliOutput(report, { command: "doctor", operation: "doctor.twin-collapse.run" });
+    const failed = report.pairs.some((p) => p.state === "failed") || report.preflight?.ok === false;
+    if (failed && (process.exitCode === void 0 || process.exitCode === 0)) {
+      process.exitCode = 1;
+    }
+  }
+});
+function reportTwinCollapseError(error, retry) {
+  if (retry && !(error instanceof CleoError)) throw error;
+  const message = error instanceof Error ? error.message : String(error);
+  const named = /^(E_[A-Z_]+):/.exec(message)?.[1];
+  const code = named ?? (retry ? "E_TWIN_COLLAPSE_FAILED" : "E_TWIN_COLLAPSE_RECOVER");
+  cliError(message, code, {
+    name: error instanceof CleoError ? "CleoError" : "Error",
+    fix: error instanceof CleoError ? error.fix : void 0,
+    details: error instanceof CleoError ? error.details : void 0
+  });
+  process.exitCode = error instanceof CleoError ? error.code : 1;
+}
+function twinCollapseActions(args) {
+  const named = (key) => typeof args[key] === "string" && args[key].length > 0;
+  return [
+    args.recover === true ? "--recover" : "",
+    named("release-snapshot") ? "--release-snapshot" : "",
+    named("rollback") ? "--rollback" : "",
+    args.retry === true ? "--retry" : ""
+  ].filter(Boolean);
+}
+
+export {
+  doctorTwinCollapseCommand
+};
+//# sourceMappingURL=chunk-37NU2XDP.js.map