@cleocode/cleo 2026.10.2 → 2026.10.4

package/dist/cli/labels-5NPOIQXN.js

@@ -0,0 +1,87 @@
+(() => {
+  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 {
+  dispatchFromCli
+} from "./chunk-3IOQVUO7.js";
+import "./chunk-AWCQH2W5.js";
+import "./chunk-OGV57L4J.js";
+import "./chunk-ZBISIPCK.js";
+import "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-QFFQSKRC.js";
+
+// packages/cleo/src/cli/commands/labels.ts
+var listCommand = defineCommand({
+  meta: { name: "list", description: "List all labels with task counts (default)" },
+  async run() {
+    await dispatchFromCli("query", "tasks", "label.list", {}, { command: "labels" });
+  }
+});
+var showCommand = defineCommand({
+  meta: { name: "show", description: "Show tasks with specific label" },
+  args: {
+    label: { type: "positional", description: "Label name to filter by", required: true }
+  },
+  async run({ args }) {
+    await dispatchFromCli("query", "tasks", "list", { label: args.label }, { command: "labels" });
+  }
+});
+var statsCommand = defineCommand({
+  meta: { name: "stats", description: "Show detailed label statistics" },
+  async run() {
+    await dispatchFromCli("query", "tasks", "label.list", {}, { command: "labels" });
+  }
+});
+var labelsCommand = defineCommand({
+  meta: {
+    name: "labels",
+    description: "List all labels (no args), or show tasks for a label (cleo labels <name>)"
+  },
+  args: {
+    // Optional positional — when present, dispatches to tasks.list with the
+    // label filter; when absent, falls through to the legacy label.list path.
+    // Required:false keeps the bare `cleo labels` invocation working.
+    name: {
+      type: "positional",
+      description: "Label name to filter tasks by (omit to list all labels)",
+      required: false
+    }
+  },
+  subCommands: {
+    list: listCommand,
+    show: showCommand,
+    stats: statsCommand
+  },
+  async run(ctx) {
+    const rawArgs = ctx.rawArgs ?? [];
+    if (rawArgs.some((a) => ["list", "show", "stats"].includes(a))) {
+      return;
+    }
+    const name = ctx.args.name;
+    if (typeof name === "string" && name.length > 0) {
+      await dispatchFromCli("query", "tasks", "list", { label: name }, { command: "labels" });
+      return;
+    }
+    await dispatchFromCli("query", "tasks", "label.list", {}, { command: "labels" });
+  }
+});
+export {
+  labelsCommand
+};
+//# sourceMappingURL=labels-5NPOIQXN.js.map

package/dist/cli/lifecycle-4FFS2K2T.js

@@ -0,0 +1,272 @@
+(() => {
+  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,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+import {
+  dispatchFromCli,
+  dispatchRaw,
+  handleRawError
+} from "./chunk-3IOQVUO7.js";
+import "./chunk-AWCQH2W5.js";
+import "./chunk-OGV57L4J.js";
+import "./chunk-ZBISIPCK.js";
+import "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-QFFQSKRC.js";
+
+// packages/cleo/src/cli/commands/lifecycle.ts
+var VALID_STAGES = "research|consensus|architecture_decision|specification|decomposition|implementation|validation|testing|release|contribution";
+var showCommand = defineCommand({
+  meta: { name: "show", description: "Show lifecycle state for an epic" },
+  args: {
+    epicId: { type: "positional", description: "Epic ID", required: true }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "pipeline",
+      "stage.status",
+      { epicId: args.epicId },
+      { command: "lifecycle" }
+    );
+  }
+});
+var startCommand = defineCommand({
+  meta: {
+    name: "start",
+    description: `Start a lifecycle stage. Valid stages: ${VALID_STAGES}`
+  },
+  args: {
+    epicId: { type: "positional", description: "Epic ID", required: true },
+    stage: { type: "positional", description: "Stage name", required: true }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "pipeline",
+      "stage.record",
+      { taskId: args.epicId, stage: args.stage, status: "in_progress" },
+      { command: "lifecycle" }
+    );
+  }
+});
+var completeCommand = defineCommand({
+  meta: {
+    name: "complete",
+    description: `Complete a lifecycle stage. Valid stages: ${VALID_STAGES}`
+  },
+  args: {
+    epicId: { type: "positional", description: "Epic ID", required: true },
+    stage: { type: "positional", description: "Stage name", required: true },
+    artifacts: { type: "string", description: "Comma-separated artifact paths" },
+    notes: { type: "string", description: "Completion notes" }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "pipeline",
+      "stage.record",
+      {
+        taskId: args.epicId,
+        stage: args.stage,
+        status: "completed",
+        notes: args.notes
+      },
+      { command: "lifecycle" }
+    );
+  }
+});
+var skipCommand = defineCommand({
+  meta: {
+    name: "skip",
+    description: `Skip a lifecycle stage. Valid stages: ${VALID_STAGES}`
+  },
+  args: {
+    epicId: { type: "positional", description: "Epic ID", required: true },
+    stage: { type: "positional", description: "Stage name", required: true },
+    reason: { type: "string", description: "Reason for skipping", required: true }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "pipeline",
+      "stage.skip",
+      { taskId: args.epicId, stage: args.stage, reason: args.reason },
+      { command: "lifecycle" }
+    );
+  }
+});
+var gateCommand = defineCommand({
+  meta: { name: "gate", description: "Check lifecycle gate for a stage" },
+  args: {
+    epicId: { type: "positional", description: "Epic ID", required: true },
+    stage: { type: "positional", description: "Stage name", required: true }
+  },
+  async run({ args }) {
+    const result = await dispatchRaw("query", "pipeline", "stage.validate", {
+      epicId: args.epicId,
+      targetStage: args.stage
+    });
+    if (result.success) {
+      const { cliOutput } = await import("./renderers-64OR3IWX.js");
+      cliOutput(result.data, { command: "lifecycle" });
+      const data = result.data;
+      if (data && !data["canProgress"]) {
+        process.exit(80);
+      }
+    } else {
+      handleRawError(result, { command: "lifecycle", operation: "pipeline.stage.validate" });
+    }
+  }
+});
+var guidanceCommand = defineCommand({
+  meta: {
+    name: "guidance",
+    description: "Get stage-aware LLM prompt guidance (Phase 2). Pi extensions shell out to this on before_agent_start."
+  },
+  args: {
+    stage: { type: "positional", description: "Stage name (optional)", required: false },
+    epicId: {
+      type: "string",
+      description: "Resolve stage from current epic pipeline status if no stage arg"
+    },
+    format: { type: "string", description: "Output format: markdown | json", default: "markdown" }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "pipeline",
+      "stage.guidance",
+      {
+        stage: args.stage,
+        epicId: args.epicId,
+        format: args.format
+      },
+      { command: "lifecycle" }
+    );
+  }
+});
+var historyCommand = defineCommand({
+  meta: { name: "history", description: "Show full lifecycle stage history for a task or epic" },
+  args: {
+    taskId: { type: "positional", description: "Task or epic ID", required: true }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "pipeline",
+      "stage.history",
+      { taskId: args.taskId },
+      { command: "lifecycle" }
+    );
+  }
+});
+var resetCommand = defineCommand({
+  meta: {
+    name: "reset",
+    description: `Reset a lifecycle stage back to pending. Valid stages: ${VALID_STAGES}`
+  },
+  args: {
+    epicId: { type: "positional", description: "Epic ID", required: true },
+    stage: { type: "positional", description: "Stage name", required: true },
+    reason: { type: "string", description: "Reason for resetting the stage", required: true }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "pipeline",
+      "stage.reset",
+      { taskId: args.epicId, stage: args.stage, reason: args.reason },
+      { command: "lifecycle" }
+    );
+  }
+});
+var gateRecordPassCommand = defineCommand({
+  meta: { name: "pass", description: "Record a gate as passed for a lifecycle stage" },
+  args: {
+    epicId: { type: "positional", description: "Epic ID", required: true },
+    gateName: { type: "positional", description: "Gate name", required: true },
+    agent: { type: "string", description: "Agent that performed the gate check" },
+    notes: { type: "string", description: "Notes on gate outcome" }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "pipeline",
+      "stage.gate.pass",
+      {
+        taskId: args.epicId,
+        gateName: args.gateName,
+        agent: args.agent,
+        notes: args.notes
+      },
+      { command: "lifecycle" }
+    );
+  }
+});
+var gateRecordFailCommand = defineCommand({
+  meta: { name: "fail", description: "Record a gate as failed for a lifecycle stage" },
+  args: {
+    epicId: { type: "positional", description: "Epic ID", required: true },
+    gateName: { type: "positional", description: "Gate name", required: true },
+    reason: { type: "string", description: "Reason the gate failed" }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "pipeline",
+      "stage.gate.fail",
+      {
+        taskId: args.epicId,
+        gateName: args.gateName,
+        reason: args.reason
+      },
+      { command: "lifecycle" }
+    );
+  }
+});
+var gateRecordCommand = defineCommand({
+  meta: { name: "gate-record", description: "Record a gate pass or fail for a lifecycle stage" },
+  subCommands: {
+    pass: gateRecordPassCommand,
+    fail: gateRecordFailCommand
+  }
+});
+var lifecycleCommand = defineCommand({
+  meta: { name: "lifecycle", description: "RCASD-IVTR+C lifecycle pipeline management" },
+  subCommands: {
+    show: showCommand,
+    start: startCommand,
+    complete: completeCommand,
+    skip: skipCommand,
+    gate: gateCommand,
+    guidance: guidanceCommand,
+    history: historyCommand,
+    reset: resetCommand,
+    "gate-record": gateRecordCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  lifecycleCommand
+};
+//# sourceMappingURL=lifecycle-4FFS2K2T.js.map

package/dist/cli/list-47KEUGPQ.js

@@ -0,0 +1,108 @@
+(() => {
+  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 {
+  getOperationParams,
+  paramsToCittyArgs,
+  registryParamsToDispatchPayload
+} from "./chunk-W33Q3FBH.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  dispatchRaw,
+  handleRawError,
+  maybeEmitDescribe
+} from "./chunk-3IOQVUO7.js";
+import "./chunk-AWCQH2W5.js";
+import "./chunk-OGV57L4J.js";
+import "./chunk-ZBISIPCK.js";
+import {
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-QFFQSKRC.js";
+
+// packages/cleo/src/cli/commands/list.ts
+import { ExitCode } from "@cleocode/contracts";
+import { createPage } from "@cleocode/core";
+var listArgs = {
+  ...paramsToCittyArgs(getOperationParams("query", "tasks", "list")),
+  includeArchive: {
+    type: "boolean",
+    description: "Compatibility alias for --include-archive"
+  },
+  "parent-id": {
+    type: "string",
+    description: "Alias for --parent (legacy parentId compatibility)"
+  },
+  // Explicit complete enumeration uses the same limit semantics as find.
+  all: {
+    type: "boolean",
+    description: "Return every matching task instead of the default page of 10; equivalent to --limit 0."
+  },
+  // T9922 — MVI record projection opt-out flags (surfaced for --help).
+  verbose: {
+    type: "boolean",
+    description: "Return full task records instead of the MVI projection (id + title + status + key metadata). T9922."
+  },
+  full: {
+    type: "boolean",
+    description: "Alias for --verbose. T9922."
+  },
+  // T9932 — 1-line-per-record summary render. Global flag; parsed by cli/index.ts.
+  summary: {
+    type: "boolean",
+    description: 'Render each task as a single line "<id> [<status>] <title-truncated-60>". Composes with --output: --output {id|table|count|silent} wins. T9932.'
+  }
+};
+var listCommand = defineCommand({
+  meta: { name: "list", description: "List tasks with optional filters" },
+  args: listArgs,
+  async run({ args }) {
+    if (maybeEmitDescribe("query", "tasks", "list", { command: "list" })) return;
+    const declaredParams = getOperationParams("query", "tasks", "list");
+    const params = registryParamsToDispatchPayload(declaredParams, args);
+    if (args["includeArchive"] !== void 0) params["includeArchive"] ??= args["includeArchive"];
+    if (args["parent-id"] !== void 0) params["parent"] ??= args["parent-id"];
+    if (args["all"] === true) params["limit"] = 0;
+    const limit = typeof params["limit"] === "number" ? params["limit"] : void 0;
+    const offset = typeof params["offset"] === "number" ? params["offset"] : void 0;
+    const response = await dispatchRaw("query", "tasks", "list", params);
+    if (!response.success) {
+      handleRawError(response, { command: "list", operation: "tasks.list" });
+    }
+    const rawData = response.data;
+    const data = (Array.isArray(rawData) ? { tasks: rawData, total: rawData.length } : rawData) ?? {};
+    const tasks = Array.isArray(data?.tasks) ? data.tasks : [];
+    if (tasks.length === 0) {
+      const matched = typeof data.filtered === "number" ? data.filtered : 0;
+      cliOutput(data, {
+        command: "list",
+        message: matched > 0 ? `No rows on this page; ${matched} tasks matched. Adjust --offset or use --all.` : "No tasks found",
+        operation: "tasks.list"
+      });
+      process.exit(ExitCode.NO_DATA);
+      return;
+    }
+    const filtered = data?.filtered ?? tasks.length;
+    const page = response.page ?? createPage({ total: filtered, limit, offset });
+    cliOutput(data, { command: "list", operation: "tasks.list", page, enumerateAllFlag: "--all" });
+  }
+});
+export {
+  listCommand
+};
+//# sourceMappingURL=list-47KEUGPQ.js.map