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

package/dist/cli/admin-YMU55YCU.js

@@ -0,0 +1,341 @@
+(() => {
+  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,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+import "./chunk-QKMBWYAS.js";
+import {
+  cliError
+} from "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-D7BAQNV2.js";
+import "./chunk-TYC7G5LF.js";
+
+// packages/cleo/src/cli/commands/admin.ts
+var versionCommand = defineCommand({
+  meta: { name: "version", description: "Show CLEO version" },
+  async run() {
+    await dispatchFromCli("query", "admin", "version", {}, { command: "admin" });
+  }
+});
+var healthCommand = defineCommand({
+  meta: { name: "health", description: "Run system health check" },
+  args: {
+    detailed: {
+      type: "boolean",
+      description: "Show detailed results"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "admin",
+      "health",
+      { detailed: args.detailed },
+      { command: "admin" }
+    );
+  }
+});
+var statsCommand = defineCommand({
+  meta: { name: "stats", description: "Show project statistics" },
+  args: {
+    period: {
+      type: "string",
+      description: "Time period in days"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "admin",
+      "stats",
+      { period: args.period ? Number(args.period) : void 0 },
+      { command: "admin" }
+    );
+  }
+});
+var runtimeCommand = defineCommand({
+  meta: { name: "runtime", description: "Show runtime diagnostics" },
+  args: {
+    detailed: {
+      type: "boolean",
+      description: "Show detailed runtime info"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "admin",
+      "runtime",
+      { detailed: args.detailed },
+      { command: "admin" }
+    );
+  }
+});
+var smokeCommand = defineCommand({
+  meta: {
+    name: "smoke",
+    description: "Run operational smoke tests across all domains, or probe ADR-049 invariants for a named provider (--provider)"
+  },
+  args: {
+    provider: {
+      type: "string",
+      description: "Probe harness sovereignty invariants for a specific provider adapter (ADR-049)"
+    }
+  },
+  async run({ args }) {
+    const provider = args.provider;
+    if (provider) {
+      await dispatchFromCli(
+        "query",
+        "admin",
+        "smoke.provider",
+        { provider },
+        { command: "admin smoke", operation: "admin.smoke.provider" }
+      );
+    } else {
+      await dispatchFromCli("query", "admin", "smoke", {}, { command: "admin" });
+    }
+  }
+});
+var pathsCommand = defineCommand({
+  meta: {
+    name: "paths",
+    description: "Report all CleoOS paths (project + global hub) and scaffolding status"
+  },
+  async run() {
+    await dispatchFromCli("query", "admin", "paths", {}, { command: "admin" });
+  }
+});
+var scaffoldHubCommand = defineCommand({
+  meta: {
+    name: "scaffold-hub",
+    description: "Create CleoOS Hub dirs (global-recipes, pi-extensions, cant-workflows, agents) and seed starter justfile"
+  },
+  async run() {
+    await dispatchFromCli("mutate", "admin", "scaffold-hub", {}, { command: "admin" });
+  }
+});
+var cleanupCommand = defineCommand({
+  meta: { name: "cleanup", description: "Purge stale CLEO data (backups, logs, archive entries)" },
+  args: {
+    target: {
+      type: "string",
+      description: "What to clean: backups | logs | archive | sessions",
+      required: true
+    },
+    "older-than": {
+      type: "string",
+      description: "Remove entries older than this duration (e.g. 30d, 6m, 1y)"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview what would be removed without making changes"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "admin",
+      "cleanup",
+      {
+        target: args.target,
+        olderThan: args["older-than"],
+        dryRun: args["dry-run"] === true
+      },
+      { command: "admin cleanup", operation: "admin.cleanup" }
+    );
+  }
+});
+var jobListCommand = defineCommand({
+  meta: { name: "list", description: "List all background jobs (default)" },
+  args: {
+    status: {
+      type: "string",
+      description: "Filter by job status (pending, running, done, failed, cancelled)"
+    },
+    limit: {
+      type: "string",
+      description: "Maximum jobs to return",
+      default: "20"
+    },
+    offset: {
+      type: "string",
+      description: "Skip N jobs",
+      default: "0"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "admin",
+      "job",
+      {
+        action: "list",
+        status: args.status,
+        limit: args.limit ? Number(args.limit) : 20,
+        offset: args.offset ? Number(args.offset) : 0
+      },
+      { command: "admin job list", operation: "admin.job" }
+    );
+  }
+});
+var jobStatusCommand = defineCommand({
+  meta: { name: "status", description: "Show status of a specific background job" },
+  args: {
+    jobId: {
+      type: "positional",
+      description: "Job ID to inspect",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "admin",
+      "job",
+      { action: "status", jobId: args.jobId },
+      { command: "admin job status", operation: "admin.job" }
+    );
+  }
+});
+var jobCancelCommand = defineCommand({
+  meta: { name: "cancel", description: "Cancel a running background job" },
+  args: {
+    jobId: {
+      type: "positional",
+      description: "Job ID to cancel",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "admin",
+      "job.cancel",
+      { jobId: args.jobId },
+      { command: "admin job cancel", operation: "admin.job.cancel" }
+    );
+  }
+});
+var jobCommand = defineCommand({
+  meta: { name: "job", description: "Inspect background jobs managed by the job manager" },
+  subCommands: {
+    list: jobListCommand,
+    status: jobStatusCommand,
+    cancel: jobCancelCommand
+  },
+  async run({ rawArgs }) {
+    const hasSubCmd = rawArgs.some((a) => ["list", "status", "cancel"].includes(a));
+    if (!hasSubCmd) {
+      await dispatchFromCli(
+        "query",
+        "admin",
+        "job",
+        { action: "list", limit: 20, offset: 0 },
+        { command: "admin job list", operation: "admin.job" }
+      );
+    }
+  }
+});
+var installGlobalCommand = defineCommand({
+  meta: {
+    name: "install-global",
+    description: "Refresh global CLEO setup (provider files, configs, ~/.agents/AGENTS.md)"
+  },
+  async run() {
+    await dispatchFromCli(
+      "mutate",
+      "admin",
+      "install.global",
+      {},
+      { command: "admin install-global", operation: "admin.install.global" }
+    );
+  }
+});
+var contextInjectCommand = defineCommand({
+  meta: {
+    name: "context-inject",
+    description: "Inject protocol content into session context (e.g. cleo-base, ct-orchestrator, ct-cleo)"
+  },
+  args: {
+    protocolType: {
+      type: "positional",
+      description: "Protocol type to inject",
+      required: true
+    },
+    task: {
+      type: "string",
+      description: "Scope injection to a specific task ID"
+    },
+    variant: {
+      type: "string",
+      description: "Select a named protocol variant"
+    }
+  },
+  async run({ args }) {
+    const protocolType = args.protocolType;
+    if (!protocolType || protocolType.trim() === "") {
+      cliError("missing required argument <protocolType>", 1, {
+        name: "E_VALIDATION",
+        fix: "Usage: cleo admin context-inject <protocolType> [--task <id>] [--variant <variant>]"
+      });
+      process.exit(1);
+    }
+    await dispatchFromCli(
+      "mutate",
+      "admin",
+      "context.inject",
+      {
+        protocolType,
+        taskId: args.task,
+        variant: args.variant
+      },
+      { command: "admin context-inject", operation: "admin.context.inject" }
+    );
+  }
+});
+var adminCommand = defineCommand({
+  meta: { name: "admin", description: "System administration and diagnostics" },
+  subCommands: {
+    version: versionCommand,
+    health: healthCommand,
+    stats: statsCommand,
+    runtime: runtimeCommand,
+    smoke: smokeCommand,
+    paths: pathsCommand,
+    "scaffold-hub": scaffoldHubCommand,
+    cleanup: cleanupCommand,
+    job: jobCommand,
+    "install-global": installGlobalCommand,
+    "context-inject": contextInjectCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  adminCommand
+};
+//# sourceMappingURL=admin-YMU55YCU.js.map

package/dist/cli/adr-XESRMFMP.js

@@ -0,0 +1,172 @@
+(() => {
+  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,
+  showUsage
+} 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/adr.ts
+var validateCommand = defineCommand({
+  meta: {
+    name: "validate",
+    description: "Validate frontmatter on all .cleo/adrs/*.md files against ADR-017 schema"
+  },
+  async run() {
+    await dispatchFromCli(
+      "mutate",
+      "admin",
+      "adr.sync",
+      { validate: true },
+      { command: "adr validate", operation: "admin.adr.sync" }
+    );
+  }
+});
+var listCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "List ADRs from .cleo/adrs/"
+  },
+  args: {
+    status: {
+      type: "string",
+      description: "Filter by status: proposed | accepted | superseded | deprecated"
+    },
+    since: {
+      type: "string",
+      description: "Filter to ADRs created on or after YYYY-MM-DD"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "admin",
+      "adr.find",
+      {
+        status: args.status,
+        since: args.since
+      },
+      { command: "adr list", operation: "admin.adr.find" }
+    );
+  }
+});
+var showCommand = defineCommand({
+  meta: {
+    name: "show",
+    description: "Show full details for a single ADR (e.g., cleo adr show ADR-017)"
+  },
+  args: {
+    adrId: {
+      type: "positional",
+      description: "ADR identifier (e.g., ADR-017)",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "admin",
+      "adr.show",
+      { adrId: args.adrId },
+      { command: "adr show", operation: "admin.adr.show" }
+    );
+  }
+});
+var syncCommand = defineCommand({
+  meta: {
+    name: "sync",
+    description: "Sync .cleo/adrs/ markdown files into the architecture_decisions DB table"
+  },
+  async run() {
+    await dispatchFromCli(
+      "mutate",
+      "admin",
+      "adr.sync",
+      {},
+      { command: "adr sync", operation: "admin.adr.sync" }
+    );
+  }
+});
+var findCommand = defineCommand({
+  meta: {
+    name: "find",
+    description: "Fuzzy search ADRs by title, summary, keywords, and topics"
+  },
+  args: {
+    query: {
+      type: "positional",
+      description: "Search query string",
+      required: true
+    },
+    topics: {
+      type: "string",
+      description: "Filter by topics (comma-separated domain tags)"
+    },
+    keywords: {
+      type: "string",
+      description: "Filter by keywords (comma-separated tags)"
+    },
+    status: {
+      type: "string",
+      description: "Filter by status: proposed | accepted | superseded | deprecated"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "admin",
+      "adr.find",
+      {
+        query: args.query,
+        topics: args.topics,
+        keywords: args.keywords,
+        status: args.status
+      },
+      { command: "adr find", operation: "admin.adr.find" }
+    );
+  }
+});
+var adrCommand = defineCommand({
+  meta: {
+    name: "adr",
+    description: "Manage and validate Architecture Decision Records in .cleo/adrs/"
+  },
+  subCommands: {
+    validate: validateCommand,
+    list: listCommand,
+    show: showCommand,
+    sync: syncCommand,
+    find: findCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  adrCommand
+};
+//# sourceMappingURL=adr-XESRMFMP.js.map