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

package/dist/cli/init-AN4DZ2XO.js

@@ -0,0 +1,40 @@
+(() => {
+  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 {
+  FIRST_RUN_LOGIN_NEXT_STEP,
+  getGitignoreTemplate,
+  getWorkflowTemplatesDir,
+  initCommand,
+  isCredentialPoolEmpty,
+  maybeNudgeFirstRunLogin
+} from "./chunk-EIUXVHNF.js";
+import "./chunk-UWCZY52R.js";
+import "./chunk-GZFVDR44.js";
+import "./chunk-GRU74UE4.js";
+import "./chunk-47JYZAMS.js";
+import "./chunk-C3B7C43W.js";
+import "./chunk-PKKZPOOP.js";
+import "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+export {
+  FIRST_RUN_LOGIN_NEXT_STEP,
+  getGitignoreTemplate,
+  getWorkflowTemplatesDir,
+  initCommand,
+  isCredentialPoolEmpty,
+  maybeNudgeFirstRunLogin
+};
+//# sourceMappingURL=init-AN4DZ2XO.js.map

package/dist/cli/inject-HQWA5GWY.js

@@ -0,0 +1,83 @@
+(() => {
+  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 {
+  dispatchFromCli
+} from "./chunk-L7ONYSV6.js";
+import "./chunk-6N6WGLXE.js";
+import "./chunk-4VASFLUW.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import "./chunk-QKMBWYAS.js";
+import "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-D7BAQNV2.js";
+import "./chunk-TYC7G5LF.js";
+
+// packages/cleo/src/cli/commands/inject.ts
+var injectCommand = defineCommand({
+  meta: { name: "inject", description: "Prepare tasks for external system injection" },
+  args: {
+    "max-tasks": {
+      type: "string",
+      description: "Maximum tasks to inject",
+      default: "8"
+    },
+    "focused-only": {
+      type: "boolean",
+      description: "Only inject the focused task",
+      default: false
+    },
+    phase: {
+      type: "string",
+      description: "Filter tasks to specific phase"
+    },
+    output: {
+      type: "string",
+      description: "Write to file instead of stdout"
+    },
+    "save-state": {
+      type: "boolean",
+      description: "Save session state for extraction",
+      default: true
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview without writing",
+      default: false
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "admin",
+      "inject.generate",
+      {
+        maxTasks: Number.parseInt(args["max-tasks"], 10),
+        focusedOnly: args["focused-only"],
+        phase: args.phase,
+        output: args.output,
+        saveState: args["save-state"],
+        dryRun: args["dry-run"]
+      },
+      { command: "inject" }
+    );
+  }
+});
+export {
+  injectCommand
+};
+//# sourceMappingURL=inject-HQWA5GWY.js.map

package/dist/cli/install-global-YQV4W5OG.js

@@ -0,0 +1,95 @@
+(() => {
+  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,
+  humanLine
+} from "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/install-global.ts
+import { bootstrapGlobalCleo } from "@cleocode/core/internal";
+function renderBootstrapHuman(ctx, dryRun) {
+  if (dryRun) {
+    humanLine("Dry-run mode \u2014 no changes will be made.\n");
+  }
+  if (ctx.created.length > 0) {
+    humanLine(`${dryRun ? "Would create/update" : "Created/updated"}:`);
+    for (const item of ctx.created) {
+      humanLine(`  + ${item}`);
+    }
+    humanLine("");
+  } else {
+    humanLine("No changes needed \u2014 everything is already up to date.\n");
+  }
+  if (ctx.warnings.length > 0) {
+    humanLine("Warnings:");
+    for (const w of ctx.warnings) {
+      humanLine(`  ! ${w}`);
+    }
+    humanLine("");
+  }
+}
+var installGlobalCommand = defineCommand({
+  meta: {
+    name: "install-global",
+    description: "Run the global bootstrap manually (install templates, ~/.cleo symlink, agents, skills). Same as npm postinstall."
+  },
+  args: {
+    "dry-run": {
+      type: "boolean",
+      description: "Preview changes without applying them"
+    },
+    // 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 dryRun = args["dry-run"] === true;
+    const isHuman = args.human === true || !!process.stdout.isTTY && args.json !== true;
+    const ctx = await bootstrapGlobalCleo({ dryRun });
+    if (isHuman && args.quiet !== true) {
+      renderBootstrapHuman(ctx, dryRun);
+    }
+    cliOutput(
+      {
+        dryRun,
+        created: ctx.created,
+        warnings: ctx.warnings
+      },
+      {
+        command: "install-global",
+        message: dryRun ? `Dry-run complete \u2014 ${ctx.created.length} action(s) would be applied` : `Bootstrap complete \u2014 ${ctx.created.length} action(s) applied, ${ctx.warnings.length} warning(s)`
+      }
+    );
+  }
+});
+export {
+  installGlobalCommand
+};
+//# sourceMappingURL=install-global-YQV4W5OG.js.map

package/dist/cli/intelligence-OFFNQGHE.js

@@ -0,0 +1,238 @@
+(() => {
+  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 {
+  errorResult,
+  handleErrorResult,
+  unsupportedOp,
+  wrapResult
+} from "./chunk-XHRZ7OYZ.js";
+
+// packages/cleo/src/dispatch/domains/intelligence.ts
+import { getLogger, getProjectRoot, getTaskAccessor } from "@cleocode/core";
+import {
+  calculateTaskRisk,
+  extractPatternsFromHistory,
+  getBrainAccessor,
+  matchPatterns,
+  predictValidationOutcome,
+  scoreVerificationConfidence,
+  suggestGateFocus
+} from "@cleocode/core/internal";
+var IntelligenceHandler = class {
+  // -----------------------------------------------------------------------
+  // Query
+  // -----------------------------------------------------------------------
+  async query(operation, params) {
+    const projectRoot = getProjectRoot();
+    const startTime = Date.now();
+    try {
+      switch (operation) {
+        // ------------------------------------------------------------------
+        // predict — calculateTaskRisk or predictValidationOutcome
+        // ------------------------------------------------------------------
+        case "predict": {
+          const taskId = params?.taskId;
+          if (!taskId) {
+            return errorResult(
+              "query",
+              "intelligence",
+              operation,
+              "E_INVALID_INPUT",
+              "taskId is required",
+              startTime
+            );
+          }
+          const [accessor, brain] = await Promise.all([
+            getTaskAccessor(projectRoot),
+            getBrainAccessor(projectRoot)
+          ]);
+          const stage = params?.stage;
+          if (stage) {
+            const result2 = await predictValidationOutcome(taskId, stage, accessor, brain);
+            return wrapResult(
+              { success: true, data: result2 },
+              "query",
+              "intelligence",
+              operation,
+              startTime
+            );
+          }
+          const result = await calculateTaskRisk(taskId, accessor, brain);
+          return wrapResult(
+            { success: true, data: result },
+            "query",
+            "intelligence",
+            operation,
+            startTime
+          );
+        }
+        // ------------------------------------------------------------------
+        // suggest — suggestGateFocus
+        // ------------------------------------------------------------------
+        case "suggest": {
+          const taskId = params?.taskId;
+          if (!taskId) {
+            return errorResult(
+              "query",
+              "intelligence",
+              operation,
+              "E_INVALID_INPUT",
+              "taskId is required",
+              startTime
+            );
+          }
+          const [accessor, brain] = await Promise.all([
+            getTaskAccessor(projectRoot),
+            getBrainAccessor(projectRoot)
+          ]);
+          const result = await suggestGateFocus(taskId, accessor, brain);
+          return wrapResult(
+            { success: true, data: result },
+            "query",
+            "intelligence",
+            operation,
+            startTime
+          );
+        }
+        // ------------------------------------------------------------------
+        // learn-errors — extractPatternsFromHistory
+        // ------------------------------------------------------------------
+        case "learn-errors": {
+          const [accessor, brain] = await Promise.all([
+            getTaskAccessor(projectRoot),
+            getBrainAccessor(projectRoot)
+          ]);
+          const limit = typeof params?.limit === "number" ? params.limit : void 0;
+          const result = await extractPatternsFromHistory(accessor, brain, { limit });
+          return wrapResult(
+            { success: true, data: result },
+            "query",
+            "intelligence",
+            operation,
+            startTime
+          );
+        }
+        // ------------------------------------------------------------------
+        // confidence — scoreVerificationConfidence
+        // ------------------------------------------------------------------
+        case "confidence": {
+          const taskId = params?.taskId;
+          if (!taskId) {
+            return errorResult(
+              "query",
+              "intelligence",
+              operation,
+              "E_INVALID_INPUT",
+              "taskId is required",
+              startTime
+            );
+          }
+          const [accessor, brain] = await Promise.all([
+            getTaskAccessor(projectRoot),
+            getBrainAccessor(projectRoot)
+          ]);
+          const task = await accessor.loadSingleTask(taskId);
+          if (!task) {
+            return errorResult(
+              "query",
+              "intelligence",
+              operation,
+              "E_NOT_FOUND",
+              `Task ${taskId} not found`,
+              startTime
+            );
+          }
+          const verification = task.verification ?? {
+            passed: false,
+            round: 1,
+            gates: {},
+            lastAgent: null,
+            lastUpdated: null,
+            failureLog: [],
+            checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          const result = await scoreVerificationConfidence(taskId, verification, accessor, brain, {
+            dryRun: true
+          });
+          return wrapResult(
+            { success: true, data: result },
+            "query",
+            "intelligence",
+            operation,
+            startTime
+          );
+        }
+        // ------------------------------------------------------------------
+        // match — matchPatterns
+        // ------------------------------------------------------------------
+        case "match": {
+          const taskId = params?.taskId;
+          if (!taskId) {
+            return errorResult(
+              "query",
+              "intelligence",
+              operation,
+              "E_INVALID_INPUT",
+              "taskId is required",
+              startTime
+            );
+          }
+          const [accessor, brain] = await Promise.all([
+            getTaskAccessor(projectRoot),
+            getBrainAccessor(projectRoot)
+          ]);
+          const result = await matchPatterns(taskId, accessor, brain);
+          return wrapResult(
+            { success: true, data: result },
+            "query",
+            "intelligence",
+            operation,
+            startTime
+          );
+        }
+        default:
+          return unsupportedOp("query", "intelligence", operation, startTime);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      getLogger("domain:intelligence").error(
+        { gateway: "query", domain: "intelligence", operation, err: error },
+        message
+      );
+      return handleErrorResult("query", "intelligence", operation, error, startTime);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Mutate — not supported; intelligence is read-only at the domain level
+  // -----------------------------------------------------------------------
+  async mutate(operation, _params) {
+    const startTime = Date.now();
+    return unsupportedOp("mutate", "intelligence", operation, startTime);
+  }
+  // -----------------------------------------------------------------------
+  // Supported operations
+  // -----------------------------------------------------------------------
+  getSupportedOperations() {
+    return {
+      query: ["predict", "suggest", "learn-errors", "confidence", "match"],
+      mutate: []
+    };
+  }
+};
+export {
+  IntelligenceHandler
+};
+//# sourceMappingURL=intelligence-OFFNQGHE.js.map

package/dist/cli/intelligence-QIC4SN4X.js

@@ -0,0 +1,182 @@
+(() => {
+  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 {
+  dispatchFromCli
+} from "./chunk-L7ONYSV6.js";
+import "./chunk-6N6WGLXE.js";
+import "./chunk-4VASFLUW.js";
+import {
+  defineCommand,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+import "./chunk-QKMBWYAS.js";
+import "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-D7BAQNV2.js";
+import "./chunk-TYC7G5LF.js";
+
+// packages/cleo/src/cli/commands/intelligence.ts
+var predictCommand = defineCommand({
+  meta: {
+    name: "predict",
+    description: "Calculate risk score for a task, or predict validation outcome for a stage"
+  },
+  args: {
+    task: {
+      type: "string",
+      description: "Task ID to assess",
+      required: true
+    },
+    stage: {
+      type: "string",
+      description: "Lifecycle stage for validation outcome prediction"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON",
+      default: false
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "intelligence",
+      "predict",
+      { taskId: args.task, stage: args.stage },
+      { command: "intelligence", operation: "intelligence.predict" }
+    );
+  }
+});
+var suggestCommand = defineCommand({
+  meta: { name: "suggest", description: "Suggest verification gate focus for a task" },
+  args: {
+    task: {
+      type: "string",
+      description: "Task ID to analyze",
+      required: true
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON",
+      default: false
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "intelligence",
+      "suggest",
+      { taskId: args.task },
+      { command: "intelligence", operation: "intelligence.suggest" }
+    );
+  }
+});
+var learnErrorsCommand = defineCommand({
+  meta: {
+    name: "learn-errors",
+    description: "Extract recurring failure patterns from task and brain history"
+  },
+  args: {
+    limit: {
+      type: "string",
+      description: "Maximum number of patterns to return"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON",
+      default: false
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "intelligence",
+      "learn-errors",
+      { limit: args.limit !== void 0 ? Number.parseInt(args.limit, 10) : void 0 },
+      { command: "intelligence", operation: "intelligence.learn-errors" }
+    );
+  }
+});
+var confidenceCommand = defineCommand({
+  meta: {
+    name: "confidence",
+    description: "Score verification confidence for a task based on its current gate state"
+  },
+  args: {
+    task: {
+      type: "string",
+      description: "Task ID to score",
+      required: true
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON",
+      default: false
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "intelligence",
+      "confidence",
+      { taskId: args.task },
+      { command: "intelligence", operation: "intelligence.confidence" }
+    );
+  }
+});
+var matchCommand = defineCommand({
+  meta: { name: "match", description: "Match known brain patterns against a task" },
+  args: {
+    task: {
+      type: "string",
+      description: "Task ID to match",
+      required: true
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON",
+      default: false
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "intelligence",
+      "match",
+      { taskId: args.task },
+      { command: "intelligence", operation: "intelligence.match" }
+    );
+  }
+});
+var intelligenceCommand = defineCommand({
+  meta: { name: "intelligence", description: "Predictive intelligence and quality analysis" },
+  subCommands: {
+    predict: predictCommand,
+    suggest: suggestCommand,
+    "learn-errors": learnErrorsCommand,
+    confidence: confidenceCommand,
+    match: matchCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  intelligenceCommand
+};
+//# sourceMappingURL=intelligence-QIC4SN4X.js.map