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

package/dist/cli/chunk-OILHT47L.js

@@ -0,0 +1,252 @@
+(() => {
+  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);
+  };
+})();
+
+// packages/cleo/src/cli/lib/did-you-mean.ts
+function levenshteinDistance(input, candidate) {
+  const inputLen = input.length;
+  const candidateLen = candidate.length;
+  const matrix = Array.from({ length: inputLen + 1 }, (_, i) => [i]);
+  for (let j = 1; j <= candidateLen; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1; i <= inputLen; i++) {
+    for (let j = 1; j <= candidateLen; j++) {
+      const cost = input[i - 1] === candidate[j - 1] ? 0 : 1;
+      matrix[i][j] = Math.min(
+        matrix[i - 1][j] + 1,
+        // deletion
+        matrix[i][j - 1] + 1,
+        // insertion
+        matrix[i - 1][j - 1] + cost
+        // substitution
+      );
+    }
+  }
+  return matrix[inputLen][candidateLen];
+}
+function didYouMean(input, candidates, maxDistance = 2) {
+  const suggestions = candidates.map((candidate) => ({
+    command: candidate,
+    distance: levenshteinDistance(input, candidate)
+  })).filter((item) => item.distance <= maxDistance).sort((a, b) => {
+    if (a.distance !== b.distance) {
+      return a.distance - b.distance;
+    }
+    return a.command.localeCompare(b.command);
+  }).map((item) => item.command);
+  return suggestions;
+}
+
+// packages/cleo/src/cli/lib/strict-args.ts
+var E_UNKNOWN_FLAG = "E_UNKNOWN_FLAG";
+var RETIRED_FLAG_GUIDANCE = /* @__PURE__ */ new Map([
+  [
+    "complete",
+    /* @__PURE__ */ new Map([
+      [
+        "--force",
+        '--force was removed by ADR-051. Record evidence instead: `cleo verify <id> --gate <gate> --evidence "<atoms>"`, then `cleo complete <id>`. For an audited emergency bypass, set CLEO_OWNER_OVERRIDE=1 on verify.'
+      ]
+    ])
+  ]
+]);
+var RETIRED_FLAG_ALIASES = /* @__PURE__ */ new Map([["done", "complete"]]);
+function retiredGuidanceFor(commandName, flag) {
+  const key = RETIRED_FLAG_ALIASES.get(commandName) ?? commandName;
+  return RETIRED_FLAG_GUIDANCE.get(key)?.get(flag);
+}
+var CLI_GLOBAL_FLAGS = Object.freeze([
+  "--json",
+  "--human",
+  "--quiet",
+  "--field",
+  "--fields",
+  "--mvi",
+  "--verbose",
+  "--full",
+  "--output",
+  "--summary",
+  "--describe",
+  "--idempotency-key",
+  "--help",
+  "--version"
+]);
+var CLI_GLOBAL_VALUE_FLAGS = Object.freeze([
+  "--field",
+  "--fields",
+  "--mvi",
+  "--output"
+]);
+function normalizeGlobalValueFlags(argv) {
+  const normalized = [];
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    if (token === "--") {
+      normalized.push(...argv.slice(i));
+      break;
+    }
+    if (token !== void 0 && CLI_GLOBAL_VALUE_FLAGS.includes(token) && i + 1 < argv.length) {
+      normalized.push(`${token}=${argv[i + 1]}`);
+      i++;
+      continue;
+    }
+    if (token !== void 0) {
+      normalized.push(token);
+    }
+  }
+  return normalized;
+}
+var UnknownFlagError = class extends Error {
+  /** Stable LAFS error code string for envelope emission. */
+  code = E_UNKNOWN_FLAG;
+  /** The unknown flag token as it appeared in `rawArgs` (e.g. `--titel`, `-X`). */
+  flag;
+  /** Human-readable command label (e.g. `'docs add'`). */
+  command;
+  /** Did-you-mean suggestions, sorted by Levenshtein distance ascending. */
+  suggestions;
+  /** The full list of known flags accepted by the command (long form + short). */
+  knownFlags;
+  /** Suggested fix string for {@link CliErrorDetails.fix}. */
+  fix;
+  /** Set when the flag was REMOVED rather than mistyped. @task T12139 */
+  retiredGuidance;
+  /**
+   * @param input - Structured failure context: offending flag, command
+   *   label, ranked suggestions, and the full known-flag set.
+   */
+  constructor(input) {
+    const suggestionPart = input.suggestions.length > 0 ? ` Did you mean: ${input.suggestions.join(", ")}?` : "";
+    super(
+      `${E_UNKNOWN_FLAG}: unknown flag '${input.flag}' for '${input.command}'.${suggestionPart}`
+    );
+    this.name = "UnknownFlagError";
+    this.flag = input.flag;
+    this.command = input.command;
+    this.suggestions = input.suggestions;
+    this.knownFlags = input.knownFlags;
+    this.retiredGuidance = input.retiredGuidance;
+    this.fix = input.retiredGuidance ? input.retiredGuidance : input.suggestions.length > 0 ? `Try one of: ${input.suggestions.join(", ")}. Run \`cleo ${input.command} --help\` for the full flag list.` : `Run \`cleo ${input.command} --help\` for the full flag list.`;
+  }
+};
+function collectKnownLongFlags(schema) {
+  const known = /* @__PURE__ */ new Set();
+  for (const [name, def] of Object.entries(schema)) {
+    if (!def) continue;
+    known.add(`--${name}`);
+    if (def.type === "positional") continue;
+    if (def.type === "boolean") {
+      known.add(`--no-${name}`);
+    }
+    const alias = def.alias;
+    if (typeof alias === "string" && alias.length > 0) {
+      known.add(alias.length === 1 ? `-${alias}` : `--${alias}`);
+    } else if (Array.isArray(alias)) {
+      for (const a of alias) {
+        if (typeof a !== "string" || a.length === 0) continue;
+        known.add(a.length === 1 ? `-${a}` : `--${a}`);
+      }
+    }
+  }
+  return known;
+}
+function collectSuggestionCandidates(schema) {
+  const candidates = [];
+  for (const [name, def] of Object.entries(schema)) {
+    if (!def || def.type === "positional") continue;
+    candidates.push(`--${name}`);
+  }
+  return candidates.sort();
+}
+function assertKnownFlags(rawArgs, schema, commandName) {
+  if (!rawArgs || rawArgs.length === 0) return;
+  if (schema === void 0) return;
+  if (typeof schema === "function" || typeof schema === "object" && schema !== null && "then" in schema) {
+    return;
+  }
+  const resolved = schema;
+  const known = collectKnownLongFlags(resolved);
+  for (const global of CLI_GLOBAL_FLAGS) known.add(global);
+  const candidates = collectSuggestionCandidates(resolved);
+  for (let i = 0; i < rawArgs.length; i++) {
+    const token = rawArgs[i];
+    if (token === void 0) continue;
+    if (token === "--") break;
+    if (!token.startsWith("-")) continue;
+    if (token === "-") continue;
+    if (token.startsWith("--")) {
+      const eqIdx = token.indexOf("=");
+      const flagName = eqIdx >= 0 ? token.slice(0, eqIdx) : token;
+      if (!known.has(flagName)) {
+        throw new UnknownFlagError({
+          retiredGuidance: retiredGuidanceFor(commandName, flagName),
+          flag: flagName,
+          command: commandName,
+          suggestions: didYouMean(flagName, candidates, 3),
+          knownFlags: [...known].sort()
+        });
+      }
+    } else {
+      const eqIdx = token.indexOf("=");
+      const body = eqIdx >= 0 ? token.slice(1, eqIdx) : token.slice(1);
+      const first = `-${body[0]}`;
+      if (!known.has(first)) {
+        throw new UnknownFlagError({
+          flag: first,
+          command: commandName,
+          suggestions: didYouMean(first, candidates, 3),
+          knownFlags: [...known].sort()
+        });
+      }
+      if (eqIdx < 0 && body.length > 1) {
+        const isBooleanShort = isBooleanAlias(resolved, body[0]);
+        if (isBooleanShort) {
+          for (let k = 1; k < body.length; k++) {
+            const ch = body[k];
+            if (ch === void 0) continue;
+            const short = `-${ch}`;
+            if (!known.has(short)) {
+              throw new UnknownFlagError({
+                flag: short,
+                command: commandName,
+                suggestions: didYouMean(short, candidates, 3),
+                knownFlags: [...known].sort()
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+}
+function isBooleanAlias(schema, letter) {
+  if (!letter) return false;
+  for (const def of Object.values(schema)) {
+    if (!def || def.type !== "boolean") continue;
+    const alias = def.alias;
+    if (alias === letter) return true;
+    if (Array.isArray(alias) && alias.includes(letter)) return true;
+  }
+  return false;
+}
+
+export {
+  didYouMean,
+  normalizeGlobalValueFlags,
+  UnknownFlagError,
+  assertKnownFlags
+};
+//# sourceMappingURL=chunk-OILHT47L.js.map

package/dist/cli/chunk-PKKZPOOP.js

@@ -0,0 +1,352 @@
+(() => {
+  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);
+  };
+})();
+
+// node_modules/.pnpm/citty@0.2.1/node_modules/citty/dist/_chunks/libs/scule.mjs
+var NUMBER_CHAR_RE = /\d/;
+var STR_SPLITTERS = [
+  "-",
+  "_",
+  "/",
+  "."
+];
+function isUppercase(char = "") {
+  if (NUMBER_CHAR_RE.test(char)) return;
+  return char !== char.toLowerCase();
+}
+function splitByCase(str, separators) {
+  const splitters = separators ?? STR_SPLITTERS;
+  const parts = [];
+  if (!str || typeof str !== "string") return parts;
+  let buff = "";
+  let previousUpper;
+  let previousSplitter;
+  for (const char of str) {
+    const isSplitter = splitters.includes(char);
+    if (isSplitter === true) {
+      parts.push(buff);
+      buff = "";
+      previousUpper = void 0;
+      continue;
+    }
+    const isUpper = isUppercase(char);
+    if (previousSplitter === false) {
+      if (previousUpper === false && isUpper === true) {
+        parts.push(buff);
+        buff = char;
+        previousUpper = isUpper;
+        continue;
+      }
+      if (previousUpper === true && isUpper === false && buff.length > 1) {
+        const lastChar = buff.at(-1);
+        parts.push(buff.slice(0, Math.max(0, buff.length - 1)));
+        buff = lastChar + char;
+        previousUpper = isUpper;
+        continue;
+      }
+    }
+    buff += char;
+    previousUpper = isUpper;
+    previousSplitter = isSplitter;
+  }
+  parts.push(buff);
+  return parts;
+}
+function upperFirst(str) {
+  return str ? str[0].toUpperCase() + str.slice(1) : "";
+}
+function lowerFirst(str) {
+  return str ? str[0].toLowerCase() + str.slice(1) : "";
+}
+function pascalCase(str, opts) {
+  return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => upperFirst(opts?.normalize ? p.toLowerCase() : p)).join("") : "";
+}
+function camelCase(str, opts) {
+  return lowerFirst(pascalCase(str || "", opts));
+}
+function kebabCase(str, joiner) {
+  return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => p.toLowerCase()).join(joiner ?? "-") : "";
+}
+
+// node_modules/.pnpm/citty@0.2.1/node_modules/citty/dist/index.mjs
+import { parseArgs as parseArgs$1 } from "node:util";
+function toArray(val) {
+  if (Array.isArray(val)) return val;
+  return val === void 0 ? [] : [val];
+}
+function formatLineColumns(lines, linePrefix = "") {
+  const maxLength = [];
+  for (const line of lines) for (const [i, element] of line.entries()) maxLength[i] = Math.max(maxLength[i] || 0, element.length);
+  return lines.map((l) => l.map((c, i) => linePrefix + c[i === 0 ? "padStart" : "padEnd"](maxLength[i])).join("  ")).join("\n");
+}
+function resolveValue(input) {
+  return typeof input === "function" ? input() : input;
+}
+var CLIError = class extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "CLIError";
+    this.code = code;
+  }
+};
+function parseRawArgs(args = [], opts = {}) {
+  const booleans = new Set(opts.boolean || []);
+  const strings = new Set(opts.string || []);
+  const aliasMap = opts.alias || {};
+  const defaults = opts.default || {};
+  const aliasToMain = /* @__PURE__ */ new Map();
+  const mainToAliases = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(aliasMap)) {
+    const targets = value;
+    for (const target of targets) {
+      aliasToMain.set(key, target);
+      if (!mainToAliases.has(target)) mainToAliases.set(target, []);
+      mainToAliases.get(target).push(key);
+      aliasToMain.set(target, key);
+      if (!mainToAliases.has(key)) mainToAliases.set(key, []);
+      mainToAliases.get(key).push(target);
+    }
+  }
+  const options = {};
+  function getType(name) {
+    if (booleans.has(name)) return "boolean";
+    const aliases = mainToAliases.get(name) || [];
+    for (const alias of aliases) if (booleans.has(alias)) return "boolean";
+    return "string";
+  }
+  const allOptions = /* @__PURE__ */ new Set([
+    ...booleans,
+    ...strings,
+    ...Object.keys(aliasMap),
+    ...Object.values(aliasMap).flat(),
+    ...Object.keys(defaults)
+  ]);
+  for (const name of allOptions) if (!options[name]) options[name] = {
+    type: getType(name),
+    default: defaults[name]
+  };
+  for (const [alias, main] of aliasToMain.entries()) if (alias.length === 1 && options[main] && !options[main].short) options[main].short = alias;
+  const processedArgs = [];
+  const negatedFlags = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--") {
+      processedArgs.push(...args.slice(i));
+      break;
+    }
+    if (arg.startsWith("--no-")) {
+      const flagName = arg.slice(5);
+      negatedFlags[flagName] = true;
+      continue;
+    }
+    processedArgs.push(arg);
+  }
+  let parsed;
+  try {
+    parsed = parseArgs$1({
+      args: processedArgs,
+      options: Object.keys(options).length > 0 ? options : void 0,
+      allowPositionals: true,
+      strict: false
+    });
+  } catch {
+    parsed = {
+      values: {},
+      positionals: processedArgs
+    };
+  }
+  const out = { _: [] };
+  out._ = parsed.positionals;
+  for (const [key, value] of Object.entries(parsed.values)) out[key] = value;
+  for (const [name] of Object.entries(negatedFlags)) {
+    out[name] = false;
+    const mainName = aliasToMain.get(name);
+    if (mainName) out[mainName] = false;
+    const aliases = mainToAliases.get(name);
+    if (aliases) for (const alias of aliases) out[alias] = false;
+  }
+  for (const [alias, main] of aliasToMain.entries()) {
+    if (out[alias] !== void 0 && out[main] === void 0) out[main] = out[alias];
+    if (out[main] !== void 0 && out[alias] === void 0) out[alias] = out[main];
+  }
+  return out;
+}
+var noColor = /* @__PURE__ */ (() => {
+  const env = globalThis.process?.env ?? {};
+  return env.NO_COLOR === "1" || env.TERM === "dumb" || env.TEST || env.CI;
+})();
+var _c = (c, r = 39) => (t) => noColor ? t : `\x1B[${c}m${t}\x1B[${r}m`;
+var bold = /* @__PURE__ */ _c(1, 22);
+var cyan = /* @__PURE__ */ _c(36);
+var gray = /* @__PURE__ */ _c(90);
+var underline = /* @__PURE__ */ _c(4, 24);
+function parseArgs(rawArgs, argsDef) {
+  const parseOptions = {
+    boolean: [],
+    string: [],
+    alias: {},
+    default: {}
+  };
+  const args = resolveArgs(argsDef);
+  for (const arg of args) {
+    if (arg.type === "positional") continue;
+    if (arg.type === "string" || arg.type === "enum") parseOptions.string.push(arg.name);
+    else if (arg.type === "boolean") parseOptions.boolean.push(arg.name);
+    if (arg.default !== void 0) parseOptions.default[arg.name] = arg.default;
+    if (arg.alias) parseOptions.alias[arg.name] = arg.alias;
+    const camelName = camelCase(arg.name);
+    const kebabName = kebabCase(arg.name);
+    if (camelName !== arg.name || kebabName !== arg.name) {
+      const existingAliases = toArray(parseOptions.alias[arg.name] || []);
+      if (camelName !== arg.name && !existingAliases.includes(camelName)) existingAliases.push(camelName);
+      if (kebabName !== arg.name && !existingAliases.includes(kebabName)) existingAliases.push(kebabName);
+      if (existingAliases.length > 0) parseOptions.alias[arg.name] = existingAliases;
+    }
+  }
+  const parsed = parseRawArgs(rawArgs, parseOptions);
+  const [...positionalArguments] = parsed._;
+  const parsedArgsProxy = new Proxy(parsed, { get(target, prop) {
+    return target[prop] ?? target[camelCase(prop)] ?? target[kebabCase(prop)];
+  } });
+  for (const [, arg] of args.entries()) if (arg.type === "positional") {
+    const nextPositionalArgument = positionalArguments.shift();
+    if (nextPositionalArgument !== void 0) parsedArgsProxy[arg.name] = nextPositionalArgument;
+    else if (arg.default === void 0 && arg.required !== false) throw new CLIError(`Missing required positional argument: ${arg.name.toUpperCase()}`, "EARG");
+    else parsedArgsProxy[arg.name] = arg.default;
+  } else if (arg.type === "enum") {
+    const argument = parsedArgsProxy[arg.name];
+    const options = arg.options || [];
+    if (argument !== void 0 && options.length > 0 && !options.includes(argument)) throw new CLIError(`Invalid value for argument: ${cyan(`--${arg.name}`)} (${cyan(argument)}). Expected one of: ${options.map((o) => cyan(o)).join(", ")}.`, "EARG");
+  } else if (arg.required && parsedArgsProxy[arg.name] === void 0) throw new CLIError(`Missing required argument: --${arg.name}`, "EARG");
+  return parsedArgsProxy;
+}
+function resolveArgs(argsDef) {
+  const args = [];
+  for (const [name, argDef] of Object.entries(argsDef || {})) args.push({
+    ...argDef,
+    name,
+    alias: toArray(argDef.alias)
+  });
+  return args;
+}
+function defineCommand(def) {
+  return def;
+}
+async function runCommand(cmd, opts) {
+  const cmdArgs = await resolveValue(cmd.args || {});
+  const parsedArgs = parseArgs(opts.rawArgs, cmdArgs);
+  const context = {
+    rawArgs: opts.rawArgs,
+    args: parsedArgs,
+    data: opts.data,
+    cmd
+  };
+  if (typeof cmd.setup === "function") await cmd.setup(context);
+  let result;
+  try {
+    const subCommands = await resolveValue(cmd.subCommands);
+    if (subCommands && Object.keys(subCommands).length > 0) {
+      const subCommandArgIndex = opts.rawArgs.findIndex((arg) => !arg.startsWith("-"));
+      const subCommandName = opts.rawArgs[subCommandArgIndex];
+      if (subCommandName) {
+        if (!subCommands[subCommandName]) throw new CLIError(`Unknown command ${cyan(subCommandName)}`, "E_UNKNOWN_COMMAND");
+        const subCommand = await resolveValue(subCommands[subCommandName]);
+        if (subCommand) await runCommand(subCommand, { rawArgs: opts.rawArgs.slice(subCommandArgIndex + 1) });
+      } else if (!cmd.run) throw new CLIError(`No command specified.`, "E_NO_COMMAND");
+    }
+    if (typeof cmd.run === "function") result = await cmd.run(context);
+  } finally {
+    if (typeof cmd.cleanup === "function") await cmd.cleanup(context);
+  }
+  return { result };
+}
+async function showUsage(cmd, parent) {
+  try {
+    console.log(await renderUsage(cmd, parent) + "\n");
+  } catch (error) {
+    console.error(error);
+  }
+}
+var negativePrefixRe = /^no[-A-Z]/;
+async function renderUsage(cmd, parent) {
+  const cmdMeta = await resolveValue(cmd.meta || {});
+  const cmdArgs = resolveArgs(await resolveValue(cmd.args || {}));
+  const parentMeta = await resolveValue(parent?.meta || {});
+  const commandName = `${parentMeta.name ? `${parentMeta.name} ` : ""}` + (cmdMeta.name || process.argv[1]);
+  const argLines = [];
+  const posLines = [];
+  const commandsLines = [];
+  const usageLine = [];
+  for (const arg of cmdArgs) if (arg.type === "positional") {
+    const name = arg.name.toUpperCase();
+    const isRequired = arg.required !== false && arg.default === void 0;
+    const defaultHint = arg.default ? `="${arg.default}"` : "";
+    posLines.push([
+      cyan(name + defaultHint),
+      arg.description || "",
+      arg.valueHint ? `<${arg.valueHint}>` : ""
+    ]);
+    usageLine.push(isRequired ? `<${name}>` : `[${name}]`);
+  } else {
+    const isRequired = arg.required === true && arg.default === void 0;
+    const argStr = [...(arg.alias || []).map((a) => `-${a}`), `--${arg.name}`].join(", ") + (arg.type === "string" && (arg.valueHint || arg.default) ? `=${arg.valueHint ? `<${arg.valueHint}>` : `"${arg.default || ""}"`}` : "") + (arg.type === "enum" && arg.options ? `=<${arg.options.join("|")}>` : "");
+    argLines.push([cyan(argStr + (isRequired ? " (required)" : "")), arg.description || ""]);
+    if (arg.type === "boolean" && (arg.default === true || arg.negativeDescription) && !negativePrefixRe.test(arg.name)) {
+      const negativeArgStr = [...(arg.alias || []).map((a) => `--no-${a}`), `--no-${arg.name}`].join(", ");
+      argLines.push([cyan(negativeArgStr + (isRequired ? " (required)" : "")), arg.negativeDescription || ""]);
+    }
+    if (isRequired) usageLine.push(argStr);
+  }
+  if (cmd.subCommands) {
+    const commandNames = [];
+    const subCommands = await resolveValue(cmd.subCommands);
+    for (const [name, sub] of Object.entries(subCommands)) {
+      const meta = await resolveValue((await resolveValue(sub))?.meta);
+      if (meta?.hidden) continue;
+      commandsLines.push([cyan(name), meta?.description || ""]);
+      commandNames.push(name);
+    }
+    usageLine.push(commandNames.join("|"));
+  }
+  const usageLines = [];
+  const version = cmdMeta.version || parentMeta.version;
+  usageLines.push(gray(`${cmdMeta.description} (${commandName + (version ? ` v${version}` : "")})`), "");
+  const hasOptions = argLines.length > 0 || posLines.length > 0;
+  usageLines.push(`${underline(bold("USAGE"))} ${cyan(`${commandName}${hasOptions ? " [OPTIONS]" : ""} ${usageLine.join(" ")}`)}`, "");
+  if (posLines.length > 0) {
+    usageLines.push(underline(bold("ARGUMENTS")), "");
+    usageLines.push(formatLineColumns(posLines, "  "));
+    usageLines.push("");
+  }
+  if (argLines.length > 0) {
+    usageLines.push(underline(bold("OPTIONS")), "");
+    usageLines.push(formatLineColumns(argLines, "  "));
+    usageLines.push("");
+  }
+  if (commandsLines.length > 0) {
+    usageLines.push(underline(bold("COMMANDS")), "");
+    usageLines.push(formatLineColumns(commandsLines, "  "));
+    usageLines.push("", `Use ${cyan(`${commandName} <command> --help`)} for more information about a command.`);
+  }
+  return usageLines.filter((l) => typeof l === "string").join("\n");
+}
+
+export {
+  defineCommand,
+  runCommand,
+  showUsage
+};
+//# sourceMappingURL=chunk-PKKZPOOP.js.map

