@cleocode/cleo 2026.10.2 → 2026.10.4

package/dist/cli/tasks-BNXTM7PB.js

@@ -0,0 +1,174 @@
+(() => {
+  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 {
+  isSubCommandDispatch
+} from "./chunk-YY66LFZF.js";
+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 {
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-QFFQSKRC.js";
+
+// packages/cleo/src/cli/commands/tasks.ts
+var showSub = defineCommand({
+  meta: { name: "show", description: "Show full task details" },
+  args: {
+    id: { type: "positional", description: "Task ID (e.g. T1234)", required: true },
+    json: { type: "boolean", description: "Emit JSON output" }
+  },
+  async run({ args }) {
+    await dispatchFromCli("query", "tasks", "show", { taskId: args.id }, { command: "tasks show" });
+  }
+});
+var findSub = defineCommand({
+  meta: { name: "find", description: "Search tasks by keyword" },
+  args: {
+    query: { type: "positional", description: "Search query", required: false },
+    status: { type: "string", description: "Filter by status" },
+    parent: { type: "string", description: "Filter by parent ID" },
+    limit: { type: "string", description: "Max results (default 20)" },
+    json: { type: "boolean", description: "Emit JSON output" }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "tasks",
+      "find",
+      {
+        query: args.query ?? "",
+        status: args.status,
+        parentId: args.parent,
+        limit: args.limit ? parseInt(args.limit, 10) : void 0
+      },
+      { command: "tasks find" }
+    );
+  }
+});
+var nextSub = defineCommand({
+  meta: { name: "next", description: "Auto-select highest-priority next task" },
+  args: {
+    json: { type: "boolean", description: "Emit JSON output" }
+  },
+  async run() {
+    await dispatchFromCli("query", "tasks", "next", {}, { command: "tasks next" });
+  }
+});
+var currentSub = defineCommand({
+  meta: { name: "current", description: "Show currently active task" },
+  args: {
+    json: { type: "boolean", description: "Emit JSON output" }
+  },
+  async run() {
+    await dispatchFromCli("query", "tasks", "current", {}, { command: "tasks current" });
+  }
+});
+var planSub = defineCommand({
+  meta: { name: "plan", description: "Composite planning view: upcoming, blockers, dependencies" },
+  args: {
+    json: { type: "boolean", description: "Emit JSON output" }
+  },
+  async run() {
+    await dispatchFromCli("query", "tasks", "plan", {}, { command: "tasks plan" });
+  }
+});
+var analyzeSub = defineCommand({
+  meta: { name: "analyze", description: "Leverage-sorted task discovery" },
+  args: {
+    json: { type: "boolean", description: "Emit JSON output" }
+  },
+  async run() {
+    await dispatchFromCli("query", "tasks", "analyze", {}, { command: "tasks analyze" });
+  }
+});
+var sliceSub = defineCommand({
+  meta: {
+    name: "slice",
+    description: "Show a localized WorkGraph slice around a task"
+  },
+  args: {
+    id: { type: "positional", description: "Task ID (e.g. T1234)", required: true },
+    upstream: { type: "boolean", description: "Return upstream dependency slice only" },
+    downstream: { type: "boolean", description: "Return downstream dependent slice only" },
+    around: {
+      type: "boolean",
+      description: "Return upstream, downstream, and sibling context (default)"
+    },
+    depth: { type: "string", description: "Dependency traversal depth (default 1)" },
+    radius: { type: "string", description: "Alias for --depth" },
+    budget: { type: "string", description: "Maximum nodes per returned section" },
+    "include-relates": {
+      type: "boolean",
+      description: "Include direct non-dependency related tasks"
+    },
+    json: { type: "boolean", description: "Emit JSON output" }
+  },
+  async run({ args }) {
+    const direction = args.upstream ? "upstream" : args.downstream ? "downstream" : "around";
+    await dispatchFromCli(
+      "query",
+      "tasks",
+      "slice",
+      {
+        taskId: args.id,
+        direction,
+        radius: args.radius ? parseInt(args.radius, 10) : void 0,
+        depth: args.depth ? parseInt(args.depth, 10) : void 0,
+        budget: args.budget ? parseInt(args.budget, 10) : void 0,
+        includeRelates: Boolean(args["include-relates"])
+      },
+      { command: "tasks slice" }
+    );
+  }
+});
+var tasksCommand = defineCommand({
+  meta: {
+    name: "tasks",
+    description: "Task query namespace: show, find, next, current, plan, analyze, slice"
+  },
+  subCommands: {
+    show: showSub,
+    find: findSub,
+    next: nextSub,
+    current: currentSub,
+    plan: planSub,
+    analyze: analyzeSub,
+    slice: sliceSub
+  },
+  async run({ cmd, rawArgs }) {
+    if (isSubCommandDispatch(rawArgs, cmd.subCommands)) return;
+    cliOutput(
+      { subCommands: ["show", "find", "next", "current", "plan", "analyze"] },
+      {
+        command: "tasks",
+        message: "Usage: cleo tasks show|find|next|current|plan|analyze",
+        operation: "tasks"
+      }
+    );
+  }
+});
+export {
+  tasksCommand
+};
+//# sourceMappingURL=tasks-BNXTM7PB.js.map

package/dist/cli/telemetry-55Z2XJWL.js

@@ -0,0 +1,120 @@
+(() => {
+  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 {
+  isSubCommandDispatch
+} from "./chunk-YY66LFZF.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/telemetry.ts
+import { randomUUID } from "node:crypto";
+import { getConfigValue, setConfigValue } from "@cleocode/core";
+async function readTelemetryConfig() {
+  const enabledResolved = await getConfigValue("telemetry.enabled");
+  const periodResolved = await getConfigValue("telemetry.period");
+  const installIdResolved = await getConfigValue("telemetry.installId");
+  const enabled = enabledResolved.value === true;
+  const period = periodResolved.value === "monthly" ? "monthly" : "monthly";
+  const installId = typeof installIdResolved.value === "string" ? installIdResolved.value : void 0;
+  return { enabled, period, installId };
+}
+async function ensureInstallId() {
+  const existing = await getConfigValue("telemetry.installId");
+  if (typeof existing.value === "string" && existing.value.length > 0) {
+    return existing.value;
+  }
+  const newId = randomUUID();
+  await setConfigValue("telemetry.installId", newId, void 0, { global: true });
+  return newId;
+}
+var enableSub = defineCommand({
+  meta: {
+    name: "enable",
+    description: "Enable anonymous skills-usage telemetry (default-on for new installs)"
+  },
+  async run() {
+    await setConfigValue("telemetry.enabled", true, void 0, { global: true });
+    await setConfigValue("telemetry.period", "monthly", void 0, { global: true });
+    const installId = await ensureInstallId();
+    const config = await readTelemetryConfig();
+    cliOutput(
+      { ...config, installId },
+      {
+        command: "telemetry",
+        message: `Telemetry enabled (installId=${installId}, period=${config.period}).`,
+        operation: "telemetry.enable"
+      }
+    );
+  }
+});
+var disableSub = defineCommand({
+  meta: {
+    name: "disable",
+    description: "Disable anonymous skills-usage telemetry"
+  },
+  async run() {
+    await setConfigValue("telemetry.enabled", false, void 0, { global: true });
+    const config = await readTelemetryConfig();
+    cliOutput(config, {
+      command: "telemetry",
+      message: "Telemetry disabled.",
+      operation: "telemetry.disable"
+    });
+  }
+});
+var statusSub = defineCommand({
+  meta: {
+    name: "status",
+    description: "Print current telemetry configuration"
+  },
+  async run() {
+    const config = await readTelemetryConfig();
+    cliOutput(config, {
+      command: "telemetry",
+      message: `Telemetry is ${config.enabled ? "enabled" : "disabled"} (period=${config.period}).`,
+      operation: "telemetry.status"
+    });
+  }
+});
+var telemetryCommand = defineCommand({
+  meta: {
+    name: "telemetry",
+    description: "Manage anonymous skills-usage telemetry (enable/disable/status)"
+  },
+  subCommands: {
+    enable: enableSub,
+    disable: disableSub,
+    status: statusSub
+  },
+  async run({ cmd, rawArgs }) {
+    if (isSubCommandDispatch(rawArgs, cmd.subCommands)) return;
+    const config = await readTelemetryConfig();
+    cliOutput(config, {
+      command: "telemetry",
+      message: `Telemetry is ${config.enabled ? "enabled" : "disabled"} (period=${config.period}).`,
+      operation: "telemetry.status"
+    });
+  }
+});
+export {
+  telemetryCommand
+};
+//# sourceMappingURL=telemetry-55Z2XJWL.js.map