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

package/dist/cli/chunk-ZMGDZMSJ.js

@@ -0,0 +1,210 @@
+(() => {
+  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 {
+  cliError
+} from "./chunk-4RGSNUUP.js";
+
+// packages/cleo/src/cli/commands/llm-stream.ts
+async function buildSession(provider, model) {
+  const [{ resolveCredentialsAsync }, { ConcreteSession }, { ModelRunner }, { deriveApiWire }] = await Promise.all([
+    import(
+      /* webpackIgnore: true */
+      "@cleocode/core/llm/credentials.js"
+    ),
+    import(
+      /* webpackIgnore: true */
+      "@cleocode/core/llm/concrete-session.js"
+    ),
+    import(
+      /* webpackIgnore: true */
+      "@cleocode/core/llm/model-runner.js"
+    ),
+    import(
+      /* webpackIgnore: true */
+      "@cleocode/core/llm/api-mode.js"
+    )
+  ]);
+  const cred = await resolveCredentialsAsync(provider);
+  if (!cred.apiKey) {
+    throw new Error(
+      `No credential found for provider '${provider}'. Run \`cleo login ${provider}\` (for OAuth) or \`cleo llm add ${provider} <key>\` (for API key).`
+    );
+  }
+  const wire = deriveApiWire(provider, cred.authType);
+  const resolvedCredential = {
+    provider,
+    label: "default",
+    token: cred.apiKey,
+    authType: cred.authType,
+    expiresAt: null,
+    refreshToken: null,
+    extraHeaders: {},
+    baseUrl: wire.baseUrl,
+    awsProfile: null
+  };
+  const transport = ModelRunner.buildTransportFromCredential(
+    provider,
+    resolvedCredential,
+    wire.apiMode
+  );
+  return new ConcreteSession({ transport, model, credential: resolvedCredential });
+}
+async function getComputeCost() {
+  const { computeCost } = await import(
+    /* webpackIgnore: true */
+    "@cleocode/core/llm/usage-pricing"
+  );
+  return computeCost;
+}
+async function resolveDefaultModel(provider) {
+  const [{ getProviderProfile }, { IMPLICIT_FALLBACK_MODEL }] = await Promise.all([
+    import(
+      /* webpackIgnore: true */
+      "@cleocode/core/llm/provider-registry/index.js"
+    ),
+    import(
+      /* webpackIgnore: true */
+      "@cleocode/core/llm/role-resolver.js"
+    )
+  ]);
+  const profile = await getProviderProfile(provider);
+  return profile?.defaultModel ?? IMPLICIT_FALLBACK_MODEL;
+}
+async function runLlmStream(opts) {
+  const stdout = opts.stdout ?? process.stdout;
+  const stderr = opts.stderr ?? process.stderr;
+  const session = opts._sessionOverride ?? await buildSession(opts.provider, opts.model ?? await resolveDefaultModel(opts.provider));
+  const sendOpts = {
+    ...opts.system != null ? { systemSuffix: opts.system } : {}
+  };
+  const messages = [{ role: "user", content: opts.prompt }];
+  let finalUsage = { inputTokens: 0, outputTokens: 0, costUsd: null };
+  const stream = session.stream(messages, sendOpts);
+  for await (const delta of stream) {
+    if (delta.text) {
+      stdout.write(delta.text);
+    }
+    if (delta.reasoning && opts.showThink) {
+      stderr.write(delta.reasoning);
+    }
+    if (delta.usage !== null) {
+      const { inputTokens, outputTokens } = delta.usage;
+      let costUsd = null;
+      try {
+        const computeCost = await getComputeCost();
+        const raw = computeCost({ inputTokens, outputTokens }, session.model);
+        costUsd = raw === 0 ? null : raw;
+      } catch {
+      }
+      finalUsage = { inputTokens, outputTokens, costUsd };
+    }
+  }
+  stderr.write(`${JSON.stringify(finalUsage)}
+`);
+  return finalUsage;
+}
+var streamCommand = defineCommand({
+  meta: {
+    name: "stream",
+    description: "Stream a single-prompt completion via LlmTransport.stream(). Text deltas are written to stdout incrementally. Reasoning/think blocks go to stderr (requires --think). A JSON usage summary is printed to stderr at stream end."
+  },
+  args: {
+    provider: {
+      type: "positional",
+      description: "Provider transport (anthropic | openai | gemini | moonshot | openrouter | \u2026)",
+      required: true
+    },
+    prompt: {
+      type: "positional",
+      description: "Prompt text to send to the model.",
+      required: true
+    },
+    model: {
+      type: "string",
+      description: "Model identifier override (e.g. 'claude-sonnet-4-6'). Uses provider default when omitted."
+    },
+    "max-tokens": {
+      type: "string",
+      description: "Maximum output tokens (default: 4096)."
+    },
+    temperature: {
+      type: "string",
+      description: "Sampling temperature in 0.0\u20131.0 (default: 0.7)."
+    },
+    think: {
+      type: "boolean",
+      description: "Emit reasoning/think blocks to stderr (default: off).",
+      default: false
+    },
+    system: {
+      type: "string",
+      description: "Optional system prompt prepended to the conversation."
+    }
+  },
+  async run({ args }) {
+    const a = args;
+    const provider = String(a["provider"] ?? "").trim();
+    const prompt = String(a["prompt"] ?? "").trim();
+    if (!provider) {
+      cliError(
+        "cleo llm stream: <provider> is required.",
+        2,
+        { name: "E_VALIDATION", fix: "Pass a provider as the first positional argument." },
+        { operation: "llm.stream" }
+      );
+      process.exit(2);
+    }
+    if (!prompt) {
+      cliError(
+        "cleo llm stream: <prompt> is required.",
+        2,
+        { name: "E_VALIDATION", fix: "Pass a prompt as the second positional argument." },
+        { operation: "llm.stream" }
+      );
+      process.exit(2);
+    }
+    const model = typeof a["model"] === "string" && a["model"] ? a["model"] : void 0;
+    const maxTokensRaw = typeof a["max-tokens"] === "string" ? Number(a["max-tokens"]) : void 0;
+    const maxTokens = maxTokensRaw !== void 0 && !Number.isNaN(maxTokensRaw) ? maxTokensRaw : void 0;
+    const tempRaw = typeof a["temperature"] === "string" ? parseFloat(a["temperature"]) : void 0;
+    const temperature = tempRaw !== void 0 && !Number.isNaN(tempRaw) ? tempRaw : void 0;
+    const showThink = a["think"] === true;
+    const system = typeof a["system"] === "string" && a["system"] ? a["system"] : void 0;
+    void maxTokens;
+    void temperature;
+    try {
+      await runLlmStream({ provider, prompt, model, maxTokens, temperature, showThink, system });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      cliError(
+        `cleo llm stream: ${msg}`,
+        1,
+        { name: "E_LLM_STREAM_FAILED" },
+        { operation: "llm.stream" }
+      );
+      process.exit(1);
+    }
+  }
+});
+
+export {
+  runLlmStream,
+  streamCommand
+};
+//# sourceMappingURL=chunk-ZMGDZMSJ.js.map

package/dist/cli/claim-IGOG2QOC.js

@@ -0,0 +1,97 @@
+(() => {
+  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/claim.ts
+var claimCommand = defineCommand({
+  meta: {
+    name: "claim",
+    description: "Take, renew (--renew) or override (--take-over expired, --force-claim live) your session's leased claim on a task"
+  },
+  args: {
+    taskId: { type: "positional", description: "Task ID to claim", required: true },
+    agent: {
+      type: "string",
+      description: "Agent ID recorded with the lease (default: the session's agent / CLEO_AGENT_ID)"
+    },
+    renew: { type: "boolean", description: "Renew your own lease on the task" },
+    "take-over": {
+      type: "boolean",
+      description: "Take over another session's EXPIRED lease (audited)"
+    },
+    "force-claim": {
+      type: "boolean",
+      description: "Take over another session's LIVE lease (audited)"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "tasks",
+      "claim",
+      {
+        taskId: args.taskId,
+        ...typeof args.agent === "string" && args.agent ? { agentId: args.agent } : {},
+        ...args.renew === true ? { renew: true } : {},
+        ...args["take-over"] === true ? { takeOver: true } : {},
+        ...args["force-claim"] === true ? { forceClaim: true } : {}
+      },
+      { command: "claim", operation: "tasks.claim" }
+    );
+  }
+});
+var unclaimCommand = defineCommand({
+  meta: {
+    name: "unclaim",
+    description: "Release your session's claim lease on a task (--force-claim: another session's)"
+  },
+  args: {
+    taskId: { type: "positional", description: "Task ID to unclaim", required: true },
+    "force-claim": {
+      type: "boolean",
+      description: "Release another session's lease (audited)"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "tasks",
+      "unclaim",
+      {
+        taskId: args.taskId,
+        ...args["force-claim"] === true ? { forceClaim: true } : {}
+      },
+      { command: "unclaim", operation: "tasks.unclaim" }
+    );
+  }
+});
+export {
+  claimCommand,
+  unclaimCommand
+};
+//# sourceMappingURL=claim-IGOG2QOC.js.map

package/dist/cli/classify-MG4N7GMQ.js

@@ -0,0 +1,117 @@
+(() => {
+  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 "./chunk-C3B7C43W.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliOutput
+} from "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/classify.ts
+import { classifyReadinessWithDecision, classifyTask, getProjectRoot } from "@cleocode/core";
+var classifyCommand = defineCommand({
+  meta: {
+    name: "classify",
+    description: "Classify a task: readiness verdict (proceed|grill) + persona routing (agent, confidence)"
+  },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID to classify (e.g. T1234)",
+      required: true
+    }
+  },
+  async run({ args }) {
+    const taskId = args.taskId;
+    const projectRoot = getProjectRoot();
+    const { getDb } = await import("@cleocode/core/store/sqlite.js");
+    const { tasks } = await import("@cleocode/core/store/tasks-schema");
+    const { eq } = await import("drizzle-orm");
+    const db = await getDb(projectRoot);
+    const row = await db.select().from(tasks).where(eq(tasks.id, taskId)).get();
+    if (!row) {
+      cliOutput(
+        {
+          success: false,
+          error: { code: "E_NOT_FOUND", message: `Task ${taskId} not found` }
+        },
+        { command: "classify", operation: "classify.show" }
+      );
+      return;
+    }
+    const labels = (() => {
+      try {
+        const parsed = JSON.parse(row.labelsJson ?? "[]");
+        return Array.isArray(parsed) ? parsed : [];
+      } catch {
+        return [];
+      }
+    })();
+    const acceptance = (() => {
+      try {
+        const parsed = JSON.parse(row.acceptanceJson ?? "[]");
+        return Array.isArray(parsed) ? parsed : [];
+      } catch {
+        return [];
+      }
+    })();
+    const task = {
+      id: row.id,
+      title: row.title,
+      description: row.description ?? "",
+      status: row.status,
+      priority: row.priority ?? "medium",
+      type: row.type ?? void 0,
+      kind: row.kind ?? void 0,
+      size: row.size ?? void 0,
+      pipelineStage: row.pipelineStage ?? void 0,
+      blockedBy: row.blockedBy ?? void 0,
+      phase: row.phase ?? void 0,
+      scope: row.scope ?? void 0,
+      labels,
+      acceptance,
+      createdAt: row.createdAt
+    };
+    const readiness = await classifyReadinessWithDecision(task, {}, { projectRoot });
+    const routing = classifyTask(task);
+    cliOutput(
+      {
+        taskId: row.id,
+        title: row.title,
+        readiness: {
+          verdict: readiness.verdict,
+          reason: readiness.reason,
+          triggers: readiness.triggers
+        },
+        routing: {
+          agentId: routing.agentId,
+          role: routing.role,
+          confidence: routing.confidence,
+          reason: routing.reason,
+          usedFallback: routing.usedFallback,
+          warning: routing.warning
+        }
+      },
+      { command: "classify", operation: "classify.show" }
+    );
+  }
+});
+export {
+  classifyCommand
+};
+//# sourceMappingURL=classify-MG4N7GMQ.js.map

package/dist/cli/cli-A23Q335V.js

@@ -0,0 +1,51 @@
+(() => {
+  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 {
+  createCliDispatcher,
+  createCliGatewayHandler,
+  dispatchFromCli,
+  dispatchRaw,
+  getCliDispatcher,
+  handleRawError,
+  heartbeatCliSession,
+  lookupCliSession,
+  maybeEmitDescribe,
+  prepareCoreFor,
+  resetCliDispatcher,
+  warnUnboundMutation
+} from "./chunk-L7ONYSV6.js";
+import "./chunk-6N6WGLXE.js";
+import "./chunk-4VASFLUW.js";
+import "./chunk-QKMBWYAS.js";
+import "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-D7BAQNV2.js";
+import "./chunk-TYC7G5LF.js";
+export {
+  createCliDispatcher,
+  createCliGatewayHandler,
+  dispatchFromCli,
+  dispatchRaw,
+  getCliDispatcher,
+  handleRawError,
+  heartbeatCliSession,
+  lookupCliSession,
+  maybeEmitDescribe,
+  prepareCoreFor,
+  resetCliDispatcher,
+  warnUnboundMutation
+};
+//# sourceMappingURL=cli-A23Q335V.js.map