@cleocode/cleo 2026.10.3 → 2026.10.4

package/dist/cli/exodus-KALO3B3X.js

@@ -0,0 +1,401 @@
+(() => {
+  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 "./chunk-C3B7C43W.js";
+import {
+  isSubCommandDispatch
+} from "./chunk-YY66LFZF.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliError,
+  cliOutput,
+  humanInfo
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/exodus.ts
+import { existsSync } from "node:fs";
+import { ExitCode } from "@cleocode/contracts";
+import { resolveDualScopeDbPath } from "@cleocode/core/store/dual-scope-db.js";
+import {
+  archiveMigratedSources,
+  buildExodusPlan,
+  hasExodusCompleteMarker,
+  runExodusMigrate,
+  runExodusStatus,
+  runExodusVerify,
+  sealExodus,
+  sourcesPresent,
+  verifyMigration
+} from "@cleocode/core/store/exodus/index.js";
+import { isDataContinuityOk } from "@cleocode/core/store/exodus/on-open.js";
+function fmtBytes(n) {
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  return `${(n / 1024 / 1024).toFixed(1)} MB`;
+}
+var migrateSubCommand = defineCommand({
+  meta: {
+    name: "migrate",
+    description: "Migrate legacy multi-DB fleet into consolidated dual-scope cleo.db"
+  },
+  args: {
+    "dry-run": {
+      type: "boolean",
+      description: "Preview migration plan without writing anything",
+      default: false
+    },
+    "force-cross-version": {
+      type: "boolean",
+      description: "Skip schema-version guard (AC9 \u2014 use with care)",
+      default: false
+    },
+    scope: {
+      type: "string",
+      description: "Which scope to migrate: 'global', 'project', or 'both' (default = full fleet)",
+      default: "both"
+    }
+  },
+  async run({ args }) {
+    const dryRun = args["dry-run"] === true;
+    const forceCrossVersion = args["force-cross-version"] === true;
+    const scope = args.scope ?? "both";
+    if (scope !== "both" && scope !== "project" && scope !== "global") {
+      cliError(
+        `Invalid --scope '${scope}'. Use 'global', 'project', or 'both'.`,
+        ExitCode.VALIDATION_ERROR,
+        { name: "E_INVALID_SCOPE" },
+        { operation: "exodus.migrate" }
+      );
+      process.exitCode = ExitCode.VALIDATION_ERROR;
+      return;
+    }
+    const fullPlan = buildExodusPlan(process.cwd());
+    const plan = scope === "both" ? fullPlan : { ...fullPlan, sources: fullPlan.sources.filter((s) => s.targetScope === scope) };
+    if (scope !== "both" && hasExodusCompleteMarker(scope) && !dryRun) {
+      cliOutput(
+        { kind: "generic", ok: true, alreadySealed: true, scope },
+        {
+          command: "exodus migrate",
+          message: `Scope '${scope}' already migrated + sealed (completion marker present) \u2014 nothing to do.`
+        }
+      );
+      return;
+    }
+    humanInfo(`Exodus migration plan:`);
+    humanInfo(
+      `  Source DBs (${plan.sources.length} total, ${fmtBytes(plan.totalSourceBytes)} combined):`
+    );
+    for (const s of plan.sources) {
+      humanInfo(`    [${s.targetScope.padEnd(7)}] ${s.name.padEnd(20)} ${s.path}`);
+    }
+    humanInfo(`  Target project cleo.db: ${plan.projectDbPath}`);
+    humanInfo(`  Target global  cleo.db: ${plan.globalDbPath}`);
+    humanInfo(`  Available disk: ${fmtBytes(plan.availableBytes)}`);
+    humanInfo(
+      `  Required (1.2\xD7 largest ${fmtBytes(plan.largestSourceBytes)} + consolidated): ${fmtBytes(plan.requiredBytes)}`
+    );
+    humanInfo(`  Disk pre-flight: ${plan.diskPreflight ? "PASS" : "FAIL"}`);
+    if (plan.resumeFromStaging) {
+      humanInfo(`  Resuming from existing staging: ${plan.stagingDir}`);
+    }
+    if (dryRun) {
+      cliOutput(
+        {
+          kind: "generic",
+          dryRun: true,
+          plan: {
+            sources: plan.sources.map((s) => ({
+              name: s.name,
+              path: s.path,
+              targetScope: s.targetScope
+            })),
+            totalSourceBytes: plan.totalSourceBytes,
+            largestSourceBytes: plan.largestSourceBytes,
+            requiredBytes: plan.requiredBytes,
+            availableBytes: plan.availableBytes,
+            diskPreflight: plan.diskPreflight,
+            stagingDir: plan.stagingDir,
+            resumeFromStaging: plan.resumeFromStaging,
+            projectDbPath: plan.projectDbPath,
+            globalDbPath: plan.globalDbPath
+          }
+        },
+        { command: "exodus migrate" }
+      );
+      return;
+    }
+    if (!sourcesPresent(plan.sources)) {
+      cliError(
+        "No legacy source DBs found. Nothing to migrate.",
+        ExitCode.NOT_FOUND,
+        { name: "E_NO_SOURCES" },
+        { operation: "exodus.migrate" }
+      );
+      process.exitCode = ExitCode.NOT_FOUND;
+      return;
+    }
+    if (!plan.diskPreflight) {
+      const shortfall = Math.max(0, plan.requiredBytes - plan.availableBytes);
+      cliError(
+        `Insufficient disk space for exodus. Need \u2265${fmtBytes(plan.requiredBytes)} (\u22481.2\xD7 largest source ${fmtBytes(plan.largestSourceBytes)} + consolidated estimate ${fmtBytes(plan.totalSourceBytes)}), have ${fmtBytes(plan.availableBytes)} \u2014 ${fmtBytes(shortfall)} short. Free up space (e.g. \`cleo backup prune\`) or move .cleo/ to a larger volume.`,
+        ExitCode.VALIDATION_ERROR,
+        { name: "E_DISK_PREFLIGHT_FAIL" },
+        { operation: "exodus.migrate" }
+      );
+      process.exitCode = ExitCode.VALIDATION_ERROR;
+      return;
+    }
+    humanInfo("Starting migration\u2026");
+    const result = await runExodusMigrate(plan, forceCrossVersion, (msg) => humanInfo(`  ${msg}`));
+    if (!result.ok) {
+      cliError(
+        result.error ?? "Migration failed",
+        ExitCode.GENERAL_ERROR,
+        { name: "E_EXODUS_MIGRATE_FAILED" },
+        { operation: "exodus.migrate" }
+      );
+      process.exitCode = ExitCode.GENERAL_ERROR;
+      return;
+    }
+    const copied = result.tables.filter((t) => !t.skipped).reduce((n, t) => n + t.rowsCopied, 0);
+    const skipped = result.tables.filter((t) => t.skipped).length;
+    const verifyResult = verifyMigration(
+      plan.sources,
+      plan.projectDbPath,
+      plan.globalDbPath,
+      (msg) => humanInfo(`  verify: ${msg}`)
+    );
+    let archived = [];
+    if (isDataContinuityOk(verifyResult)) {
+      const consumed = plan.sources.filter((s) => existsSync(s.path));
+      const archiveResult = archiveMigratedSources(consumed, process.cwd());
+      archived = archiveResult.sources.filter((s) => s.action === "archived").map((s) => s.name);
+      humanInfo(
+        `  Archived ${archived.length} legacy source DB(s) \u2192 _archive/ and sealed completion marker(s): ${archiveResult.markersWritten.join(", ")}`
+      );
+    } else {
+      humanInfo(
+        "  Parity validation did NOT pass \u2014 legacy sources LEFT IN PLACE (not archived). Run `cleo exodus verify` to inspect."
+      );
+    }
+    cliOutput(
+      {
+        kind: "generic",
+        ok: true,
+        summary: {
+          tablesProcessed: result.tables.length,
+          rowsCopied: copied,
+          tablesSkipped: skipped,
+          stagingDir: result.stagingDir,
+          backupCount: result.backupPaths.length,
+          archivedSources: archived,
+          archived: archived.length > 0
+        },
+        tables: result.tables
+      },
+      {
+        command: "exodus migrate",
+        message: `Migration complete. ${result.tables.length} tables processed, ${copied} rows copied.`
+      }
+    );
+  }
+});
+var verifySubCommand = defineCommand({
+  meta: {
+    name: "verify",
+    description: "Verify row-level equivalence between legacy DBs and consolidated cleo.db"
+  },
+  args: {
+    "show-passing": {
+      type: "boolean",
+      description: "Include passing tables in human output (default: failures only)",
+      default: false
+    }
+  },
+  run({ args }) {
+    const showPassing = args["show-passing"] === true;
+    const plan = buildExodusPlan(process.cwd());
+    const projectDbPath = resolveDualScopeDbPath("project", process.cwd());
+    const globalDbPath = resolveDualScopeDbPath("global");
+    humanInfo("Running equivalence verification\u2026");
+    const result = runExodusVerify(
+      plan.sources,
+      projectDbPath,
+      globalDbPath,
+      (msg) => humanInfo(`  ${msg}`)
+    );
+    if (!result.ok && result.error) {
+      cliError(
+        result.error,
+        ExitCode.GENERAL_ERROR,
+        { name: "E_EXODUS_VERIFY_FAILED" },
+        { operation: "exodus.verify" }
+      );
+      process.exitCode = ExitCode.GENERAL_ERROR;
+      return;
+    }
+    const failures = result.tables.filter((t) => !t.countMatch || !t.hashMatch);
+    const passing = result.tables.filter((t) => t.countMatch && t.hashMatch);
+    if (failures.length > 0) {
+      humanInfo(`
+Failed tables (${failures.length}):`);
+      for (const t of failures) {
+        humanInfo(
+          `  FAIL [${t.scope}] ${t.tableName}: source=${t.sourceCount}, target=${t.targetCount}, hashMatch=${t.hashMatch}`
+        );
+      }
+    }
+    if (showPassing && passing.length > 0) {
+      humanInfo(`
+Passing tables (${passing.length}):`);
+      for (const t of passing) {
+        humanInfo(`  OK   [${t.scope}] ${t.tableName}: ${t.sourceCount} rows`);
+      }
+    }
+    cliOutput(
+      {
+        kind: "generic",
+        ok: result.ok,
+        summary: {
+          totalTables: result.tables.length,
+          passing: passing.length,
+          failing: failures.length
+        },
+        failures,
+        ...showPassing ? { passing } : {}
+      },
+      {
+        command: "exodus verify",
+        message: result.ok ? `All ${passing.length} tables verified \u2014 equivalence confirmed.` : `${failures.length} table(s) failed equivalence check.`
+      }
+    );
+    if (!result.ok) {
+      process.exitCode = ExitCode.GENERAL_ERROR;
+    }
+  }
+});
+var sealSubCommand = defineCommand({
+  meta: {
+    name: "seal",
+    description: "Certify an already-migrated install: count-parity gate (no digest) \u2192 archive legacy source DBs (reversible) + write the completion marker so exodus-on-open stops re-firing."
+  },
+  args: {
+    scope: {
+      type: "string",
+      description: "Which scope to seal: 'global', 'project', or 'both' (default)",
+      default: "both"
+    }
+  },
+  run({ args }) {
+    const scope = args.scope ?? "both";
+    if (scope !== "both" && scope !== "project" && scope !== "global") {
+      cliError(
+        `Invalid --scope '${scope}'. Use 'global', 'project', or 'both'.`,
+        ExitCode.VALIDATION_ERROR,
+        { name: "E_INVALID_SCOPE" },
+        { operation: "exodus.seal" }
+      );
+      process.exitCode = ExitCode.VALIDATION_ERROR;
+      return;
+    }
+    const plan = buildExodusPlan(process.cwd());
+    const result = sealExodus(plan, scope, process.cwd());
+    if (!result.ok) {
+      cliError(
+        result.refusedReason ?? "Seal refused \u2014 parity deficit.",
+        ExitCode.GENERAL_ERROR,
+        { name: "E_EXODUS_SEAL_DEFICIT" },
+        { operation: "exodus.seal" }
+      );
+      process.exitCode = ExitCode.GENERAL_ERROR;
+      return;
+    }
+    for (const sc of result.scopes) {
+      const moved = sc.archived.filter((a) => a.action === "archived").length;
+      humanInfo(
+        `  [${sc.scope}] ${sc.alreadySealed ? "re-sealed" : "sealed"} \u2014 archived ${moved} legacy DB(s), marker: ${sc.markerPath}`
+      );
+    }
+    cliOutput(
+      {
+        kind: "generic",
+        ok: true,
+        scopesSealed: result.scopes.map((s) => s.scope),
+        tablesVerified: result.parity.checked,
+        archived: result.scopes.flatMap(
+          (s) => s.archived.filter((a) => a.action === "archived").map((a) => ({ scope: s.scope, name: a.name, archivedTo: a.archivedTo }))
+        )
+      },
+      {
+        command: "exodus seal",
+        message: `Sealed ${result.scopes.map((s) => s.scope).join(
+          " + "
+        )} \u2014 ${result.parity.checked} tables count-verified, legacy DBs archived (reversible).`
+      }
+    );
+  }
+});
+function showStatus() {
+  const result = runExodusStatus(process.cwd());
+  humanInfo("Exodus status:");
+  humanInfo(`  Staging dir present: ${result.hasStaging ? result.stagingDir ?? "yes" : "none"}`);
+  humanInfo(`  Project cleo.db:     ${result.projectDbExists ? "present" : "not yet created"}`);
+  humanInfo(`  Global  cleo.db:     ${result.globalDbExists ? "present" : "not yet created"}`);
+  humanInfo("");
+  humanInfo("  Source DBs:");
+  for (const s of result.sources) {
+    const size = s.exists ? `${(s.bytes / 1024).toFixed(1)} KB` : "-";
+    humanInfo(`    ${s.exists ? "\u2713" : "\u2717"} ${s.name.padEnd(22)} ${size.padStart(10)}  ${s.path}`);
+  }
+  if (result.journal) {
+    const done = result.journal.tables.filter((t) => t.status === "done").length;
+    const total = result.journal.tables.length;
+    humanInfo("");
+    humanInfo(`  Journal: ${done}/${total} tables done, started ${result.journal.startedAt}`);
+  }
+  cliOutput(result, { command: "exodus status" });
+}
+var statusSubCommand = defineCommand({
+  meta: {
+    name: "status",
+    description: "Show exodus migration status (staging, source DBs, target DBs)"
+  },
+  run() {
+    showStatus();
+  }
+});
+var exodusCommand = defineCommand({
+  meta: {
+    name: "exodus",
+    description: "[TRANSITIONAL] Migrate legacy multi-DB fleet to consolidated dual-scope cleo.db (SG-DB-SUBSTRATE-V2)"
+  },
+  subCommands: {
+    migrate: migrateSubCommand,
+    verify: verifySubCommand,
+    seal: sealSubCommand,
+    status: statusSubCommand
+  },
+  async run({ cmd, rawArgs }) {
+    if (isSubCommandDispatch(rawArgs, cmd.subCommands)) return;
+    showStatus();
+  }
+});
+export {
+  exodusCommand
+};
+//# sourceMappingURL=exodus-KALO3B3X.js.map

package/dist/cli/export-ROFOCG4M.js

@@ -0,0 +1,92 @@
+(() => {
+  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 {
+  dispatchFromCli,
+  dispatchRaw,
+  handleRawError
+} from "./chunk-3IOQVUO7.js";
+import "./chunk-AWCQH2W5.js";
+import "./chunk-OGV57L4J.js";
+import "./chunk-ZBISIPCK.js";
+import "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-QFFQSKRC.js";
+
+// packages/cleo/src/cli/commands/export.ts
+var exportCommand = defineCommand({
+  meta: { name: "export", description: "Export tasks to CSV, TSV, JSON, or markdown format" },
+  args: {
+    "export-format": {
+      type: "string",
+      description: "Export format: json, csv, tsv, markdown",
+      default: "json"
+    },
+    output: {
+      type: "string",
+      description: "Output file path (stdout if omitted)"
+    },
+    status: {
+      type: "string",
+      description: "Filter by status (comma-separated)"
+    },
+    parent: {
+      type: "string",
+      description: "Filter by parent task"
+    },
+    phase: {
+      type: "string",
+      description: "Filter by phase"
+    }
+  },
+  async run({ args }) {
+    const hasOutput = !!args.output;
+    if (hasOutput) {
+      await dispatchFromCli(
+        "query",
+        "admin",
+        "export",
+        {
+          format: args["export-format"],
+          output: args.output,
+          status: args.status,
+          parent: args.parent,
+          phase: args.phase
+        },
+        { command: "export" }
+      );
+    } else {
+      const response = await dispatchRaw("query", "admin", "export", {
+        format: args["export-format"],
+        status: args.status,
+        parent: args.parent,
+        phase: args.phase
+      });
+      handleRawError(response, { command: "export", operation: "admin.export" });
+      const data = response.data;
+      if (data?.content) {
+        process.stdout.write(data.content);
+        if (!data.content.endsWith("\n")) process.stdout.write("\n");
+      }
+    }
+  }
+});
+export {
+  exportCommand
+};
+//# sourceMappingURL=export-ROFOCG4M.js.map

package/dist/cli/export-tasks-US3WBIEQ.js

@@ -0,0 +1,96 @@
+(() => {
+  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 {
+  dispatchFromCli,
+  dispatchRaw,
+  handleRawError
+} from "./chunk-3IOQVUO7.js";
+import "./chunk-AWCQH2W5.js";
+import "./chunk-OGV57L4J.js";
+import "./chunk-ZBISIPCK.js";
+import "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-QFFQSKRC.js";
+
+// packages/cleo/src/cli/commands/export-tasks.ts
+var exportTasksCommand = defineCommand({
+  meta: {
+    name: "export-tasks",
+    description: "Export tasks to portable .cleo-export.json package for cross-project transfer"
+  },
+  args: {
+    taskIds: {
+      type: "positional",
+      description: "Task IDs to export (space-separated; omit to export all)",
+      required: false
+    },
+    output: {
+      type: "string",
+      description: "Output file path (stdout if omitted)",
+      alias: "o"
+    },
+    subtree: {
+      type: "boolean",
+      description: "Include all descendants of specified task(s)",
+      default: false
+    },
+    filter: {
+      type: "string",
+      description: "Filter tasks by criteria (key=value)"
+    },
+    "include-deps": {
+      type: "boolean",
+      description: "Auto-include task dependencies",
+      default: false
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview selection without creating export file",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const hasOutput = !!args.output;
+    const dryRun = args["dry-run"];
+    const params = {
+      taskIds: args.taskIds ? [args.taskIds] : void 0,
+      output: args.output,
+      subtree: args.subtree,
+      filter: args.filter,
+      includeDeps: args["include-deps"],
+      dryRun,
+      scope: "tasks"
+    };
+    if (hasOutput || dryRun) {
+      await dispatchFromCli("query", "admin", "export", params, { command: "export-tasks" });
+    } else {
+      const response = await dispatchRaw("query", "admin", "export", params);
+      handleRawError(response, { command: "export-tasks", operation: "admin.export" });
+      const data = response.data;
+      if (data?.content) {
+        process.stdout.write(data.content);
+        if (!data.content.endsWith("\n")) process.stdout.write("\n");
+      }
+    }
+  }
+});
+export {
+  exportTasksCommand
+};
+//# sourceMappingURL=export-tasks-US3WBIEQ.js.map