@cleocode/cleo 2026.10.3 → 2026.10.5-rc.ci.672

package/dist/cli/schema-OOOKLWUE.js

@@ -0,0 +1,195 @@
+(() => {
+  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 {
+  OPERATIONS
+} from "./chunk-4VASFLUW.js";
+import {
+  defineCommand,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliError,
+  cliOutput
+} from "./chunk-4RGSNUUP.js";
+import {
+  setFormatContext
+} from "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/schema.ts
+import { getInputContract } from "@cleocode/core";
+import { describeOperation } from "@cleocode/lafs";
+function resolveOperationDef(operationArg) {
+  const dotIdx = operationArg.indexOf(".");
+  if (dotIdx === -1) {
+    const matches = OPERATIONS.filter((op) => op.operation === operationArg);
+    if (matches.length === 1) {
+      return matches[0] ?? null;
+    }
+    return null;
+  }
+  const domain = operationArg.slice(0, dotIdx);
+  const operation = operationArg.slice(dotIdx + 1);
+  return OPERATIONS.find((op) => op.domain === domain && op.operation === operation) ?? null;
+}
+var schemaCommand = defineCommand({
+  meta: {
+    name: "schema",
+    description: "Introspect a CLEO operation: show params, types, enums, and declared gates"
+  },
+  args: {
+    operation: {
+      type: "positional",
+      description: "Operation key in domain.operation format (e.g. tasks.add)",
+      required: false
+    },
+    format: {
+      type: "string",
+      description: "Output format: json (default) or human (pretty table)",
+      default: "json"
+    },
+    "include-gates": {
+      type: "boolean",
+      description: "Include precondition gates in output (default: true)",
+      default: true
+    },
+    "include-examples": {
+      type: "boolean",
+      description: "Include usage examples in output (default: false)",
+      default: false
+    },
+    input: {
+      type: "boolean",
+      description: "Return the JSON Schema (draft-07) for the operation input payload, from OperationInputContract.schema (T9918)",
+      default: false
+    },
+    list: {
+      type: "boolean",
+      description: "List every operation key (domain.operation) so an operation can be discovered before it is introspected (T12308).",
+      default: false
+    },
+    examples: {
+      type: "boolean",
+      description: "Return canned example payloads from OperationInputContract.examples \u2014 pipeline: `cleo schema <op> --examples | jq '.examples[0].value' | cleo <verb> --params -` (T9918)",
+      default: false
+    }
+  },
+  async run({ args, cmd }) {
+    if (args.list === true) {
+      const operations = OPERATIONS.map((op) => ({
+        key: `${op.domain}.${op.operation}`,
+        gateway: op.gateway,
+        description: op.description
+      })).sort((a, b) => a.key.localeCompare(b.key));
+      if ((args.format ?? "json") === "human") {
+        setFormatContext({ format: "human", source: "flag", quiet: false });
+      }
+      cliOutput(
+        { operations, count: operations.length },
+        { command: "schema", operation: "schema.list" }
+      );
+      return;
+    }
+    if (!args.operation) {
+      await showUsage(cmd);
+      return;
+    }
+    const format = args.format ?? "json";
+    const includeGates = args["include-gates"] !== false;
+    const includeExamples = args["include-examples"] === true;
+    const wantInput = args.input === true;
+    const wantExamples = args.examples === true;
+    if (format === "human") {
+      setFormatContext({ format: "human", source: "flag", quiet: false });
+    }
+    const def = resolveOperationDef(args.operation);
+    if (def === null) {
+      cliError(
+        `Unknown operation: "${args.operation}". Run \`cleo schema --list\` to see all operations.`,
+        4,
+        {
+          name: "E_NOT_FOUND",
+          fix: "cleo schema --list"
+        }
+      );
+      process.exit(4);
+      return;
+    }
+    if (wantInput || wantExamples) {
+      const contract = getInputContract(args.operation);
+      if (contract === null) {
+        cliOutput(
+          {
+            operation: args.operation,
+            schema: null,
+            examples: []
+          },
+          {
+            command: "schema",
+            operation: `schema.${args.operation}`,
+            message: `No OperationInputContract registered for ${args.operation}`,
+            extensions: {
+              hint: `No OperationInputContract registered for ${args.operation}. Use plain flag-based invocation.`
+            }
+          }
+        );
+        return;
+      }
+      if (wantInput) {
+        cliOutput(
+          {
+            operation: contract.operation,
+            schema: contract.schema
+          },
+          {
+            command: "schema",
+            operation: `schema.${args.operation}`,
+            message: `Input schema for ${contract.operation}`
+          }
+        );
+        return;
+      }
+      cliOutput(
+        {
+          operation: contract.operation,
+          examples: contract.examples.map((ex) => ({
+            name: ex.name,
+            value: ex.value,
+            ...ex.description !== void 0 ? { description: ex.description } : {}
+          }))
+        },
+        {
+          command: "schema",
+          operation: `schema.${args.operation}`,
+          message: `Examples for ${contract.operation}`
+        }
+      );
+      return;
+    }
+    const schema = describeOperation(def, {
+      includeGates,
+      includeExamples
+    });
+    cliOutput(schema, {
+      command: "schema",
+      operation: `schema.${args.operation}`,
+      message: `Schema for ${schema.operation}`
+    });
+  }
+});
+export {
+  schemaCommand
+};
+//# sourceMappingURL=schema-OOOKLWUE.js.map

package/dist/cli/self-update-26SOTJMH.js

@@ -0,0 +1,504 @@
+(() => {
+  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 {
+  createSelfUpdateProgress
+} from "./chunk-W3JLYKKY.js";
+import {
+  negatedFlag
+} from "./chunk-47JYZAMS.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliError,
+  cliOutput,
+  humanInfo,
+  humanWarn
+} from "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/self-update.ts
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import * as readline from "node:readline";
+import { promisify } from "node:util";
+import { ExitCode } from "@cleocode/contracts/exit-codes.js";
+import {
+  BUILD_CONFIG,
+  CleoError,
+  checkAllRegisteredProjects,
+  checkStorageMigration,
+  getCleoHome,
+  getRuntimeDiagnostics,
+  runUpgrade
+} from "@cleocode/core/internal";
+var execAsync = promisify(execFile);
+var GITHUB_REPO = BUILD_CONFIG.repository.fullName;
+async function getCurrentVersion() {
+  const cleoHome = getCleoHome();
+  try {
+    const content = await readFile(join(cleoHome, "VERSION"), "utf-8");
+    return (content.split("\n")[0] ?? "unknown").trim();
+  } catch {
+    return "unknown";
+  }
+}
+async function getNpmInstalledVersion() {
+  try {
+    const { stdout } = await execAsync("npm", [
+      "ls",
+      "-g",
+      "@cleocode/cleo",
+      "--depth=0",
+      "--json"
+    ]);
+    const data = JSON.parse(stdout);
+    return data.dependencies?.["@cleocode/cleo"]?.version ?? null;
+  } catch {
+    return null;
+  }
+}
+async function getDistTagVersion(tag) {
+  try {
+    const { stdout } = await execAsync("npm", ["view", `@cleocode/cleo@${tag}`, "version"]);
+    const v = stdout.trim();
+    return v || null;
+  } catch {
+    if (tag === "latest") {
+      try {
+        const { stdout } = await execAsync("curl", [
+          "-sL",
+          "--max-time",
+          "10",
+          `https://api.github.com/repos/${GITHUB_REPO}/releases/latest`
+        ]);
+        const data = JSON.parse(stdout);
+        return data.tag_name?.replace(/^v/, "") ?? null;
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+}
+async function writeRuntimeVersionMetadata(mode, source, version) {
+  const cleoHome = getCleoHome();
+  const lines = [
+    version,
+    `mode=${mode}`,
+    `source=${source}`,
+    `installed=${(/* @__PURE__ */ new Date()).toISOString()}`
+  ];
+  await import("node:fs/promises").then(
+    ({ writeFile, mkdir }) => mkdir(cleoHome, { recursive: true }).then(
+      () => writeFile(join(cleoHome, "VERSION"), `${lines.join("\n")}
+`, "utf-8")
+    )
+  );
+}
+var selfUpdateCommand = defineCommand({
+  meta: {
+    name: "self-update",
+    description: "Check for and install CLEO updates, then run post-update diagnostics"
+  },
+  args: {
+    check: {
+      type: "boolean",
+      description: "Only check if update is available"
+    },
+    status: {
+      type: "boolean",
+      description: "Show current vs latest version"
+    },
+    version: {
+      type: "string",
+      description: "Update to specific version"
+    },
+    channel: {
+      type: "string",
+      description: "Update channel: stable|beta"
+    },
+    beta: {
+      type: "boolean",
+      description: "Shortcut for --channel beta"
+    },
+    force: {
+      type: "boolean",
+      description: "Force update even if same version"
+    },
+    "post-update": {
+      type: "boolean",
+      description: "Run post-update diagnostics and migration only"
+    },
+    "no-auto-upgrade": {
+      type: "boolean",
+      description: "Skip automatic upgrade after update"
+    },
+    "auto-migrate": {
+      type: "boolean",
+      description: "Automatically migrate storage without prompting"
+    },
+    "check-projects": {
+      type: "boolean",
+      default: true,
+      description: "Run cross-project health probe after upgrade (disable with --no-check-projects)"
+    },
+    // Global output format flags — read directly from args (no optsWithGlobals in citty)
+    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 isHuman = args.human === true || !!process.stdout.isTTY && args.json !== true;
+    const progress = createSelfUpdateProgress(isHuman);
+    try {
+      const noAutoUpgrade = negatedFlag(args, "auto-upgrade");
+      const checkProjects = args["check-projects"] !== false;
+      if (args["post-update"]) {
+        progress.start();
+        progress.step(4, "Running post-update diagnostics");
+        await runPostUpdateDiagnostics({
+          skipUpgrade: noAutoUpgrade,
+          autoMigrate: !!args["auto-migrate"] || !!args.force,
+          checkProjects
+        });
+        progress.complete("Post-update diagnostics complete");
+        return;
+      }
+      progress.start();
+      progress.step(0, "Detecting installation type");
+      const runtime = await getRuntimeDiagnostics();
+      const script = runtime.invocation.script;
+      const fromNodeModules = script.includes("/node_modules/@cleocode/cleo/") || script.includes("\\node_modules\\@cleocode\\cleo\\");
+      const isDev = runtime.channel === "dev" && !fromNodeModules;
+      progress.step(1, "Checking current version");
+      const currentVersion = isDev ? await getCurrentVersion() : await getNpmInstalledVersion() ?? await getCurrentVersion();
+      const rawChannel = args.channel?.toLowerCase();
+      if (rawChannel && rawChannel !== "stable" && rawChannel !== "beta") {
+        throw new CleoError(
+          ExitCode.VALIDATION_ERROR,
+          `Invalid --channel '${rawChannel}'. Expected stable|beta`
+        );
+      }
+      const requestedChannel = args.beta ? "beta" : rawChannel ?? (runtime.channel === "beta" ? "beta" : "stable");
+      if (isDev && !args.force) {
+        progress.step(4, "Running post-update checks");
+        const preflight = checkStorageMigration();
+        cliOutput(
+          {
+            devMode: true,
+            channel: runtime.channel,
+            currentVersion,
+            message: "Dev install detected. Use git pull to update.",
+            storagePreflight: {
+              migrationNeeded: preflight.migrationNeeded,
+              summary: preflight.summary,
+              fix: preflight.fix
+            }
+          },
+          { command: "self-update" }
+        );
+        if (preflight.migrationNeeded) {
+          progress.error(`Storage migration needed: ${preflight.summary}`);
+          humanWarn(
+            `
+\u26A0 Storage migration needed: ${preflight.summary}
+  Fix: ${preflight.fix}
+  Or run: cleo upgrade
+`
+          );
+        } else {
+          progress.complete("Dev environment check complete");
+        }
+        process.exit(ExitCode.NO_DATA);
+        return;
+      }
+      if (args.status || args.check) {
+        progress.step(2, "Querying npm registry");
+        const latest2 = await getDistTagVersion(requestedChannel === "beta" ? "beta" : "latest");
+        if (!latest2) {
+          throw new CleoError(
+            ExitCode.DEPENDENCY_ERROR,
+            "Failed to check latest version from GitHub"
+          );
+        }
+        progress.step(3, "Comparing versions");
+        const updateAvailable = latest2 !== currentVersion;
+        const preflight = checkStorageMigration();
+        cliOutput(
+          {
+            currentVersion,
+            latestVersion: latest2,
+            channel: requestedChannel,
+            updateAvailable,
+            storagePreflight: {
+              migrationNeeded: preflight.migrationNeeded,
+              summary: preflight.summary,
+              fix: preflight.fix
+            }
+          },
+          { command: "self-update" }
+        );
+        if (args.check && updateAvailable) {
+          process.exit(1);
+        }
+        return;
+      }
+      progress.step(2, "Querying npm registry");
+      const latest = args.version ?? await getDistTagVersion(requestedChannel === "beta" ? "beta" : "latest");
+      if (!latest) {
+        throw new CleoError(
+          ExitCode.DEPENDENCY_ERROR,
+          "Failed to check latest version from GitHub"
+        );
+      }
+      progress.step(3, "Comparing versions");
+      if (latest === currentVersion && !args.force) {
+        progress.step(4, "Running post-update checks");
+        await runPostUpdateDiagnostics({
+          skipUpgrade: noAutoUpgrade,
+          autoMigrate: !!args["auto-migrate"] || !!args.force,
+          checkProjects
+        });
+        progress.complete("Already up to date");
+        cliOutput(
+          {
+            currentVersion,
+            upToDate: true
+          },
+          { command: "self-update", message: "Already up to date" }
+        );
+        return;
+      }
+      const spec = args.version ? `@cleocode/cleo@${latest}` : requestedChannel === "beta" ? "@cleocode/cleo@beta" : "@cleocode/cleo@latest";
+      progress.step(4, `Installing ${spec}`);
+      await execAsync("npm", ["install", "-g", spec], { maxBuffer: 10 * 1024 * 1024 });
+      await writeRuntimeVersionMetadata("prod-npm", "npm", latest);
+      progress.step(5, "Finalizing");
+      cliOutput(
+        {
+          currentVersion,
+          targetVersion: latest,
+          channel: requestedChannel,
+          updated: true,
+          command: `npm install -g ${spec}`
+        },
+        { command: "self-update", message: `Updated to ${latest}` }
+      );
+      await runPostUpdateDiagnostics({
+        skipUpgrade: noAutoUpgrade,
+        autoMigrate: !!args["auto-migrate"] || !!args.force,
+        checkProjects
+      });
+      progress.complete(`Updated to ${latest}`);
+    } catch (err) {
+      if (err instanceof CleoError) {
+        progress.error(err.message);
+        cliError(
+          err.message,
+          err.code,
+          { name: "CleoError", fix: err.fix },
+          { operation: "self-update" }
+        );
+        process.exit(err.code);
+      }
+      progress.error("Unexpected error during update");
+      throw err;
+    }
+  }
+});
+async function runPostUpdateDiagnostics(opts) {
+  const preflight = checkStorageMigration();
+  if (preflight.migrationNeeded) {
+    if (opts?.skipUpgrade) {
+      humanWarn(
+        `
+\u26A0 Storage migration detected: ${preflight.summary}
+  Auto-upgrade skipped (--no-auto-upgrade).
+  Run manually: cleo upgrade
+`
+      );
+      cliOutput(
+        {
+          postUpdate: true,
+          upgradeSkipped: true,
+          storagePreflight: {
+            migrationNeeded: true,
+            summary: preflight.summary,
+            fix: preflight.fix
+          }
+        },
+        { command: "self-update", message: "Post-update upgrade skipped." }
+      );
+      return;
+    }
+    humanWarn(`
+\u26A0 Storage migration detected: ${preflight.summary}`);
+    let shouldMigrate = !!opts?.autoMigrate;
+    if (!shouldMigrate) {
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      shouldMigrate = await new Promise((resolve) => {
+        rl.question("  Do you want to run the upgrade now? [Y/n] ", (answer) => {
+          rl.close();
+          const clean = answer.trim().toLowerCase();
+          resolve(clean === "" || clean === "y" || clean === "yes");
+        });
+      });
+    }
+    if (!shouldMigrate) {
+      humanWarn(`
+  Upgrade skipped. Run manually later: cleo upgrade
+`);
+      return;
+    }
+    humanInfo(`  Running upgrade...
+`);
+    const result = await runUpgrade({ autoMigrate: true });
+    if (result.actions.length > 0) {
+      humanInfo("Upgrade actions:");
+      for (const action of result.actions) {
+        const icon = action.status === "applied" ? "  \u2713" : action.status === "error" ? "  \u2717" : "  -";
+        humanInfo(`${icon} ${action.action}: ${action.details}`);
+      }
+      humanInfo("");
+    }
+    cliOutput(
+      {
+        postUpdate: true,
+        upgrade: {
+          success: result.success,
+          applied: result.applied,
+          actions: result.actions,
+          storageMigration: result.storageMigration,
+          errors: result.errors.length > 0 ? result.errors : void 0
+        }
+      },
+      {
+        command: "self-update",
+        message: result.success ? "Post-update upgrade complete." : "Post-update upgrade had errors."
+      }
+    );
+    if (!result.success) {
+      humanWarn(`
+\u26A0 Some upgrade steps failed. Manual fix:
+  ${preflight.fix}
+`);
+    }
+  } else {
+    if (!opts?.skipUpgrade) {
+      const result = await runUpgrade({ autoMigrate: false });
+      if (result.applied > 0 || result.errors.length > 0) {
+        if (result.actions.length > 0) {
+          humanInfo("Post-update maintenance:");
+          for (const action of result.actions) {
+            if (action.status === "skipped") continue;
+            const icon = action.status === "applied" ? "  \u2713" : action.status === "error" ? "  \u2717" : "  -";
+            humanInfo(`${icon} ${action.action}: ${action.details}`);
+          }
+          humanInfo("");
+        }
+        cliOutput(
+          {
+            postUpdate: true,
+            upgrade: {
+              success: result.success,
+              applied: result.applied,
+              actions: result.actions,
+              errors: result.errors.length > 0 ? result.errors : void 0
+            }
+          },
+          {
+            command: "self-update",
+            message: result.success ? `Post-update maintenance complete (${result.applied} action(s) applied).` : "Post-update maintenance had errors."
+          }
+        );
+      } else {
+        cliOutput(
+          {
+            postUpdate: true,
+            storagePreflight: {
+              migrationNeeded: false,
+              summary: preflight.summary
+            }
+          },
+          { command: "self-update", message: "No post-update actions needed." }
+        );
+      }
+    } else {
+      cliOutput(
+        {
+          postUpdate: true,
+          storagePreflight: {
+            migrationNeeded: false,
+            summary: preflight.summary
+          }
+        },
+        { command: "self-update", message: "No post-update actions needed." }
+      );
+    }
+  }
+  if (opts?.checkProjects !== false) {
+    try {
+      const report = await checkAllRegisteredProjects({
+        updateRegistry: true
+      });
+      cliOutput(
+        {
+          crossProjectHealth: {
+            summary: report.summary,
+            global: report.global.overall,
+            globalIssues: report.global.issues,
+            degraded: report.projects.filter((p) => p.overall === "degraded").map((p) => ({
+              hash: p.projectHash,
+              path: p.projectPath,
+              issues: p.issues
+            })),
+            unreachable: report.projects.filter((p) => p.overall === "unreachable").map((p) => ({
+              hash: p.projectHash,
+              path: p.projectPath
+            }))
+          }
+        },
+        {
+          command: "self-update",
+          message: report.summary.degraded > 0 || report.summary.unreachable > 0 ? `Cross-project health: ${report.summary.degraded} degraded, ${report.summary.unreachable} unreachable` : `Cross-project health: ${report.summary.totalProjects} project(s) healthy`
+        }
+      );
+    } catch (err) {
+      humanWarn(
+        `
+\u26A0 Cross-project health probe failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+}
+export {
+  selfUpdateCommand
+};
+//# sourceMappingURL=self-update-26SOTJMH.js.map