@cleocode/cleo 2026.10.2 → 2026.10.4

package/dist/cli/detect-drift-UL2JTPUK.js

@@ -0,0 +1,408 @@
+(() => {
+  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 {
+  CLEO_DIR_NAME,
+  CLEO_INJECTION_MD,
+  TEMPLATES_SUBDIR
+} from "./chunk-OGV57L4J.js";
+import {
+  cliOutput
+} from "./chunk-3ZO3M37V.js";
+import "./chunk-6JSJNYH2.js";
+
+// packages/cleo/src/cli/commands/detect-drift.ts
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getErrorMessage } from "@cleocode/contracts";
+function findProjectRoot() {
+  let currentDir = process.cwd();
+  while (currentDir !== "/") {
+    if (existsSync(join(currentDir, "package.json"))) {
+      return currentDir;
+    }
+    const parent = dirname(currentDir);
+    if (parent === currentDir) break;
+    currentDir = parent;
+  }
+  return process.cwd();
+}
+var detectDriftCommand = defineCommand({
+  meta: {
+    name: "detect-drift",
+    description: "Detect documentation drift against TypeScript source of truth"
+  },
+  async run() {
+    const projectRoot = findProjectRoot();
+    const isCleoRepo = existsSync(join(projectRoot, "packages", "cleo", "src"));
+    const cleoSrcRoot = isCleoRepo ? join(projectRoot, "packages", "cleo", "src") : join(projectRoot, "src");
+    const safeRead = (filePath) => {
+      try {
+        return readFileSync(filePath, "utf-8");
+      } catch {
+        return "";
+      }
+    };
+    if (!isCleoRepo) {
+      const userResult = {
+        summary: { totalChecks: 1, passed: 0, warnings: 0, errors: 0, exitCode: 0 },
+        checks: [],
+        recommendations: []
+      };
+      const injPath = join(projectRoot, CLEO_DIR_NAME, TEMPLATES_SUBDIR, CLEO_INJECTION_MD);
+      if (existsSync(injPath)) {
+        const content = safeRead(injPath);
+        userResult.checks.push({
+          name: "Agent injection",
+          status: content.length > 100 ? "pass" : "warn",
+          message: content.length > 100 ? "Agent injection template exists" : "Template appears incomplete",
+          issues: []
+        });
+        userResult.summary.passed = content.length > 100 ? 1 : 0;
+        userResult.summary.warnings = content.length > 100 ? 0 : 1;
+      } else {
+        userResult.checks.push({
+          name: "Agent injection",
+          status: "warn",
+          message: "No injection template found \u2014 run `cleo init` to create one",
+          issues: []
+        });
+        userResult.summary.warnings = 1;
+      }
+      userResult.summary.exitCode = userResult.summary.errors > 0 ? 2 : userResult.summary.warnings > 0 ? 1 : 0;
+      userResult.recommendations.push(
+        "detect-drift source checks only apply to the CLEO monorepo. Run from the cleo source tree for full analysis."
+      );
+      cliOutput(userResult, { command: "detect-drift" });
+      process.exit(userResult.summary.exitCode);
+    }
+    const result = {
+      summary: {
+        totalChecks: 0,
+        passed: 0,
+        warnings: 0,
+        errors: 0,
+        exitCode: 0
+      },
+      checks: [],
+      recommendations: []
+    };
+    const addCheck = (name, status, message, issues = []) => {
+      result.checks.push({ name, status, message, issues });
+      result.summary.totalChecks++;
+      if (status === "pass") result.summary.passed++;
+      if (status === "warn") {
+        result.summary.warnings++;
+        result.summary.exitCode = Math.max(result.summary.exitCode, 1);
+      }
+      if (status === "fail") {
+        result.summary.errors++;
+        result.summary.exitCode = 2;
+      }
+    };
+    try {
+      const specPath = join(projectRoot, "docs", "specs", "CLEO-OPERATION-CONSTITUTION.md");
+      const registryPath = join(cleoSrcRoot, "dispatch", "registry.ts");
+      const dispatchDomainsDir = join(cleoSrcRoot, "dispatch", "domains");
+      if (!existsSync(specPath)) {
+        addCheck("Gateway-to-spec sync", "fail", "CLEO-OPERATION-CONSTITUTION.md missing", [
+          {
+            severity: "error",
+            category: "spec",
+            message: "Operations reference specification not found",
+            file: specPath,
+            recommendation: "Create docs/specs/CLEO-OPERATION-CONSTITUTION.md with canonical operation definitions"
+          }
+        ]);
+      } else if (!existsSync(registryPath) || !existsSync(dispatchDomainsDir)) {
+        addCheck("Gateway-to-spec sync", "fail", "Dispatch registry or domains missing", [
+          {
+            severity: "error",
+            category: "implementation",
+            message: "Dispatch registry or domains directory not found",
+            file: registryPath,
+            recommendation: "Verify packages/cleo/src/dispatch/registry.ts and packages/cleo/src/dispatch/domains/ exist"
+          }
+        ]);
+      } else {
+        const specContent = safeRead(specPath);
+        const registryContent = safeRead(registryPath);
+        const specOpsMatch = specContent.match(/## `([a-z_]+)`/g) || [];
+        const specOps = specOpsMatch.map((m) => m.replace(/## `|`/g, ""));
+        const registryOpsMatch = registryContent.match(/operation:\s*'([a-z_.]+)'/g) || [];
+        const registryOps = registryOpsMatch.map((m) => m.replace(/operation:\s*'|'/g, ""));
+        const specOnly = specOps.filter((op) => !registryOps.includes(op));
+        const gatewayOnly = registryOps.filter((op) => !specOps.includes(op));
+        if (specOnly.length === 0 && gatewayOnly.length === 0) {
+          addCheck("Gateway-to-spec sync", "pass", `All ${specOps.length} operations synchronized`);
+        } else {
+          const issues = [];
+          if (specOnly.length > 0) {
+            issues.push({
+              severity: "warning",
+              category: "spec-coverage",
+              message: `${specOnly.length} operations in spec but not in gateways: ${specOnly.join(", ")}`,
+              recommendation: "Add missing operation handlers to dispatch domains or remove from spec"
+            });
+          }
+          if (gatewayOnly.length > 0) {
+            issues.push({
+              severity: "warning",
+              category: "implementation-coverage",
+              message: `${gatewayOnly.length} operations in gateways but not in spec: ${gatewayOnly.join(", ")}`,
+              recommendation: "Document missing operations in CLEO-OPERATIONS-REFERENCE.md"
+            });
+          }
+          addCheck(
+            "Gateway-to-spec sync",
+            "warn",
+            `Found ${specOnly.length + gatewayOnly.length} operation mismatches`,
+            issues
+          );
+        }
+      }
+    } catch (e) {
+      addCheck("Gateway-to-spec sync", "fail", `Error: ${getErrorMessage(e)}`, [
+        {
+          severity: "error",
+          category: "system",
+          message: getErrorMessage(e),
+          recommendation: "Check file permissions and paths"
+        }
+      ]);
+    }
+    try {
+      const cliDir = join(cleoSrcRoot, "cli", "commands");
+      const coreDir = isCleoRepo ? join(projectRoot, "packages", "core", "src") : join(projectRoot, "src", "core");
+      if (!existsSync(cliDir)) {
+        addCheck("CLI-to-core sync", "fail", "CLI commands directory missing", [
+          {
+            severity: "error",
+            category: "structure",
+            message: `${cliDir} directory not found`,
+            recommendation: "Verify TypeScript source structure is intact"
+          }
+        ]);
+      } else if (!existsSync(coreDir)) {
+        addCheck("CLI-to-core sync", "fail", "Core directory missing", [
+          {
+            severity: "error",
+            category: "structure",
+            message: `${coreDir} directory not found`,
+            recommendation: "Verify TypeScript source structure is intact"
+          }
+        ]);
+      } else {
+        const files = readdirSync(cliDir).filter((f) => f.endsWith(".ts") && !f.includes(".test."));
+        addCheck("CLI-to-core sync", "pass", `Found ${files.length} CLI command implementations`);
+      }
+    } catch (e) {
+      addCheck("CLI-to-core sync", "fail", `Error: ${getErrorMessage(e)}`);
+    }
+    try {
+      const domainsDir = join(cleoSrcRoot, "dispatch", "domains");
+      if (!existsSync(domainsDir)) {
+        addCheck("Domain handler coverage", "fail", "Dispatch domains directory missing", [
+          {
+            severity: "error",
+            category: "structure",
+            message: `${domainsDir} not found`,
+            recommendation: "Verify dispatch domain handlers are in place"
+          }
+        ]);
+      } else {
+        const files = readdirSync(domainsDir).filter((f) => f.endsWith(".ts"));
+        addCheck("Domain handler coverage", "pass", `Found ${files.length} domain handlers`);
+      }
+    } catch (e) {
+      addCheck("Domain handler coverage", "fail", `Error: ${getErrorMessage(e)}`);
+    }
+    try {
+      const matrixPath = join(cleoSrcRoot, "dispatch", "lib", "capability-matrix.ts");
+      if (!existsSync(matrixPath)) {
+        addCheck("Capability matrix", "fail", "Capability matrix missing", [
+          {
+            severity: "error",
+            category: "configuration",
+            message: `${matrixPath} not found`,
+            recommendation: "Create capability matrix to document supported operations"
+          }
+        ]);
+      } else {
+        addCheck("Capability matrix", "pass", "Capability matrix exists");
+      }
+    } catch (e) {
+      addCheck("Capability matrix", "fail", `Error: ${getErrorMessage(e)}`);
+    }
+    try {
+      const schemaPath = join(projectRoot, "src", "store", "schema.ts");
+      if (!existsSync(schemaPath)) {
+        addCheck("Schema validation", "fail", "Schema definition missing", [
+          {
+            severity: "error",
+            category: "data-model",
+            message: "src/store/schema.ts not found",
+            recommendation: "Create schema definition for database tables"
+          }
+        ]);
+      } else {
+        const content = safeRead(schemaPath);
+        const tableCount = (content.match(/CREATE TABLE/g) || []).length;
+        if (tableCount === 0) {
+          addCheck(
+            "Schema validation",
+            "warn",
+            "Schema file exists but no CREATE TABLE statements",
+            [
+              {
+                severity: "warning",
+                category: "data-model",
+                message: "No SQL table definitions found in schema.ts",
+                recommendation: "Add CREATE TABLE statements for all database entities"
+              }
+            ]
+          );
+        } else {
+          addCheck("Schema validation", "pass", `Schema defines ${tableCount} tables`);
+        }
+      }
+    } catch (e) {
+      addCheck("Schema validation", "fail", `Error: ${getErrorMessage(e)}`);
+    }
+    try {
+      const visionPath = join(projectRoot, "docs", "concepts", "CLEO-VISION.md");
+      const specPath = join(projectRoot, "docs", "specs", "CLEO-PORTABLE-PROJECT-BRAIN-SPEC.md");
+      const issues = [];
+      if (!existsSync(visionPath)) {
+        issues.push({
+          severity: "error",
+          category: "vision",
+          message: "Vision document missing",
+          file: visionPath,
+          recommendation: "Create docs/concepts/CLEO-VISION.md with project vision"
+        });
+      }
+      if (!existsSync(specPath)) {
+        issues.push({
+          severity: "error",
+          category: "spec",
+          message: "Portable Brain spec missing",
+          file: specPath,
+          recommendation: "Create docs/specs/CLEO-PORTABLE-PROJECT-BRAIN-SPEC.md with canonical pillars"
+        });
+      }
+      if (issues.length > 0) {
+        addCheck("Canonical identity", "fail", "Canonical documents missing", issues);
+      } else {
+        const specContent = safeRead(specPath);
+        const requiredPillars = [
+          "Portable Memory",
+          "Provenance by Default",
+          "Interoperable Interfaces",
+          "Deterministic Safety",
+          "Cognitive Retrieval"
+        ];
+        const missingPillars = requiredPillars.filter((p) => !specContent.includes(p));
+        if (missingPillars.length > 0) {
+          addCheck(
+            "Canonical identity",
+            "fail",
+            `Missing ${missingPillars.length} canonical pillars`,
+            [
+              {
+                severity: "error",
+                category: "vision",
+                message: `Missing pillars: ${missingPillars.join(", ")}`,
+                file: specPath,
+                recommendation: "Add all five canonical pillars to CLEO-PORTABLE-PROJECT-BRAIN-SPEC.md"
+              }
+            ]
+          );
+        } else {
+          addCheck("Canonical identity", "pass", "All canonical pillars documented");
+        }
+      }
+    } catch (e) {
+      addCheck("Canonical identity", "fail", `Error: ${getErrorMessage(e)}`);
+    }
+    try {
+      const injectionPath = join(projectRoot, CLEO_DIR_NAME, TEMPLATES_SUBDIR, CLEO_INJECTION_MD);
+      if (!existsSync(injectionPath)) {
+        addCheck("Agent injection", "fail", "Agent injection template missing", [
+          {
+            severity: "error",
+            category: "agent-support",
+            message: "CLEO-INJECTION.md not found",
+            file: injectionPath,
+            recommendation: "Create agent injection template or run cleo init"
+          }
+        ]);
+      } else {
+        const content = safeRead(injectionPath);
+        if (content.length < 100) {
+          addCheck("Agent injection", "warn", "Agent injection template appears incomplete", [
+            {
+              severity: "warning",
+              category: "agent-support",
+              message: "Template file is unusually short",
+              recommendation: "Verify template contains required agent instructions"
+            }
+          ]);
+        } else {
+          addCheck("Agent injection", "pass", "Agent injection template exists");
+        }
+      }
+    } catch (e) {
+      addCheck("Agent injection", "fail", `Error: ${getErrorMessage(e)}`);
+    }
+    try {
+      const exitCodesPath = join(cleoSrcRoot, "dispatch", "lib", "exit-codes.ts");
+      if (!existsSync(exitCodesPath)) {
+        addCheck("Exit codes", "fail", "Exit codes definition missing", [
+          {
+            severity: "error",
+            category: "protocol",
+            message: `${exitCodesPath} not found`,
+            recommendation: "Create exit codes definition for CLI protocol compliance"
+          }
+        ]);
+      } else {
+        const content = safeRead(exitCodesPath);
+        const codeCount = (content.match(/= \d+/g) || []).length;
+        addCheck("Exit codes", "pass", `${codeCount} exit codes defined`);
+      }
+    } catch (e) {
+      addCheck("Exit codes", "fail", `Error: ${getErrorMessage(e)}`);
+    }
+    if (result.summary.errors > 0) {
+      result.recommendations.push("Address all ERROR-level issues before proceeding");
+    }
+    if (result.summary.warnings > 0) {
+      result.recommendations.push("Review WARNING-level issues for documentation improvements");
+    }
+    if (result.summary.errors === 0 && result.summary.warnings === 0) {
+      result.recommendations.push("Documentation is synchronized with implementation");
+    }
+    cliOutput(result, { command: "detect-drift" });
+    process.exit(result.summary.exitCode);
+  }
+});
+export {
+  detectDriftCommand
+};
+//# sourceMappingURL=detect-drift-UL2JTPUK.js.map

package/dist/cli/diagnostics-TI5QAZXR.js

@@ -0,0 +1,132 @@
+(() => {
+  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 {
+  negatedFlag
+} from "./chunk-47JYZAMS.js";
+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/diagnostics.ts
+var enableCommand = defineCommand({
+  meta: {
+    name: "enable",
+    description: "Opt in to anonymous command telemetry for self-improvement analysis"
+  },
+  async run() {
+    await dispatchFromCli("mutate", "diagnostics", "enable", {}, { command: "diagnostics" });
+  }
+});
+var disableCommand = defineCommand({
+  meta: {
+    name: "disable",
+    description: "Opt out of telemetry collection (existing data is preserved)"
+  },
+  async run() {
+    await dispatchFromCli("mutate", "diagnostics", "disable", {}, { command: "diagnostics" });
+  }
+});
+var statusCommand = defineCommand({
+  meta: { name: "status", description: "Show telemetry opt-in state and database path" },
+  async run() {
+    await dispatchFromCli("query", "diagnostics", "status", {}, { command: "diagnostics" });
+  }
+});
+var analyzeCommand = defineCommand({
+  meta: {
+    name: "analyze",
+    description: "Aggregate telemetry patterns: top failing commands, slowest commands, BRAIN observations"
+  },
+  args: {
+    days: {
+      type: "string",
+      description: "Analysis window in days (default: 30)",
+      alias: "d"
+    },
+    "no-brain": {
+      type: "boolean",
+      description: "Skip pushing high-signal patterns to BRAIN"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "diagnostics",
+      "analyze",
+      {
+        days: args.days !== void 0 ? Number.parseInt(args.days, 10) : 30,
+        noBrain: negatedFlag(args, "brain")
+      },
+      { command: "diagnostics" }
+    );
+  }
+});
+var exportCommand = defineCommand({
+  meta: {
+    name: "export",
+    description: "Export all telemetry events as a JSON array for external analysis"
+  },
+  args: {
+    days: {
+      type: "string",
+      description: "Limit to last N days (default: all)",
+      alias: "d"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "diagnostics",
+      "export",
+      {
+        days: args.days !== void 0 ? Number.parseInt(args.days, 10) : void 0
+      },
+      { command: "diagnostics" }
+    );
+  }
+});
+var diagnosticsCommand = defineCommand({
+  meta: {
+    name: "diagnostics",
+    description: "Autonomous self-improvement telemetry \u2014 opt-in command analytics that feed BRAIN observations"
+  },
+  subCommands: {
+    enable: enableCommand,
+    disable: disableCommand,
+    status: statusCommand,
+    analyze: analyzeCommand,
+    export: exportCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  diagnosticsCommand
+};
+//# sourceMappingURL=diagnostics-TI5QAZXR.js.map