@cleocode/cleo 2026.10.3 → 2026.10.4

package/dist/cli/testing-37YTBNKP.js

@@ -0,0 +1,146 @@
+(() => {
+  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
+} 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/testing.ts
+var validateCommand = defineCommand({
+  meta: { name: "validate", description: "Validate testing protocol compliance for a task" },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID to validate testing protocol for",
+      required: true
+    },
+    strict: {
+      type: "boolean",
+      description: "Exit with error code on violations"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "check",
+      "protocol",
+      {
+        protocolType: "testing",
+        mode: "task",
+        taskId: args.taskId,
+        strict: !!args.strict
+      },
+      { command: "testing", operation: "check.protocol" }
+    );
+  }
+});
+var checkCommand = defineCommand({
+  meta: { name: "check", description: "Validate testing protocol from a manifest file" },
+  args: {
+    manifestFile: {
+      type: "positional",
+      description: "Path to the manifest file to validate",
+      required: true
+    },
+    strict: {
+      type: "boolean",
+      description: "Exit with error code on violations"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "check",
+      "manifest",
+      {
+        file: args.manifestFile,
+        strict: !!args.strict,
+        type: "testing"
+      },
+      { command: "testing", operation: "check.manifest" }
+    );
+  }
+});
+var statusCommand = defineCommand({
+  meta: { name: "status", description: "Show test suite status" },
+  async run() {
+    await dispatchFromCli(
+      "query",
+      "check",
+      "test",
+      { format: "status" },
+      { command: "testing", operation: "check.test" }
+    );
+  }
+});
+var coverageCommand = defineCommand({
+  meta: { name: "coverage", description: "Show test coverage" },
+  async run() {
+    await dispatchFromCli(
+      "query",
+      "check",
+      "test",
+      { format: "coverage" },
+      { command: "testing", operation: "check.test" }
+    );
+  }
+});
+var runCommand = defineCommand({
+  meta: { name: "run", description: "Run test suite" },
+  args: {
+    filter: {
+      type: "string",
+      description: "Filter tests by pattern"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "check",
+      "test.run",
+      { filter: args.filter },
+      { command: "testing", operation: "check.test.run" }
+    );
+  }
+});
+var testingCommand = defineCommand({
+  meta: { name: "testing", description: "Validate testing protocol compliance" },
+  subCommands: {
+    validate: validateCommand,
+    check: checkCommand,
+    status: statusCommand,
+    coverage: coverageCommand,
+    run: runCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  testingCommand
+};
+//# sourceMappingURL=testing-37YTBNKP.js.map

package/dist/cli/token-UAVJMNUI.js

@@ -0,0 +1,220 @@
+(() => {
+  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
+} 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/token.ts
+import { readFileSync } from "node:fs";
+import { getProjectRoot, measureTokenExchange, recordTokenExchange } from "@cleocode/core/internal";
+function readPayload(args, textKey, fileKey) {
+  const text = args[textKey];
+  const file = args[fileKey];
+  if (file) return readFileSync(file, "utf-8");
+  return text;
+}
+var filterArgs = {
+  provider: { type: "string", description: "Filter by provider" },
+  transport: { type: "string", description: "Filter by transport" },
+  domain: { type: "string", description: "Filter by domain" },
+  operation: { type: "string", description: "Filter by operation name" },
+  session: { type: "string", description: "Filter by session ID" },
+  task: { type: "string", description: "Filter by task ID" }
+};
+var summaryCommand = defineCommand({
+  meta: { name: "summary", description: "Summarize recorded token telemetry" },
+  args: { ...filterArgs },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "admin",
+      "token",
+      {
+        action: "summary",
+        provider: args.provider,
+        transport: args.transport,
+        domain: args.domain,
+        operationName: args.operation,
+        sessionId: args.session,
+        taskId: args.task
+      },
+      { command: "token", operation: "admin.token" }
+    );
+  }
+});
+var listCommand = defineCommand({
+  meta: { name: "list", description: "List recorded token telemetry" },
+  args: {
+    ...filterArgs,
+    limit: { type: "string", description: "Maximum records" },
+    offset: { type: "string", description: "Skip records" }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "admin",
+      "token",
+      {
+        action: "list",
+        provider: args.provider,
+        transport: args.transport,
+        domain: args.domain,
+        operationName: args.operation,
+        sessionId: args.session,
+        taskId: args.task,
+        limit: args.limit ? Number.parseInt(args.limit, 10) : void 0,
+        offset: args.offset ? Number.parseInt(args.offset, 10) : void 0
+      },
+      { command: "token", operation: "admin.token" }
+    );
+  }
+});
+var showCommand = defineCommand({
+  meta: { name: "show", description: "Show a single token telemetry record" },
+  args: {
+    tokenId: {
+      type: "positional",
+      description: "Token telemetry record ID",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "admin",
+      "token",
+      { action: "show", tokenId: args.tokenId },
+      { command: "token", operation: "admin.token" }
+    );
+  }
+});
+var deleteCommand = defineCommand({
+  meta: { name: "delete", description: "Delete a token telemetry record" },
+  args: {
+    tokenId: {
+      type: "positional",
+      description: "Token telemetry record ID to delete",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "admin",
+      "token",
+      { action: "delete", tokenId: args.tokenId },
+      { command: "token", operation: "admin.token" }
+    );
+  }
+});
+var clearCommand = defineCommand({
+  meta: { name: "clear", description: "Clear token telemetry records" },
+  args: { ...filterArgs },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "admin",
+      "token",
+      {
+        action: "clear",
+        provider: args.provider,
+        transport: args.transport,
+        domain: args.domain,
+        operationName: args.operation,
+        sessionId: args.session,
+        taskId: args.task
+      },
+      { command: "token", operation: "admin.token" }
+    );
+  }
+});
+var estimateCommand = defineCommand({
+  meta: {
+    name: "estimate",
+    description: "Estimate request/response tokens using the central token service"
+  },
+  args: {
+    provider: { type: "string", description: "Provider name" },
+    model: { type: "string", description: "Model name" },
+    transport: {
+      type: "string",
+      description: "Transport (cli|api|agent|unknown)",
+      default: "unknown"
+    },
+    gateway: { type: "string", description: "Gateway name" },
+    domain: { type: "string", description: "Domain name" },
+    operation: { type: "string", description: "Operation name" },
+    "request-text": { type: "string", description: "Inline request text" },
+    "response-text": { type: "string", description: "Inline response text" },
+    "request-file": { type: "string", description: "Read request payload from file" },
+    "response-file": { type: "string", description: "Read response payload from file" },
+    record: { type: "boolean", description: "Persist the measured exchange" }
+  },
+  async run({ args }) {
+    const requestPayload = readPayload(args, "request-text", "request-file");
+    const responsePayload = readPayload(args, "response-text", "response-file");
+    const input = {
+      requestPayload,
+      responsePayload,
+      provider: args.provider,
+      model: args.model,
+      transport: args.transport,
+      gateway: args.gateway,
+      domain: args.domain,
+      operation: args.operation
+    };
+    const result = args.record ? await recordTokenExchange(getProjectRoot(), input) : await measureTokenExchange(input);
+    cliOutput(result, {
+      command: "token",
+      operation: args.record ? "admin.token.record" : "token.estimate"
+    });
+  }
+});
+var tokenCommand = defineCommand({
+  meta: {
+    name: "token",
+    description: "Provider-aware token telemetry from tasks.db (historical, per-operation tracking)"
+  },
+  subCommands: {
+    summary: summaryCommand,
+    list: listCommand,
+    show: showCommand,
+    delete: deleteCommand,
+    clear: clearCommand,
+    estimate: estimateCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  tokenCommand
+};
+//# sourceMappingURL=token-UAVJMNUI.js.map