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

package/dist/cli/deps-UTPZJBXL.js

@@ -0,0 +1,462 @@
+(() => {
+  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 {
+  DIM,
+  NC
+} from "./chunk-VB3LDPL5.js";
+import {
+  createAnimateContext,
+  dispatchFromCli,
+  renderLegend,
+  renderSummary,
+  renderTree
+} from "./chunk-L7ONYSV6.js";
+import "./chunk-6N6WGLXE.js";
+import "./chunk-4VASFLUW.js";
+import {
+  defineCommand,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+import "./chunk-QKMBWYAS.js";
+import {
+  cliError,
+  cliOutput
+} from "./chunk-4RGSNUUP.js";
+import {
+  getFormatContext,
+  isJsonFormat,
+  isQuiet
+} from "./chunk-6JSJNYH2.js";
+import "./chunk-D7BAQNV2.js";
+import "./chunk-TYC7G5LF.js";
+
+// packages/cleo/src/cli/commands/deps.ts
+import { ExitCode } from "@cleocode/contracts/exit-codes.js";
+import { getCriticalPath as depsCriticalPath } from "@cleocode/core/phases/deps";
+import { resolveProjectRoot } from "@cleocode/core/store/file-utils";
+import { buildGenericTaskTree } from "@cleocode/core/tasks/generic-tree";
+
+// packages/cleo/src/cli/renderers/generic-tree.ts
+import {
+  ascii,
+  KindIcon,
+  pickIcon,
+  RelationIcon,
+  StatusIcon
+} from "@cleocode/contracts/render/icon.js";
+function renderGenericTree(result, opts) {
+  const explicitCtx = opts.ctx !== void 0;
+  const ctx = opts.ctx ?? resolveAnimateContext();
+  if (!ctx.enabled) return "";
+  if (opts.quiet) return renderQuiet(result);
+  const useAscii = explicitCtx ? ctx.inputs.noColor : ctx.inputs.noColor || process.env["NO_COLOR"] != null;
+  const lines = [];
+  if (result.ancestors.length > 0) {
+    lines.push(formatAncestorBanner(result.ancestors, useAscii));
+    lines.push("");
+  }
+  const treeWithGlyphs = decorateGroupsEdges(result.tree, useAscii);
+  const body = renderTree(treeWithGlyphs, { ctx, asciiBoxDrawing: useAscii });
+  if (body) lines.push(body);
+  if (opts.withDeps || opts.withBlockers) {
+    const annotations = renderAnnotations(result.tree, opts);
+    if (annotations) lines.push(annotations);
+  }
+  const footer = renderFooterLegend(result, ctx, useAscii);
+  if (footer) {
+    lines.push("");
+    lines.push(footer);
+  }
+  return lines.join("\n");
+}
+function renderFooterLegend(result, ctx, useAscii) {
+  if (!ctx.enabled) return "";
+  const kindsSeen = /* @__PURE__ */ new Set();
+  const statusesSeen = /* @__PURE__ */ new Set();
+  let hasGroupsEdge = false;
+  for (const node of result.tree.tree) {
+    kindsSeen.add(node.kind);
+    statusesSeen.add(node.status);
+    if (node.metadata.edgeType === "groups") hasGroupsEdge = true;
+  }
+  const items = [];
+  const KIND_ORDER = [
+    ["saga", "saga"],
+    ["epic", "epic"],
+    ["task", "task"],
+    ["subtask", "subtask"]
+  ];
+  for (const [kind, label] of KIND_ORDER) {
+    if (!kindsSeen.has(kind)) continue;
+    items.push({ icon: pickIcon(kindIconOf(kind), { noColor: useAscii }), label });
+  }
+  if (hasGroupsEdge) {
+    items.push({
+      icon: useAscii ? ascii(RelationIcon.GROUPS) : RelationIcon.GROUPS,
+      label: "groups-edge"
+    });
+  }
+  const STATUS_ORDER = [
+    ["done", StatusIcon.DONE],
+    ["in_progress", StatusIcon.ACTIVE],
+    ["pending", StatusIcon.PENDING],
+    ["blocked", StatusIcon.BLOCKED],
+    ["archived", StatusIcon.ARCHIVED],
+    ["cancelled", StatusIcon.CANCELLED]
+  ];
+  const STATUS_LABEL = {
+    done: "done",
+    in_progress: "active",
+    pending: "pending",
+    blocked: "blocked",
+    archived: "archived",
+    cancelled: "cancelled"
+  };
+  for (const [status, icon] of STATUS_ORDER) {
+    if (!statusesSeen.has(status)) continue;
+    items.push({
+      icon: pickIcon(icon, { noColor: useAscii }),
+      label: STATUS_LABEL[status] ?? status
+    });
+  }
+  const legend = renderLegend({ items, ctx });
+  const sagaMembers = result.tree.tree.filter((n) => n.metadata.edgeType === "groups").length;
+  const counts = [
+    { label: "nodes", n: result.tree.totalNodes },
+    { label: "depth", n: result.tree.maxDepth }
+  ];
+  if (sagaMembers > 0) counts.push({ label: "saga members", n: sagaMembers });
+  const summary = renderSummary({ counts, ctx });
+  const divider = `${DIM}\u2500\u2500\u2500 Legend \u2500\u2500\u2500${NC}`;
+  return [divider, legend, summary].filter(Boolean).join("\n");
+}
+function decorateGroupsEdges(tree, useAscii) {
+  const glyph = useAscii ? ascii(RelationIcon.GROUPS) : RelationIcon.GROUPS;
+  const prefix = `${glyph} `;
+  const rows = tree.tree.map(
+    (node) => node.metadata.edgeType === "groups" ? { ...node, title: `${prefix}${node.title}` } : node
+  );
+  return { ...tree, tree: rows };
+}
+function formatAncestorBanner(ancestors, useAscii) {
+  const ordered = [...ancestors].reverse();
+  const parts = ordered.map((node) => {
+    const icon = pickIcon(kindIconOf(node.kind), { noColor: useAscii });
+    return `${icon} ${node.id}`;
+  });
+  const arrow = useAscii ? " > " : " \u203A ";
+  const upGlyph = useAscii ? "^" : "\u2191";
+  const tip = arrow.trim();
+  const chain = parts.join(arrow);
+  return `${DIM}${upGlyph} ${chain}${tip}(here)${NC}`;
+}
+function renderQuiet(result) {
+  return result.tree.tree.map((node) => node.id).join("\n");
+}
+function renderAnnotations(tree, opts) {
+  const lines = [];
+  for (const node of tree.tree) {
+    if (opts.withDeps && node.metadata.depends.length > 0) {
+      lines.push(`${DIM}  ${node.id} depends-on: ${node.metadata.depends.join(", ")}${NC}`);
+    }
+    if (opts.withBlockers) {
+      const chain = node.metadata.blockerChain ?? [];
+      if (chain.length > 0) {
+        lines.push(`${DIM}  ${node.id} blocker-chain: ${chain.join(" \u2192 ")}${NC}`);
+      }
+      const leaves = node.metadata.leafBlockers ?? [];
+      if (leaves.length > 0) {
+        lines.push(`${DIM}  ${node.id} leaf-blockers: ${leaves.join(", ")}${NC}`);
+      }
+    }
+  }
+  return lines.length > 0 ? `
+${lines.join("\n")}` : "";
+}
+function kindIconOf(kind) {
+  switch (kind) {
+    case "saga":
+      return KindIcon.SAGA;
+    case "epic":
+      return KindIcon.EPIC;
+    case "task":
+      return KindIcon.TASK;
+    case "subtask":
+      return KindIcon.SUBTASK;
+  }
+}
+function resolveAnimateContext() {
+  const fmt = getFormatContext();
+  if (fmt.format !== "human") {
+    return createAnimateContext({ flagResolution: fmt });
+  }
+  return createAnimateContext({
+    flagResolution: fmt,
+    isTTY: true,
+    noColor: false
+  });
+}
+
+// packages/cleo/src/cli/commands/deps.ts
+var overviewCommand = defineCommand({
+  meta: { name: "overview", description: "Overview of all dependencies" },
+  async run() {
+    await dispatchFromCli(
+      "query",
+      "tasks",
+      "depends",
+      { action: "overview" },
+      { command: "deps", operation: "tasks.depends" }
+    );
+  }
+});
+var showCommand = defineCommand({
+  meta: { name: "show", description: "Show dependencies for a specific task" },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID to inspect",
+      required: true
+    },
+    tree: {
+      type: "boolean",
+      description: "Show full transitive dependency tree"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "tasks",
+      "depends",
+      {
+        taskId: args.taskId,
+        tree: args.tree
+      },
+      { command: "deps", operation: "tasks.depends" }
+    );
+  }
+});
+var wavesCommand = defineCommand({
+  meta: { name: "waves", description: "Group tasks into parallelizable execution waves" },
+  args: {
+    epicId: {
+      type: "positional",
+      description: "Epic ID to compute waves for",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "orchestrate",
+      "waves",
+      { epicId: args.epicId },
+      { command: "deps", operation: "orchestrate.waves" }
+    );
+  }
+});
+var criticalPathCommand = defineCommand({
+  meta: { name: "critical-path", description: "Find longest dependency chain from task" },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID to trace critical path from",
+      required: true
+    }
+  },
+  async run({ args }) {
+    const cwd = resolveProjectRoot();
+    try {
+      const result = await depsCriticalPath(args.taskId, cwd);
+      cliOutput(result, { command: "deps", operation: "tasks.criticalPath" });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      cliError(`critical-path: ${msg}`, ExitCode.NOT_FOUND, { name: "E_NOT_FOUND" });
+      process.exit(ExitCode.NOT_FOUND);
+    }
+  }
+});
+var impactCommand = defineCommand({
+  meta: { name: "impact", description: "Find all tasks affected by changes to task" },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID to analyse impact for",
+      required: true
+    },
+    depth: {
+      type: "string",
+      description: "Maximum depth for impact analysis",
+      default: "10"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "tasks",
+      "depends",
+      {
+        taskId: args.taskId,
+        action: "impact",
+        depth: Number.parseInt(args.depth, 10)
+      },
+      { command: "deps", operation: "tasks.depends" }
+    );
+  }
+});
+var cyclesCommand = defineCommand({
+  meta: { name: "cycles", description: "Detect circular dependencies" },
+  async run() {
+    await dispatchFromCli(
+      "query",
+      "tasks",
+      "depends",
+      { action: "cycles" },
+      { command: "deps", operation: "tasks.depends" }
+    );
+  }
+});
+var validateCommand = defineCommand({
+  meta: {
+    name: "validate",
+    description: "Validate dep graph \u2014 orphan, circular, cross-epic gap, stale-dep detection"
+  },
+  args: {
+    epic: {
+      type: "string",
+      description: "Scope validation to direct children of this epic ID"
+    },
+    scope: {
+      type: "string",
+      description: "Which tasks to include: all (default), open, or critical",
+      default: "all"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "tasks",
+      "deps.validate",
+      {
+        epicId: args.epic,
+        scope: args.scope
+      },
+      { command: "deps", operation: "tasks.deps.validate" }
+    );
+  }
+});
+var depsTreeCommand = defineCommand({
+  meta: {
+    name: "tree",
+    description: "Render the dep-graph tree for an epic (text/mermaid/json)"
+  },
+  args: {
+    epic: {
+      type: "string",
+      description: "Epic ID to visualize",
+      required: true
+    },
+    json: {
+      type: "boolean",
+      description: "Emit machine-readable JSON tree",
+      default: false
+    },
+    mermaid: {
+      type: "boolean",
+      description: "Emit Mermaid graph TD block",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const format = args.json ? "json" : args.mermaid ? "mermaid" : "text";
+    await dispatchFromCli(
+      "query",
+      "tasks",
+      "deps.tree",
+      {
+        epicId: args.epic,
+        format
+      },
+      { command: "deps", operation: "tasks.deps.tree" }
+    );
+  }
+});
+var depsCommand = defineCommand({
+  meta: { name: "deps", description: "Dependency visualization and analysis" },
+  subCommands: {
+    overview: overviewCommand,
+    show: showCommand,
+    waves: wavesCommand,
+    "critical-path": criticalPathCommand,
+    impact: impactCommand,
+    cycles: cyclesCommand,
+    validate: validateCommand,
+    tree: depsTreeCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+var treeCommand = defineCommand({
+  meta: { name: "tree", description: "Task hierarchy tree visualization" },
+  args: {
+    rootId: {
+      type: "positional",
+      description: "Root task ID \u2014 walks parent + groups edges from here",
+      required: true
+    },
+    withDeps: {
+      type: "boolean",
+      description: "Append direct depends chain below each task that has deps",
+      default: false
+    },
+    blockers: {
+      type: "boolean",
+      description: "Append transitive blocker chain and leaf blockers below each blocked task",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const cwd = resolveProjectRoot();
+    try {
+      const result = await buildGenericTaskTree(cwd, args.rootId, {
+        withBlockers: args.blockers
+      });
+      if (isJsonFormat()) {
+        cliOutput(result, { command: "tree", operation: "tasks.graphTree" });
+        return;
+      }
+      const text = renderGenericTree(result, {
+        withDeps: args.withDeps,
+        withBlockers: args.blockers,
+        quiet: isQuiet()
+      });
+      if (text) process.stdout.write(`${text}
+`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      cliError(`tree: ${msg}`, ExitCode.NOT_FOUND, { name: "E_NOT_FOUND" });
+      process.exit(ExitCode.NOT_FOUND);
+    }
+  }
+});
+export {
+  depsCommand,
+  treeCommand
+};
+//# sourceMappingURL=deps-UTPZJBXL.js.map

package/dist/cli/detect-FFZSMVDT.js

@@ -0,0 +1,46 @@
+(() => {
+  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/detect.ts
+var detectCommand = defineCommand({
+  meta: { name: "detect", description: "Re-detect project type and update project-context.json" },
+  async run() {
+    await dispatchFromCli(
+      "mutate",
+      "admin",
+      "detect",
+      {},
+      { command: "detect", operation: "admin.detect" }
+    );
+  }
+});
+export {
+  detectCommand
+};
+//# sourceMappingURL=detect-FFZSMVDT.js.map