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

package/dist/cli/list-LB6GCYYU.js

@@ -0,0 +1,109 @@
+(() => {
+  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-RRKP7HLU.js";
+import {
+  dispatchRaw,
+  handleRawError,
+  maybeEmitDescribe
+} from "./chunk-L7ONYSV6.js";
+import "./chunk-6N6WGLXE.js";
+import "./chunk-4VASFLUW.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import "./chunk-QKMBWYAS.js";
+import {
+  cliOutput
+} from "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-D7BAQNV2.js";
+import "./chunk-TYC7G5LF.js";
+
+// packages/cleo/src/cli/commands/list.ts
+import { ExitCode } from "@cleocode/contracts/exit-codes.js";
+import { createPage } from "@cleocode/core/pagination";
+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-LB6GCYYU.js.map

package/dist/cli/llm-H7LZWQKX.js

@@ -0,0 +1,130 @@
+(() => {
+  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 {
+  defineTypedHandler,
+  lafsError,
+  lafsSuccess,
+  typedDispatch
+} from "./chunk-QWNKLLLG.js";
+import {
+  envelopeToEngineResult,
+  handleErrorResult,
+  unsupportedOp,
+  wrapResult
+} from "./chunk-XHRZ7OYZ.js";
+
+// packages/cleo/src/dispatch/domains/llm/index.ts
+import {
+  llmAdd,
+  llmAuxiliaryStatus,
+  llmList,
+  llmProfile,
+  llmRemove,
+  llmSystemsOfUse,
+  llmTest,
+  llmUse,
+  llmWhoami
+} from "@cleocode/core/internal";
+var coreOps = {
+  list: llmList,
+  test: llmTest,
+  whoami: llmWhoami,
+  "systems-of-use": llmSystemsOfUse,
+  "auxiliary-status": llmAuxiliaryStatus,
+  add: llmAdd,
+  remove: llmRemove,
+  use: llmUse,
+  profile: llmProfile
+};
+async function wrap(op, params, label) {
+  try {
+    const result = await op(params);
+    if (result.success) return lafsSuccess(result.data, label);
+    return lafsError(String(result.error.code), result.error.message, label);
+  } catch (err) {
+    return lafsError("E_INTERNAL", err instanceof Error ? err.message : String(err), label);
+  }
+}
+var _llmTypedHandler = defineTypedHandler("llm", {
+  // -------------------------------------------------------------------------
+  // Query ops
+  // -------------------------------------------------------------------------
+  list: async (params) => wrap(coreOps["list"], params, "list"),
+  test: async (params) => wrap(coreOps["test"], params, "test"),
+  whoami: async (params) => wrap(coreOps["whoami"], params, "whoami"),
+  "systems-of-use": async (params) => wrap(coreOps["systems-of-use"], params, "systems-of-use"),
+  "auxiliary-status": async (params) => wrap(coreOps["auxiliary-status"], params, "auxiliary-status"),
+  // -------------------------------------------------------------------------
+  // Mutate ops
+  // -------------------------------------------------------------------------
+  add: async (params) => wrap(coreOps["add"], params, "add"),
+  remove: async (params) => wrap(coreOps["remove"], params, "remove"),
+  use: async (params) => wrap(coreOps["use"], params, "use"),
+  profile: async (params) => wrap(coreOps["profile"], params, "profile")
+});
+var QUERY_OPS = /* @__PURE__ */ new Set(["list", "test", "whoami", "systems-of-use", "auxiliary-status"]);
+var MUTATE_OPS = /* @__PURE__ */ new Set(["add", "remove", "use", "profile"]);
+var LlmHandler = class {
+  /** Declared operations for introspection and validation. */
+  getSupportedOperations() {
+    return {
+      query: ["list", "test", "whoami", "systems-of-use", "auxiliary-status"],
+      mutate: ["add", "remove", "use", "profile"]
+    };
+  }
+  /**
+   * Execute a read-only llm query operation.
+   */
+  async query(operation, params) {
+    const startTime = Date.now();
+    if (!QUERY_OPS.has(operation)) {
+      return unsupportedOp("query", "llm", operation, startTime);
+    }
+    try {
+      const envelope = await typedDispatch(
+        _llmTypedHandler,
+        operation,
+        params ?? {}
+      );
+      return wrapResult(envelopeToEngineResult(envelope), "query", "llm", operation, startTime);
+    } catch (error) {
+      return handleErrorResult("query", "llm", operation, error, startTime);
+    }
+  }
+  /**
+   * Execute a state-modifying llm mutate operation.
+   */
+  async mutate(operation, params) {
+    const startTime = Date.now();
+    if (!MUTATE_OPS.has(operation)) {
+      return unsupportedOp("mutate", "llm", operation, startTime);
+    }
+    try {
+      const envelope = await typedDispatch(
+        _llmTypedHandler,
+        operation,
+        params ?? {}
+      );
+      return wrapResult(envelopeToEngineResult(envelope), "mutate", "llm", operation, startTime);
+    } catch (error) {
+      return handleErrorResult("mutate", "llm", operation, error, startTime);
+    }
+  }
+};
+export {
+  LlmHandler
+};
+//# sourceMappingURL=llm-H7LZWQKX.js.map