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

package/dist/cli/chunk-COXFJ3PT.js

@@ -0,0 +1,74 @@
+(() => {
+  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-heavy-command-hook.ts
+import { getProjectRoot } from "@cleocode/core/paths.js";
+import {
+  deliverHeavyCommandHooks,
+  heavyHookPresent,
+  inspectHeavyCommandHooks,
+  isHeavyHookProblem,
+  probeHeavyHookCliFor
+} from "@cleocode/core/resources/heavy-command-hook-delivery.js";
+var doctorHeavyCommandHookCommand = defineCommand({
+  meta: {
+    name: "heavy-command-hook",
+    description: "Report, per agent harness in use, whether the heavy-command hook (routes agent-run tests and builds through cleo run) is installed, outdated, missing or blocked. --fix installs it."
+  },
+  args: {
+    fix: {
+      type: "boolean",
+      description: "Install or refresh the hook in this project (project-level configs only, never user-global)"
+    },
+    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 outcomes = args.fix === true ? (await deliverHeavyCommandHooks(projectRoot)).outcomes : [];
+    const { mode, inspections } = await inspectHeavyCommandHooks(projectRoot);
+    const cli = mode !== "off" && heavyHookPresent(inspections) ? await probeHeavyHookCliFor(projectRoot) : null;
+    const problems = inspections.filter(isHeavyHookProblem);
+    const cliProblem = cli !== null && cli.state !== "current";
+    cliOutput(
+      {
+        projectRoot,
+        mode,
+        inspections,
+        cli,
+        fixApplied: args.fix === true,
+        outcomes,
+        healthy: problems.length === 0 && !cliProblem
+      },
+      { command: "doctor", operation: "doctor.heavy-command-hook.run" }
+    );
+    if ((problems.length > 0 || cliProblem) && (process.exitCode ?? 0) === 0) {
+      process.exitCode = 1;
+    }
+  }
+});
+
+export {
+  doctorHeavyCommandHookCommand
+};
+//# sourceMappingURL=chunk-COXFJ3PT.js.map

package/dist/cli/chunk-D7BAQNV2.js

@@ -0,0 +1,55 @@
+(() => {
+  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/dispatch/context/session-context.ts
+var _context = null;
+var GLOBAL_PEER_ID = "global";
+function resolveActivePeerId() {
+  const envPeerId = process.env["CLEO_AGENT_PEER_ID"] ?? process.env["CLEO_AGENT_ID"] ?? null;
+  if (envPeerId && envPeerId.trim().length > 0) {
+    return envPeerId.trim();
+  }
+  return GLOBAL_PEER_ID;
+}
+function bindSession(ctx) {
+  if (_context) {
+    throw new Error(
+      `Session already bound: ${_context.sessionId}. Call unbindSession() before binding a new session.`
+    );
+  }
+  _context = {
+    ...ctx,
+    agentPid: process.pid,
+    boundAt: (/* @__PURE__ */ new Date()).toISOString(),
+    activePeerId: ctx.activePeerId ?? resolveActivePeerId()
+  };
+  return _context;
+}
+function getBoundSession() {
+  return _context;
+}
+function unbindSession() {
+  const prev = _context;
+  _context = null;
+  return prev;
+}
+
+export {
+  bindSession,
+  getBoundSession,
+  unbindSession
+};
+//# sourceMappingURL=chunk-D7BAQNV2.js.map

package/dist/cli/chunk-EIUXVHNF.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-UWCZY52R.js";
+import {
+  ReadlineWizardIO
+} from "./chunk-GZFVDR44.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliError,
+  cliOutput,
+  isHumanOutput
+} from "./chunk-4RGSNUUP.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-EIUXVHNF.js.map

package/dist/cli/chunk-EUGB6P5V.js

@@ -0,0 +1,173 @@
+(() => {
+  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 {
+  negatedFlag
+} from "./chunk-47JYZAMS.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliError,
+  cliOutput,
+  humanLine
+} from "./chunk-4RGSNUUP.js";
+
+// packages/cleo/src/cli/commands/doctor-projects.ts
+import { checkAllRegisteredProjects } from "@cleocode/core/system/project-health";
+function formatRow(report, nameFallback) {
+  const hash = report.projectHash.padEnd(12).slice(0, 12);
+  const name = nameFallback.padEnd(24).slice(0, 24);
+  const path = report.projectPath.padEnd(40).slice(0, 40);
+  const status = report.overall.padEnd(12).slice(0, 12);
+  const issues = report.issues.join("; ").slice(0, 80);
+  return `${hash}  ${name}  ${path}  ${status}  ${issues}`;
+}
+function deriveExitCode(summary, ignoreUnreachable) {
+  if (summary.unreachable > 0 && !ignoreUnreachable) return 2;
+  if (summary.degraded > 0) return 1;
+  return 0;
+}
+function printDoctorProjectsReport(report, opts, nameLookup) {
+  if (report.registryError) {
+    const { registryError } = report;
+    cliError(
+      registryError.message,
+      registryError.exitCode,
+      { name: registryError.code, fix: registryError.fix, details: { report } },
+      { operation: "doctor.projects" }
+    );
+    process.exitCode = registryError.exitCode;
+    return;
+  }
+  const { summary } = report;
+  const exitCode = deriveExitCode(summary, opts.ignoreUnreachable === true);
+  process.exitCode = exitCode;
+  if (opts.json === true || opts.quiet === true) {
+    cliOutput(
+      opts.quiet ? {
+        projects: summary.totalProjects,
+        healthy: summary.healthy,
+        degraded: summary.degraded,
+        unreachable: summary.unreachable,
+        unknown: summary.unknown,
+        global: report.global.overall
+      } : report,
+      { command: "doctor-projects", operation: "doctor.projects" }
+    );
+    return;
+  }
+  humanLine("\nCLEO Cross-Project Health Report");
+  humanLine(`Generated: ${report.generatedAt}
+`);
+  humanLine(`Global: ${report.global.overall.toUpperCase()} (${report.global.cleoHome})`);
+  if (report.global.issues.length > 0) {
+    for (const iss of report.global.issues) {
+      humanLine(`  - ${iss}`);
+    }
+  }
+  humanLine("");
+  if (report.projects.length === 0) {
+    humanLine("No projects registered in nexus.db.");
+    humanLine("Register projects with: cleo nexus register <path>\n");
+    return;
+  }
+  const header = `${"hash".padEnd(12)}  ${"name".padEnd(24)}  ${"path".padEnd(40)}  ${"status".padEnd(12)}  issues`;
+  humanLine(header);
+  humanLine("-".repeat(header.length));
+  for (const project of report.projects) {
+    const name = nameLookup.get(project.projectHash) ?? "<unnamed>";
+    humanLine(formatRow(project, name));
+  }
+  humanLine("");
+  humanLine(
+    `Summary: ${summary.totalProjects} project(s) \u2014 ${summary.healthy} healthy, ${summary.degraded} degraded, ${summary.unreachable} unreachable, ${summary.unknown} unknown
+`
+  );
+}
+async function runDoctorProjects(opts = {}) {
+  const report = await checkAllRegisteredProjects({
+    updateRegistry: opts.noUpdateRegistry !== true,
+    parallelism: opts.parallelism,
+    includeGlobal: opts.skipGlobal !== true
+  });
+  const nameLookup = /* @__PURE__ */ new Map();
+  if (!report.registryError) {
+    try {
+      const { nexusList } = await import("@cleocode/core/nexus/registry");
+      const rows = await nexusList();
+      for (const row of rows) {
+        nameLookup.set(row.hash, row.name);
+      }
+    } catch {
+    }
+  }
+  printDoctorProjectsReport(report, opts, nameLookup);
+  return report;
+}
+var doctorProjectsCommand = defineCommand({
+  meta: {
+    name: "doctor-projects",
+    description: "Probe every registered project (nexus.db) for DB + config health"
+  },
+  args: {
+    json: {
+      type: "boolean",
+      description: "Emit machine-readable JSON report"
+    },
+    quiet: {
+      type: "boolean",
+      description: "Emit a one-line summary only"
+    },
+    "ignore-unreachable": {
+      type: "boolean",
+      description: "Exit 1 instead of 2 when a project is unreachable"
+    },
+    parallelism: {
+      type: "string",
+      description: "Probe concurrency cap (default: 8)"
+    },
+    "no-update-registry": {
+      type: "boolean",
+      description: "Do not write healthStatus back to nexus.db"
+    },
+    "skip-global": {
+      type: "boolean",
+      description: "Skip the global-tier (nexus.db, signaldock.db) probe"
+    },
+    human: {
+      type: "boolean",
+      description: "Force human-readable output"
+    }
+  },
+  async run({ args }) {
+    const parallelism = args.parallelism ? Number.parseInt(String(args.parallelism), 10) : void 0;
+    await runDoctorProjects({
+      json: args.json === true,
+      quiet: args.quiet === true,
+      ignoreUnreachable: args["ignore-unreachable"] === true,
+      parallelism: typeof parallelism === "number" && Number.isFinite(parallelism) ? parallelism : void 0,
+      noUpdateRegistry: negatedFlag(args, "update-registry"),
+      skipGlobal: args["skip-global"] === true
+    });
+  }
+});
+
+export {
+  printDoctorProjectsReport,
+  runDoctorProjects,
+  doctorProjectsCommand
+};
+//# sourceMappingURL=chunk-EUGB6P5V.js.map