package/dist/cli/chunk-PN4WW5VX.js

@@ -0,0 +1,66 @@
+(() => {
+  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 {
+  cliOutput
+} from "./chunk-4RGSNUUP.js";
+
+// packages/cleo/src/cli/commands/doctor-project-identity.ts
+import {
+  inspectProjectIdentity,
+  inspectProjectNameDrift,
+  resolveProjectIdentity
+} from "@cleocode/core/doctor/project-identity.js";
+import { getProjectRoot } from "@cleocode/core/project-scope";
+var doctorProjectIdentityCommand = defineCommand({
+  meta: {
+    name: "project-identity",
+    description: "Check .cleo/project.json, its legacy .cleo/project-id mirror and the project-info.json cache (legacy / missing / conflict / invalid / untracked) plus registry-name drift, and print the exact remedy. --resolve applies it: it migrates a legacy project to .cleo/project.json (no id changes) and re-keys a conflict to the tracked id through the alias table, losing no registry rows; add --dry-run to see the plan first."
+  },
+  args: {
+    resolve: { type: "boolean", description: "Apply the remedy for the reported state" },
+    "dry-run": { type: "boolean", description: "With --resolve: print the plan, write nothing" },
+    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();
+    if (!args.resolve) {
+      const report = inspectProjectIdentity(projectRoot);
+      const nameDrift = await inspectProjectNameDrift(projectRoot);
+      cliOutput(
+        { ...report, nameDrift },
+        { command: "doctor", operation: "doctor.project-identity.inspect" }
+      );
+      const drifted = nameDrift.state === "drift" || nameDrift.state === "taken";
+      if ((report.state !== "ok" || drifted) && (process.exitCode === void 0 || process.exitCode === 0))
+        process.exitCode = 1;
+      return;
+    }
+    const result = await resolveProjectIdentity(projectRoot, { dryRun: !!args["dry-run"] });
+    cliOutput(result, { command: "doctor", operation: "doctor.project-identity.resolve" });
+    if (result.refused && result.before.state !== "ok" && (process.exitCode ?? 0) === 0)
+      process.exitCode = 1;
+  }
+});
+
+export {
+  doctorProjectIdentityCommand
+};
+//# sourceMappingURL=chunk-PN4WW5VX.js.map