@cleocode/cleo 2026.10.2 → 2026.10.4

package/dist/cli/code-Z5CTMVTD.js

@@ -0,0 +1,178 @@
+(() => {
+  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,
+  humanLine
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/code.ts
+async function requireTreeSitter() {
+  const { isTreeSitterAvailable } = await import("@cleocode/core/internal");
+  if (!isTreeSitterAvailable()) {
+    cliError(
+      "tree-sitter native module not available.\n\nThis usually means the native addon failed to build during install.\n\ntree-sitter and grammar packages are bundled dependencies that should\ninstall automatically. If this persists, run: cleo doctor",
+      7,
+      {
+        name: "E_SERVICE_UNAVAILABLE",
+        fix: "pnpm install (or npm install -g @cleocode/cleo)"
+      }
+    );
+    process.exit(7);
+  }
+}
+var codeCommand = defineCommand({
+  meta: { name: "code", description: "Code analysis via tree-sitter AST" },
+  subCommands: {
+    /**
+     * Outline subcommand — extract file structure via tree-sitter.
+     *
+     * Shows all top-level symbols and nested methods/properties with signatures only
+     * (bodies collapsed). Provides ~1-2K token overview vs ~12K for full file read.
+     *
+     * Usage:
+     *   cleo code outline packages/core/src/store/sqlite.ts
+     *
+     * @task T154, T157
+     */
+    outline: defineCommand({
+      meta: { name: "outline", description: "Show file structural skeleton (signatures only)" },
+      args: {
+        file: { type: "positional", description: "Source file path", required: true }
+      },
+      async run({ args }) {
+        await requireTreeSitter();
+        const { smartOutline } = await import("@cleocode/core/internal");
+        const { join } = await import("node:path");
+        const root = process.cwd();
+        const absPath = args.file.startsWith("/") ? args.file : join(root, args.file);
+        const result = smartOutline(absPath, root);
+        if (result.errors.length > 0 && result.symbols.length === 0) {
+          cliError(result.errors.join(", "), 1, { name: "E_OUTLINE_FAILED" });
+          process.exit(1);
+        }
+        humanLine(`${result.filePath} (${result.language}, ~${result.estimatedTokens} tokens)
+`);
+        for (const sym of result.symbols) {
+          const prefix = sym.exported ? "export " : "";
+          humanLine(`${prefix}${sym.kind} ${sym.name} [${sym.startLine}-${sym.endLine}]`);
+          if (sym.children.length > 0) {
+            for (const child of sym.children) {
+              humanLine(`  ${child.kind} ${child.name} [${child.startLine}-${child.endLine}]`);
+            }
+          }
+        }
+      }
+    }),
+    /**
+     * Search subcommand — find symbols across codebase with relevance scoring.
+     *
+     * Walks directory tree, parses files by language, and matches symbols against
+     * query string with relevance scoring (exact > substring > fuzzy > path).
+     *
+     * Usage:
+     *   cleo code search parseFile --lang typescript --max 10
+     *   cleo code search smartOutline --path "src/**"
+     *
+     * @task T152, T157
+     */
+    search: defineCommand({
+      meta: { name: "search", description: "Search for symbols across codebase" },
+      args: {
+        query: { type: "positional", description: "Search query", required: true },
+        lang: { type: "string", description: "Filter by language (e.g. typescript, python)" },
+        max: { type: "string", description: "Max results (default: 20)" },
+        path: { type: "string", description: "File pattern filter (e.g. src/**)" }
+      },
+      async run({ args }) {
+        await requireTreeSitter();
+        const { smartSearch } = await import("@cleocode/core/internal");
+        const root = process.cwd();
+        const opts = {
+          rootDir: root,
+          maxResults: args.max ? Number.parseInt(args.max, 10) : 20,
+          filePattern: args.path
+        };
+        if (args.lang) {
+          opts.language = args.lang;
+        }
+        const results = smartSearch(args.query, opts);
+        if (results.length === 0) {
+          humanLine(`No symbols found matching "${args.query}"`);
+          return;
+        }
+        humanLine(`Found ${results.length} symbols:
+`);
+        for (const r of results) {
+          humanLine(
+            `  ${r.symbol.kind.padEnd(12)} ${r.symbol.name.padEnd(30)} ${r.symbol.filePath}:${r.symbol.startLine} (${r.matchType}, score: ${r.score})`
+          );
+        }
+      }
+    }),
+    /**
+     * Unfold subcommand — extract complete symbol source code.
+     *
+     * Takes file path + symbol name, finds the symbol via tree-sitter AST,
+     * and extracts complete source including JSDoc/docstrings, decorators,
+     * and full body. AST boundaries guarantee no truncation.
+     *
+     * Usage:
+     *   cleo code unfold packages/core/src/code/outline.ts smartOutline
+     *   cleo code unfold packages/cleo/src/cli/commands/code.ts codeCommand
+     *
+     * @task T153, T157
+     */
+    unfold: defineCommand({
+      meta: { name: "unfold", description: "Extract complete symbol source" },
+      args: {
+        file: { type: "positional", description: "Source file path", required: true },
+        symbol: {
+          type: "positional",
+          description: "Symbol name (e.g. parseFile or Class.method)",
+          required: true
+        }
+      },
+      async run({ args }) {
+        await requireTreeSitter();
+        const { smartUnfold } = await import("@cleocode/core/internal");
+        const { join } = await import("node:path");
+        const root = process.cwd();
+        const absPath = args.file.startsWith("/") ? args.file : join(root, args.file);
+        const result = smartUnfold(absPath, args.symbol, root);
+        if (!result.found) {
+          const errs = result.errors.length > 0 ? `: ${result.errors.join(", ")}` : "";
+          cliError(`Symbol "${args.symbol}" not found in ${args.file}${errs}`, 1, {
+            name: "E_NOT_FOUND"
+          });
+          process.exit(1);
+        }
+        humanLine(
+          `// ${result.filePath}:${result.startLine}-${result.endLine} (~${result.estimatedTokens} tokens)
+`
+        );
+        humanLine(result.source);
+      }
+    })
+  }
+});
+export {
+  codeCommand
+};
+//# sourceMappingURL=code-Z5CTMVTD.js.map

package/dist/cli/complete-UBOCOBRB.js

@@ -0,0 +1,34 @@
+(() => {
+  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 {
+  completeCommand,
+  completeCommandArgs,
+  completeDispatchParams
+} from "./chunk-EOPQFCSR.js";
+import "./chunk-PKKZPOOP.js";
+import "./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";
+export {
+  completeCommand,
+  completeCommandArgs,
+  completeDispatchParams
+};
+//# sourceMappingURL=complete-UBOCOBRB.js.map

package/dist/cli/complexity-BV2AGQRZ.js

@@ -0,0 +1,56 @@
+(() => {
+  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/complexity.ts
+var complexityEstimateCommand = defineCommand({
+  meta: { name: "estimate", description: "Estimate complexity of a task (small / medium / large)" },
+  args: { taskId: { type: "positional", description: "Task ID to estimate", required: true } },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "tasks",
+      "complexity.estimate",
+      { taskId: args.taskId },
+      { command: "complexity", operation: "tasks.complexity.estimate" }
+    );
+  }
+});
+var complexityCommand = defineCommand({
+  meta: { name: "complexity", description: "Task complexity analysis" },
+  subCommands: { estimate: complexityEstimateCommand },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  complexityCommand
+};
+//# sourceMappingURL=complexity-BV2AGQRZ.js.map

package/dist/cli/compliance-32PD5Y47.js

@@ -0,0 +1,276 @@
+(() => {
+  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/compliance.ts
+var summaryCommand = defineCommand({
+  meta: { name: "summary", description: "Aggregate compliance stats (default)" },
+  args: {
+    since: {
+      type: "string",
+      description: "Filter metrics from this date (ISO 8601)"
+    },
+    agent: {
+      type: "string",
+      description: "Filter by agent/skill ID"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "check",
+      "compliance.summary",
+      {
+        since: args.since,
+        agent: args.agent
+      },
+      { command: "compliance" }
+    );
+  }
+});
+var violationsCommand = defineCommand({
+  meta: { name: "violations", description: "List compliance violations" },
+  args: {
+    severity: {
+      type: "string",
+      description: "Filter by severity (low|medium|high|critical)"
+    },
+    since: {
+      type: "string",
+      description: "Filter from date"
+    },
+    agent: {
+      type: "string",
+      description: "Filter by agent ID"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "check",
+      "compliance.summary",
+      {
+        detail: true,
+        severity: args.severity,
+        since: args.since,
+        agent: args.agent
+      },
+      { command: "compliance" }
+    );
+  }
+});
+var trendCommand = defineCommand({
+  meta: { name: "trend", description: "Show compliance trend over N days" },
+  args: {
+    days: {
+      type: "positional",
+      description: "Number of days to include (default: 7)",
+      required: false
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "check",
+      "compliance.summary",
+      {
+        type: "trend",
+        days: args.days !== void 0 ? Number.parseInt(args.days, 10) : 7
+      },
+      { command: "compliance" }
+    );
+  }
+});
+var auditCommand = defineCommand({
+  meta: {
+    name: "audit",
+    description: "Check compliance for a specific task and its subtasks"
+  },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID to audit",
+      required: true
+    },
+    since: {
+      type: "string",
+      description: "Filter from date"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "check",
+      "compliance.summary",
+      {
+        type: "audit",
+        taskId: args.taskId,
+        since: args.since
+      },
+      { command: "compliance" }
+    );
+  }
+});
+var syncCommand = defineCommand({
+  meta: { name: "sync", description: "Sync project metrics to global aggregation" },
+  args: {
+    force: {
+      type: "boolean",
+      description: "Force full sync"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "check",
+      "compliance.sync",
+      {
+        force: args.force
+      },
+      { command: "compliance" }
+    );
+  }
+});
+var skillsCommand = defineCommand({
+  meta: { name: "skills", description: "Per-skill/agent reliability stats" },
+  args: {
+    global: {
+      type: "boolean",
+      description: "Use global metrics file"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "check",
+      "compliance.summary",
+      {
+        type: "skills",
+        global: args.global
+      },
+      { command: "compliance" }
+    );
+  }
+});
+var valueCommand = defineCommand({
+  meta: { name: "value", description: "VALUE PROOF: Token savings & validation impact" },
+  args: {
+    days: {
+      type: "positional",
+      description: "Number of days to include (default: 7)",
+      required: false
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "check",
+      "compliance.summary",
+      {
+        type: "value",
+        days: args.days !== void 0 ? Number.parseInt(args.days, 10) : 7
+      },
+      { command: "compliance" }
+    );
+  }
+});
+var recordCommand = defineCommand({
+  meta: {
+    name: "record",
+    description: "Record a compliance check result for a task (pass|fail|warning)"
+  },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID to record result for",
+      required: true
+    },
+    result: {
+      type: "positional",
+      description: "Result value (pass|fail|warning)",
+      required: true
+    },
+    protocol: {
+      type: "string",
+      description: "Protocol name the check applies to (e.g. implementation)"
+    },
+    violation: {
+      type: "string",
+      description: 'Add a violation as "code:severity:message"'
+    }
+  },
+  async run({ args }) {
+    const rawViolation = args.violation;
+    const rawViolations = rawViolation !== void 0 ? [rawViolation] : [];
+    const violations = rawViolations.map((v) => {
+      const [code, severity, ...rest] = v.split(":");
+      return {
+        code: code ?? "",
+        severity: severity === "error" || severity === "warning" ? severity : "error",
+        message: rest.join(":")
+      };
+    }).filter((v) => v.code);
+    await dispatchFromCli(
+      "mutate",
+      "check",
+      "compliance.record",
+      {
+        taskId: args.taskId,
+        result: args.result,
+        protocol: args.protocol,
+        violations: violations.length > 0 ? violations : void 0
+      },
+      { command: "compliance", operation: "check.compliance.record" }
+    );
+  }
+});
+var complianceCommand = defineCommand({
+  meta: {
+    name: "compliance",
+    description: "Monitor and report compliance metrics for orchestrator and agent outputs"
+  },
+  subCommands: {
+    summary: summaryCommand,
+    violations: violationsCommand,
+    trend: trendCommand,
+    audit: auditCommand,
+    sync: syncCommand,
+    skills: skillsCommand,
+    value: valueCommand,
+    record: recordCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  complianceCommand
+};
+//# sourceMappingURL=compliance-32PD5Y47.js.map