@cleocode/cleo 2026.4.16 → 2026.4.18

package/dist/cli/index.js

@@ -75307,6 +75307,7 @@ __export(src_exports, {
 });
 var init_src2 = __esm({
   "packages/core/src/index.ts"() {
+    "use strict";
     init_src();
     init_adapters();
     init_admin();
@@ -100331,7 +100332,7 @@ var init_normalizer = __esm({
 });
 
 // packages/cleo/src/cli/renderers/colors.ts
-function ansi(code) {
+function ansi2(code) {
   return colorsEnabled ? code : "";
 }
 function statusSymbol(status) {
@@ -100424,15 +100425,15 @@ var init_colors = __esm({
       if (lang === "C" || lang === "POSIX") return false;
       return lang.includes("UTF") || process.platform === "darwin";
     })();
-    BOLD = ansi("\x1B[1m");
-    DIM = ansi("\x1B[2m");
-    NC = ansi("\x1B[0m");
-    RED = ansi("\x1B[0;31m");
-    GREEN = ansi("\x1B[0;32m");
-    YELLOW = ansi("\x1B[1;33m");
-    BLUE = ansi("\x1B[0;34m");
-    MAGENTA = ansi("\x1B[0;35m");
-    CYAN = ansi("\x1B[0;36m");
+    BOLD = ansi2("\x1B[1m");
+    DIM = ansi2("\x1B[2m");
+    NC = ansi2("\x1B[0m");
+    RED = ansi2("\x1B[0;31m");
+    GREEN = ansi2("\x1B[0;32m");
+    YELLOW = ansi2("\x1B[1;33m");
+    BLUE = ansi2("\x1B[0;34m");
+    MAGENTA = ansi2("\x1B[0;35m");
+    CYAN = ansi2("\x1B[0;36m");
     BOX = unicodeEnabled ? {
       tl: "\u256D",
       tr: "\u256E",
@@ -111598,8 +111599,29 @@ async function orchestrateFanout(items, projectRoot) {
   try {
     const settled = await Promise.allSettled(
       items.map(async (item) => {
-        void projectRoot;
-        return { taskId: item.taskId, status: "queued" };
+        const spawnResult = await orchestrateSpawnExecute(
+          item.taskId,
+          /* adapterId */
+          void 0,
+          /* protocolType */
+          void 0,
+          projectRoot,
+          /* tier */
+          void 0
+        );
+        if (!spawnResult.success) {
+          return {
+            taskId: item.taskId,
+            status: "failed",
+            error: spawnResult.error?.message ?? `Spawn failed for task ${item.taskId}`
+          };
+        }
+        const data = spawnResult.data;
+        return {
+          taskId: item.taskId,
+          status: "spawned",
+          instanceId: typeof data?.instanceId === "string" ? data.instanceId : void 0
+        };
       })
     );
     const results = settled.map((outcome, i) => {
@@ -111612,15 +111634,18 @@ async function orchestrateFanout(items, projectRoot) {
         error: outcome.reason instanceof Error ? outcome.reason.message : String(outcome.reason)
       };
     });
+    fanoutManifestStore.set(manifestEntryId, {
+      results,
+      completedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
     return {
       success: true,
       data: {
         manifestEntryId,
         results,
         total: items.length,
-        queued: results.filter((r) => r.status === "queued").length,
-        failed: results.filter((r) => r.status === "failed").length,
-        note: "fanout spawn execution is a W7b stub \u2014 real Pi adapter wiring lands with runtime enforcement"
+        spawned: results.filter((r) => r.status === "spawned").length,
+        failed: results.filter((r) => r.status === "failed").length
       }
     };
   } catch (error48) {
@@ -111714,7 +111739,7 @@ async function orchestrateAnalyzeParallelSafety(taskIds, projectRoot) {
     };
   }
 }
-var OrchestrateHandler;
+var OrchestrateHandler, fanoutManifestStore;
 var init_orchestrate2 = __esm({
   "packages/cleo/src/dispatch/domains/orchestrate.ts"() {
     "use strict";
@@ -111806,16 +111831,34 @@ var init_orchestrate2 = __esm({
                   startTime
                 );
               }
+              const entry = fanoutManifestStore.get(manifestEntryId);
+              if (!entry) {
+                return {
+                  meta: dispatchMeta("query", "orchestrate", operation, startTime),
+                  success: true,
+                  data: {
+                    manifestEntryId,
+                    pending: [],
+                    running: [],
+                    complete: [],
+                    failed: [],
+                    found: false
+                  }
+                };
+              }
+              const spawned = entry.results.filter((r) => r.status === "spawned").map((r) => r.taskId);
+              const failed = entry.results.filter((r) => r.status === "failed").map((r) => r.taskId);
               return {
                 meta: dispatchMeta("query", "orchestrate", operation, startTime),
                 success: true,
                 data: {
                   manifestEntryId,
                   pending: [],
-                  running: [],
+                  running: spawned,
                   complete: [],
-                  failed: [],
-                  note: "fanout.status tracking is a W7b stub \u2014 live tracking lands with runtime enforcement"
+                  failed,
+                  found: true,
+                  completedAt: entry.completedAt
                 }
               };
             }
@@ -112180,6 +112223,7 @@ var init_orchestrate2 = __esm({
         };
       }
     };
+    fanoutManifestStore = /* @__PURE__ */ new Map();
   }
 });
 
@@ -116097,11 +116141,11 @@ var CLIError = class extends Error {
 function parseRawArgs(args = [], opts = {}) {
   const booleans = new Set(opts.boolean || []);
   const strings = new Set(opts.string || []);
-  const aliasMap = opts.alias || {};
+  const aliasMap2 = opts.alias || {};
   const defaults = opts.default || {};
   const aliasToMain = /* @__PURE__ */ new Map();
   const mainToAliases = /* @__PURE__ */ new Map();
-  for (const [key, value] of Object.entries(aliasMap)) {
+  for (const [key, value] of Object.entries(aliasMap2)) {
     const targets = value;
     for (const target of targets) {
       aliasToMain.set(key, target);
@@ -116122,8 +116166,8 @@ function parseRawArgs(args = [], opts = {}) {
   const allOptions = /* @__PURE__ */ new Set([
     ...booleans,
     ...strings,
-    ...Object.keys(aliasMap),
-    ...Object.values(aliasMap).flat(),
+    ...Object.keys(aliasMap2),
+    ...Object.values(aliasMap2).flat(),
     ...Object.keys(defaults)
   ]);
   for (const name2 of allOptions) if (!options[name2]) options[name2] = {
@@ -116539,6 +116583,237 @@ function camelToKebab2(str) {
 init_field_context();
 init_format_context();
 
+// packages/cleo/src/cli/help-renderer.ts
+var noColor2 = (() => {
+  const env = globalThis.process?.env ?? {};
+  return env.NO_COLOR === "1" || env.TERM === "dumb" || env.TEST || env.CI;
+})();
+var ansi = (code, reset = 39) => (t) => noColor2 ? t : `\x1B[${code}m${t}\x1B[${reset}m`;
+var bold2 = ansi(1, 22);
+var cyan2 = ansi(36);
+var gray2 = ansi(90);
+var underline2 = ansi(4, 24);
+var IMPLICIT_ALIASES = {
+  tags: "labels"
+};
+var NATIVE_COMMAND_DESCS = {
+  version: "Display CLEO version",
+  code: "Code analysis via tree-sitter AST"
+};
+var COMMAND_GROUPS = [
+  {
+    name: "Task Management",
+    commands: [
+      "add",
+      "show",
+      "find",
+      "list",
+      "update",
+      "complete",
+      "delete",
+      "start",
+      "stop",
+      "current",
+      "next",
+      "exists",
+      "bug"
+    ]
+  },
+  {
+    name: "Task Organization",
+    commands: [
+      "archive",
+      "labels",
+      "promote",
+      "relates",
+      "reorder",
+      "reparent",
+      "deps",
+      "tree",
+      "blockers"
+    ]
+  },
+  {
+    name: "Sessions & Planning",
+    commands: ["session", "briefing", "dash", "plan", "safestop", "context"]
+  },
+  {
+    name: "Phases & Lifecycle",
+    commands: ["phase", "phases", "lifecycle", "release", "roadmap"]
+  },
+  {
+    name: "Memory & Notes",
+    commands: ["memory", "brain", "observe", "refresh-memory", "sticky", "reason"]
+  },
+  {
+    name: "Analysis & Stats",
+    commands: ["analyze", "stats", "history", "archive-stats"]
+  },
+  {
+    name: "Validation & Compliance",
+    commands: [
+      "check",
+      "validate",
+      "verify",
+      "testing",
+      "compliance",
+      "implementation",
+      "specification",
+      "consensus",
+      "contribution",
+      "decomposition",
+      "backfill"
+    ]
+  },
+  {
+    name: "Code & Documentation",
+    commands: ["code", "docs", "detect-drift", "map"]
+  },
+  {
+    name: "Research & Orchestration",
+    commands: ["research", "orchestrate"]
+  },
+  {
+    name: "Import / Export",
+    commands: ["export", "import", "export-tasks", "import-tasks", "snapshot", "inject"]
+  },
+  {
+    name: "Collaboration",
+    commands: ["nexus", "remote", "push", "pull", "checkpoint"]
+  },
+  {
+    name: "Agents",
+    commands: ["agent", "grade"]
+  },
+  {
+    name: "System & Admin",
+    commands: [
+      "version",
+      "init",
+      "config",
+      "env",
+      "admin",
+      "doctor",
+      "upgrade",
+      "self-update",
+      "commands",
+      "ops",
+      "schema",
+      "log",
+      "sequence",
+      "adr",
+      "cant",
+      "token",
+      "otel",
+      "migrate",
+      "detect",
+      "generate-changelog",
+      "issue",
+      "skills",
+      "web",
+      "backup",
+      "restore"
+    ]
+  }
+];
+function buildAliasMap(shims) {
+  const map2 = /* @__PURE__ */ new Map();
+  for (const shim of shims) {
+    for (const alias of shim._aliases) {
+      map2.set(alias, shim._name);
+    }
+  }
+  for (const [alias, primary] of Object.entries(IMPLICIT_ALIASES)) {
+    map2.set(alias, primary);
+  }
+  return map2;
+}
+function getShortDescription(desc7) {
+  if (!desc7) return "";
+  const match = desc7.match(/^Description:\s*(.+)/);
+  if (match) return match[1].trim();
+  const firstLine = desc7.split("\n").find((l) => l.trim().length > 0);
+  return firstLine?.trim() ?? desc7.trim();
+}
+function renderGroupedHelp(version2, shims, aliasMap2) {
+  const descMap = /* @__PURE__ */ new Map();
+  for (const shim of shims) {
+    descMap.set(shim._name, getShortDescription(shim._description));
+  }
+  for (const [name2, desc7] of Object.entries(NATIVE_COMMAND_DESCS)) {
+    if (!descMap.has(name2)) {
+      descMap.set(name2, desc7);
+    }
+  }
+  const cmdAliases = /* @__PURE__ */ new Map();
+  for (const [alias, primary] of aliasMap2) {
+    const existing = cmdAliases.get(primary) ?? [];
+    existing.push(alias);
+    cmdAliases.set(primary, existing);
+  }
+  let maxCmdWidth = 0;
+  const allGroupedCmds = COMMAND_GROUPS.flatMap((g2) => g2.commands);
+  const allCmds = [.../* @__PURE__ */ new Set([...allGroupedCmds, ...shims.map((s3) => s3._name), "version"])];
+  for (const cmd of allCmds) {
+    if (!descMap.has(cmd) || aliasMap2.has(cmd)) continue;
+    const aliases = cmdAliases.get(cmd);
+    const display = aliases && aliases.length > 0 ? `${cmd} (${aliases.join(", ")})` : cmd;
+    if (display.length > maxCmdWidth) maxCmdWidth = display.length;
+  }
+  const lines = [];
+  lines.push(gray2(`CLEO V2 - Task management for AI coding agents (cleo v${version2})`));
+  lines.push("");
+  lines.push(`${underline2(bold2("USAGE"))} ${cyan2("cleo <command> [OPTIONS]")}`);
+  lines.push("");
+  const rendered = /* @__PURE__ */ new Set();
+  for (const group of COMMAND_GROUPS) {
+    const groupLines = [];
+    for (const cmd of group.commands) {
+      if (!descMap.has(cmd)) continue;
+      rendered.add(cmd);
+      const aliases = cmdAliases.get(cmd);
+      const display = aliases && aliases.length > 0 ? `${cmd} (${aliases.join(", ")})` : cmd;
+      const desc7 = descMap.get(cmd) ?? "";
+      groupLines.push(`  ${cyan2(display.padEnd(maxCmdWidth + 2))}${desc7}`);
+    }
+    if (groupLines.length > 0) {
+      lines.push(underline2(bold2(group.name.toUpperCase())));
+      lines.push(...groupLines);
+      lines.push("");
+    }
+  }
+  const ungrouped = [];
+  for (const shim of shims) {
+    if (!rendered.has(shim._name) && !aliasMap2.has(shim._name)) {
+      ungrouped.push(shim._name);
+    }
+  }
+  if (ungrouped.length > 0) {
+    lines.push(underline2(bold2("OTHER")));
+    for (const cmd of ungrouped) {
+      const aliases = cmdAliases.get(cmd);
+      const display = aliases && aliases.length > 0 ? `${cmd} (${aliases.join(", ")})` : cmd;
+      const desc7 = descMap.get(cmd) ?? "";
+      lines.push(`  ${cyan2(display.padEnd(maxCmdWidth + 2))}${desc7}`);
+    }
+    lines.push("");
+  }
+  lines.push(`Use ${cyan2("cleo <command> --help")} for more information about a command.`);
+  return lines.join("\n");
+}
+function createCustomShowUsage(version2, shims, aliasMap2) {
+  return async (cmd, parent) => {
+    if (!parent) {
+      const meta3 = await (typeof cmd.meta === "function" ? cmd.meta() : cmd.meta);
+      if (meta3?.name === "cleo") {
+        console.log(renderGroupedHelp(version2, shims, aliasMap2) + "\n");
+        return;
+      }
+    }
+    await showUsage(cmd, parent);
+  };
+}
+
 // packages/cleo/src/cli/middleware/output-format.ts
 import { resolveOutputFormat } from "@cleocode/lafs";
 function resolveFormat2(opts, defaults) {
@@ -125287,5 +125562,7 @@ var main = defineCommand({
   },
   subCommands
 });
-runMain(main);
+var aliasMap = buildAliasMap(rootShim._subcommands);
+var customShowUsage = createCustomShowUsage(CLI_VERSION, rootShim._subcommands, aliasMap);
+runMain(main, { showUsage: customShowUsage });
 //# sourceMappingURL=index.js.map