@cleocode/cleo 2026.10.2 → 2026.10.4

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-OPTEQKBB.js

@@ -0,0 +1,258 @@
+(() => {
+  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 {
+  runLoginFrontDoor
+} from "./chunk-J3ZFM3UQ.js";
+import {
+  ReadlineWizardIO
+} from "./chunk-GZFVDR44.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliError,
+  cliOutput,
+  isHumanOutput
+} from "./chunk-3ZO3M37V.js";
+
+// packages/cleo/src/cli/commands/init.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  CleoError,
+  getWorkflowTemplatesDir as getCoreWorkflowTemplatesDir,
+  initErrorCodeName,
+  initProject,
+  pushWarning,
+  scaffoldWorkflows
+} from "@cleocode/core";
+import { getCredentialPool } from "@cleocode/core/llm/credential-pool.js";
+import { getTemplatesByKind } from "@cleocode/core/templates/registry";
+function getGitignoreTemplate() {
+  try {
+    const thisFile = fileURLToPath(import.meta.url);
+    const packageRoot = join(thisFile, "..", "..", "..", "..");
+    const localTemplatePath = join(packageRoot, "templates", "cleo-gitignore");
+    const monorepoTemplatePath = join(packageRoot, "..", "..", "templates", "cleo-gitignore");
+    const templatePath = existsSync(localTemplatePath) ? localTemplatePath : monorepoTemplatePath;
+    if (existsSync(templatePath)) {
+      return readFileSync(templatePath, "utf-8");
+    }
+  } catch {
+  }
+  return "# CLEO Project Data - Selective Git Tracking\nagent-outputs/\n";
+}
+function getWorkflowTemplatesDir() {
+  return getCoreWorkflowTemplatesDir();
+}
+var initCommand = defineCommand({
+  meta: { name: "init", description: "Initialize CLEO in a project directory" },
+  args: {
+    projectName: {
+      type: "positional",
+      description: "Project name (alternative to --name)",
+      required: false
+    },
+    name: {
+      type: "string",
+      description: "Project name"
+    },
+    force: {
+      type: "boolean",
+      description: "Re-initialize THIS directory's project: resets .cleo/config.json and project-info.json, rewrites .cleo/.gitignore and the managed git hooks. Snapshots databases and those files to .cleo/backups/sqlite/ first; never targets an ancestor or a worktree.",
+      default: false
+    },
+    detect: {
+      type: "boolean",
+      description: "Auto-detect project configuration",
+      default: false
+    },
+    "map-codebase": {
+      type: "boolean",
+      description: "Run codebase analysis and store findings to brain.db",
+      default: false
+    },
+    "install-seed-agents": {
+      type: "boolean",
+      description: "Install canonical CleoOS seed agent personas (.cant)",
+      default: false
+    },
+    workflows: {
+      type: "boolean",
+      /**
+       * @deprecated Use `cleo templates install --kind workflow` instead
+       * (T9886 / Saga T9855). Removal target: v2026.7.0. T9888.
+       */
+      description: "[DEPRECATED \u2014 use `cleo templates install --kind workflow`] Scaffold release workflows into .github/workflows/. Will be removed in v2026.7.0.",
+      default: false
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "With --workflows: print the rendered YAML without writing.",
+      default: false
+    },
+    "force-rebind": {
+      type: "boolean",
+      description: "Point the NEXUS registry at this checkout even though the project is registered at another path that still exists (T12470).",
+      default: false
+    },
+    here: {
+      type: "boolean",
+      description: "Initialize the current directory itself, even inside an ancestor CLEO project (T12562). A directory that is its own git root is targeted without it. At a directory a project was rerooted away from it requires --new-identity (T12558).",
+      default: false
+    },
+    "new-identity": {
+      type: "boolean",
+      description: "Mint a new project identity instead of re-linking a registered one (T12325). Never rewrites an existing .cleo/project-id \u2014 except with --here at a directory a project was rerooted away from, where that project's restored id is retired for the new one (T12558).",
+      default: false
+    }
+  },
+  async run({ args }) {
+    try {
+      if (args.workflows) {
+        pushWarning({
+          code: "W_INIT_WORKFLOWS_DEPRECATED",
+          message: "[deprecated] cleo init --workflows: use `cleo templates install --kind workflow` instead. This alias will be removed in v2026.7.0.",
+          severity: "warn",
+          deprecated: "cleo init --workflows",
+          replacement: "cleo templates install --kind workflow",
+          removeBy: "v2026.7.0",
+          context: { task: "T9888", saga: "T9855" }
+        });
+        const projectRoot = process.cwd();
+        const templatesDir = getWorkflowTemplatesDir();
+        const workflowEntries = getTemplatesByKind("workflow");
+        const templates = workflowEntries.map((entry) => entry.id).filter((id) => isWorkflowName(id));
+        const result2 = await scaffoldWorkflows({
+          projectRoot,
+          templatesDir,
+          ...templates.length > 0 ? { templates } : {},
+          dryRun: !!args["dry-run"],
+          force: !!args.force
+        });
+        cliOutput(
+          {
+            scaffolded: result2.outcomes.map((o) => ({
+              template: o.template,
+              targetPath: o.targetPath,
+              status: o.status
+            })),
+            resolvedTools: result2.resolvedTools,
+            ...args["dry-run"] ? { rendered: result2.outcomes.map((o) => o.rendered) } : {}
+          },
+          { command: "init" }
+        );
+        return;
+      }
+      const initOpts = {
+        name: args.name || args.projectName || void 0,
+        force: !!args.force,
+        detect: !!args.detect,
+        mapCodebase: !!args["map-codebase"],
+        installSeedAgents: !!args["install-seed-agents"],
+        newIdentity: !!args["new-identity"],
+        forceRebind: !!args["force-rebind"],
+        here: !!args.here
+      };
+      const result = await initProject(initOpts);
+      const nextSteps = [...result.nextSteps ?? []];
+      await maybeNudgeFirstRunLogin(nextSteps);
+      cliOutput(
+        {
+          initialized: result.initialized,
+          directory: result.directory,
+          created: result.created,
+          skipped: result.skipped,
+          ...result.warnings.length > 0 ? { warnings: result.warnings } : {},
+          ...result.updateDocsOnly ? { updateDocsOnly: true } : {},
+          // Phase 5 — greenfield/brownfield classification + LAFS nextSteps
+          ...result.classification ? { classification: result.classification } : {},
+          ...nextSteps.length > 0 ? { nextSteps } : {}
+        },
+        { command: "init" }
+      );
+    } catch (err) {
+      if (err instanceof CleoError) {
+        cliError(`init failed: ${err.message}`, err.code, {
+          name: initErrorCodeName(err) ?? err.toLAFSError().code,
+          ...err.fix !== void 0 ? { fix: err.fix } : {},
+          ...err.alternatives !== void 0 ? { alternatives: err.alternatives } : {},
+          ...err.details !== void 0 ? { details: err.details } : {}
+        });
+        process.exit(err.code);
+      }
+      throw err;
+    }
+  }
+});
+var FIRST_RUN_LOGIN_NEXT_STEP = {
+  action: "Add an LLM credential to start using CLEO",
+  command: "cleo login"
+};
+async function isCredentialPoolEmpty() {
+  try {
+    const pool = getCredentialPool();
+    const entries = await pool.list();
+    return entries.length === 0;
+  } catch {
+    return false;
+  }
+}
+async function maybeNudgeFirstRunLogin(nextSteps) {
+  if (!await isCredentialPoolEmpty()) return;
+  nextSteps.push({ ...FIRST_RUN_LOGIN_NEXT_STEP });
+  if (!isHumanOutput() || process.stdin.isTTY !== true) return;
+  try {
+    const io = new ReadlineWizardIO(process.stdin, process.stderr);
+    let configureNow;
+    try {
+      configureNow = await io.confirm("No LLM credential found. Configure now?", true);
+    } finally {
+      io.close();
+    }
+    if (!configureNow) return;
+    const result = await runLoginFrontDoor({});
+    let note;
+    if (result.validated) {
+      note = `  Logged in to ${result.provider} as '${result.accountLabel}' \u2014 bound ${result.profileName ?? "default"} \u2192 ${result.provider}/${result.modelId}.
+`;
+    } else {
+      const failed = result.steps.find((st) => st.status === "failed");
+      note = `  Login did not complete${failed?.detail ? `: ${failed.detail}` : "."} Run 'cleo login' to retry.
+`;
+    }
+    process.stderr.write(note);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const note = `  Login skipped (${msg}). Run 'cleo login' to retry.
+`;
+    process.stderr.write(note);
+  }
+}
+function isWorkflowName(id) {
+  return id === "release-prepare" || id === "release-publish" || id === "release-fanout" || id === "release-rollback";
+}
+
+export {
+  getGitignoreTemplate,
+  getWorkflowTemplatesDir,
+  initCommand,
+  FIRST_RUN_LOGIN_NEXT_STEP,
+  isCredentialPoolEmpty,
+  maybeNudgeFirstRunLogin
+};
+//# sourceMappingURL=chunk-OPTEQKBB.js.map