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

package/dist/cli/tools-BI74W7VE.js

@@ -0,0 +1,652 @@
+(() => {
+  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 {
+  routeByParam
+} from "./chunk-QY76BRUZ.js";
+import {
+  dispatchMeta,
+  errorResult,
+  getListParams,
+  handleErrorResult,
+  unsupportedOp,
+  wrapResult
+} from "./chunk-XHRZ7OYZ.js";
+
+// packages/cleo/src/dispatch/domains/tools.ts
+import { getLogger, getProjectRoot } from "@cleocode/core";
+import {
+  codeOutline,
+  codeParse,
+  codeSearch,
+  codeUnfold,
+  toolsAdapterActivate,
+  toolsAdapterDetect,
+  toolsAdapterDispose,
+  toolsAdapterHealth,
+  toolsAdapterList,
+  toolsAdapterShow,
+  toolsIssueDiagnostics,
+  toolsProviderDetect,
+  toolsProviderHooks,
+  toolsProviderInject,
+  toolsProviderInjectStatus,
+  toolsProviderList,
+  toolsProviderSupports,
+  toolsSkillCatalogInfo,
+  toolsSkillCatalogProfiles,
+  toolsSkillCatalogProtocols,
+  toolsSkillCatalogResources,
+  toolsSkillDependencies,
+  toolsSkillDispatch,
+  toolsSkillDoctorDiagnose,
+  toolsSkillFederatedFind,
+  toolsSkillFind,
+  toolsSkillImportHermes,
+  toolsSkillInstall,
+  toolsSkillList,
+  toolsSkillMigrate,
+  toolsSkillPrecedenceResolve,
+  toolsSkillPrecedenceShow,
+  toolsSkillPruneTelemetry,
+  toolsSkillRefresh,
+  toolsSkillShow,
+  toolsSkillSpawnProviders,
+  toolsSkillStats,
+  toolsSkillUninstall,
+  toolsSkillVerify
+} from "@cleocode/core/internal";
+var ToolsHandler = class {
+  get projectRoot() {
+    return getProjectRoot();
+  }
+  // -----------------------------------------------------------------------
+  // DomainHandler interface
+  // -----------------------------------------------------------------------
+  async query(operation, params) {
+    const startTime = Date.now();
+    try {
+      if (operation.startsWith("issue.")) {
+        return this.queryIssue(operation.slice("issue.".length), params, startTime);
+      }
+      if (operation.startsWith("skill.")) {
+        return await this.querySkill(operation.slice("skill.".length), params, startTime);
+      }
+      if (operation.startsWith("provider.")) {
+        return await this.queryProvider(operation.slice("provider.".length), params, startTime);
+      }
+      if (operation.startsWith("adapter.")) {
+        return this.queryAdapter(operation.slice("adapter.".length), params, startTime);
+      }
+      if (operation.startsWith("code.")) {
+        return this.queryCode(operation.slice("code.".length), params, startTime);
+      }
+      return unsupportedOp("query", "tools", operation, startTime);
+    } catch (error) {
+      return this.handleError("query", "tools", operation, error, startTime);
+    }
+  }
+  async mutate(operation, params) {
+    const startTime = Date.now();
+    try {
+      if (operation.startsWith("issue.")) {
+        return this.mutateIssue(operation.slice("issue.".length), params, startTime);
+      }
+      if (operation.startsWith("skill.")) {
+        return await this.mutateSkill(operation.slice("skill.".length), params, startTime);
+      }
+      if (operation.startsWith("provider.")) {
+        return await this.mutateProvider(operation.slice("provider.".length), params, startTime);
+      }
+      if (operation.startsWith("adapter.")) {
+        return await this.mutateAdapter(operation.slice("adapter.".length), params, startTime);
+      }
+      return unsupportedOp("mutate", "tools", operation, startTime);
+    } catch (error) {
+      return this.handleError("mutate", "tools", operation, error, startTime);
+    }
+  }
+  getSupportedOperations() {
+    return {
+      query: [
+        // issue
+        "issue.diagnostics",
+        // skill
+        "skill.list",
+        "skill.show",
+        "skill.find",
+        "skill.federated.find",
+        "skill.dispatch",
+        "skill.verify",
+        "skill.dependencies",
+        "skill.spawn.providers",
+        "skill.catalog",
+        "skill.precedence",
+        "skill.doctor.diagnose",
+        "skill.stats",
+        // provider
+        "provider.list",
+        "provider.detect",
+        "provider.inject.status",
+        "provider.supports",
+        "provider.hooks",
+        // adapter
+        "adapter.list",
+        "adapter.show",
+        "adapter.detect",
+        "adapter.health"
+      ],
+      mutate: [
+        // skill
+        "skill.install",
+        "skill.uninstall",
+        "skill.refresh",
+        "skill.import.hermes",
+        "skill.migrate",
+        "skill.prune.telemetry",
+        // provider
+        "provider.inject",
+        // adapter
+        "adapter.activate",
+        "adapter.dispose"
+      ]
+    };
+  }
+  // -----------------------------------------------------------------------
+  // Issue queries
+  // -----------------------------------------------------------------------
+  queryIssue(sub, _params, startTime) {
+    switch (sub) {
+      case "diagnostics": {
+        const result = toolsIssueDiagnostics();
+        return wrapResult(result, "query", "tools", "issue.diagnostics", startTime);
+      }
+      default:
+        return unsupportedOp("query", "tools", `issue.${sub}`, startTime);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Issue mutations (plugin-extracted)
+  // -----------------------------------------------------------------------
+  mutateIssue(sub, _params, startTime) {
+    return unsupportedOp("mutate", "tools", `issue.${sub}`, startTime);
+  }
+  // -----------------------------------------------------------------------
+  // Skill queries
+  // -----------------------------------------------------------------------
+  async querySkill(sub, params, startTime) {
+    switch (sub) {
+      case "list": {
+        const { limit, offset } = getListParams(params);
+        const result = await toolsSkillList(limit, offset);
+        if (!result.success) {
+          return wrapResult(result, "query", "tools", "skill.list", startTime);
+        }
+        return {
+          meta: dispatchMeta("query", "tools", "skill.list", startTime),
+          success: true,
+          data: {
+            skills: result.data.skills,
+            count: result.data.count,
+            total: result.data.total,
+            filtered: result.data.filtered
+          },
+          page: result.data.page
+        };
+      }
+      case "show": {
+        const name = params?.name;
+        if (!name) {
+          return errorResult(
+            "query",
+            "tools",
+            "skill.show",
+            "E_INVALID_INPUT",
+            "Missing required parameter: name",
+            startTime
+          );
+        }
+        const result = await toolsSkillShow(name);
+        return wrapResult(result, "query", "tools", "skill.show", startTime);
+      }
+      case "find": {
+        const query = params?.query;
+        const result = await toolsSkillFind(query);
+        return wrapResult(result, "query", "tools", "skill.find", startTime);
+      }
+      case "federated.find":
+      case "federated-find": {
+        const query = params?.query;
+        const federated = params?.federated === true;
+        const rawLimit = params?.limit;
+        const limit = typeof rawLimit === "number" && rawLimit > 0 ? rawLimit : 25;
+        const result = await toolsSkillFederatedFind(query, federated, limit);
+        return wrapResult(result, "query", "tools", "skill.federated.find", startTime);
+      }
+      case "dispatch": {
+        const name = params?.name;
+        if (!name) {
+          return errorResult(
+            "query",
+            "tools",
+            "skill.dispatch",
+            "E_INVALID_INPUT",
+            "Missing required parameter: name",
+            startTime
+          );
+        }
+        const result = toolsSkillDispatch(name);
+        return wrapResult(result, "query", "tools", "skill.dispatch", startTime);
+      }
+      case "verify": {
+        const name = params?.name;
+        if (!name) {
+          return errorResult(
+            "query",
+            "tools",
+            "skill.verify",
+            "E_INVALID_INPUT",
+            "Missing required parameter: name",
+            startTime
+          );
+        }
+        const result = await toolsSkillVerify(name);
+        return wrapResult(result, "query", "tools", "skill.verify", startTime);
+      }
+      case "dependencies": {
+        const name = params?.name;
+        if (!name) {
+          return errorResult(
+            "query",
+            "tools",
+            "skill.dependencies",
+            "E_INVALID_INPUT",
+            "Missing required parameter: name",
+            startTime
+          );
+        }
+        const result = toolsSkillDependencies(name);
+        return wrapResult(result, "query", "tools", "skill.dependencies", startTime);
+      }
+      case "spawn.providers": {
+        const capability = params?.capability;
+        const result = await toolsSkillSpawnProviders(capability);
+        return wrapResult(result, "query", "tools", "skill.spawn.providers", startTime);
+      }
+      // Merged: skill.catalog (absorbs catalog.protocols/profiles/resources/info via type param)
+      case "catalog": {
+        return routeByParam(
+          params,
+          "type",
+          {
+            protocols: () => {
+              const { limit, offset } = getListParams(params);
+              const result = toolsSkillCatalogProtocols(limit, offset);
+              if (!result.success) {
+                return wrapResult(result, "query", "tools", "skill.catalog", startTime);
+              }
+              return {
+                meta: dispatchMeta("query", "tools", "skill.catalog", startTime),
+                success: true,
+                data: {
+                  protocols: result.data.protocols,
+                  count: result.data.count,
+                  total: result.data.total,
+                  filtered: result.data.filtered
+                },
+                page: result.data.page
+              };
+            },
+            profiles: () => {
+              const { limit, offset } = getListParams(params);
+              const result = toolsSkillCatalogProfiles(limit, offset);
+              if (!result.success) {
+                return wrapResult(result, "query", "tools", "skill.catalog", startTime);
+              }
+              return {
+                meta: dispatchMeta("query", "tools", "skill.catalog", startTime),
+                success: true,
+                data: {
+                  profiles: result.data.profiles,
+                  count: result.data.count,
+                  total: result.data.total,
+                  filtered: result.data.filtered
+                },
+                page: result.data.page
+              };
+            },
+            resources: () => {
+              const { limit, offset } = getListParams(params);
+              const result = toolsSkillCatalogResources(limit, offset);
+              if (!result.success) {
+                return wrapResult(result, "query", "tools", "skill.catalog", startTime);
+              }
+              return {
+                meta: dispatchMeta("query", "tools", "skill.catalog", startTime),
+                success: true,
+                data: {
+                  resources: result.data.resources,
+                  count: result.data.count,
+                  total: result.data.total,
+                  filtered: result.data.filtered
+                },
+                page: result.data.page
+              };
+            },
+            info: () => {
+              const result = toolsSkillCatalogInfo();
+              return wrapResult(result, "query", "tools", "skill.catalog", startTime);
+            }
+          },
+          "info"
+        );
+      }
+      // Merged: skill.precedence (absorbs precedence.show/resolve via action param)
+      case "precedence": {
+        const action = params?.action ?? "show";
+        if (action === "show") {
+          const result = await toolsSkillPrecedenceShow();
+          return wrapResult(result, "query", "tools", "skill.precedence", startTime);
+        }
+        if (action === "resolve") {
+          const providerId = params?.providerId;
+          const scope = params?.scope || "global";
+          const result = await toolsSkillPrecedenceResolve(providerId, scope, this.projectRoot);
+          return wrapResult(result, "query", "tools", "skill.precedence", startTime);
+        }
+        return unsupportedOp("query", "tools", `skill.precedence`, startTime);
+      }
+      // T9652 — skill.doctor.diagnose: read-only health report
+      case "doctor.diagnose": {
+        const verbose = params?.verbose === true;
+        const result = await toolsSkillDoctorDiagnose({ verbose });
+        return wrapResult(result, "query", "tools", "skill.doctor.diagnose", startTime);
+      }
+      // T9690 — skill.stats: Sphere B telemetry rollup
+      case "stats": {
+        const top = typeof params?.top === "number" ? params.top : void 0;
+        const sinceDays = typeof params?.sinceDays === "number" ? params.sinceDays : void 0;
+        const result = await toolsSkillStats({
+          top,
+          sinceDays,
+          bySource: params?.bySource === true,
+          byLifecycle: params?.byLifecycle === true,
+          agentCreated: params?.agentCreated === true
+        });
+        return wrapResult(result, "query", "tools", "skill.stats", startTime);
+      }
+      default:
+        return unsupportedOp("query", "tools", `skill.${sub}`, startTime);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Skill mutations
+  // -----------------------------------------------------------------------
+  async mutateSkill(sub, params, startTime) {
+    switch (sub) {
+      case "install": {
+        const name = params?.name;
+        if (!name) {
+          return errorResult(
+            "mutate",
+            "tools",
+            "skill.install",
+            "E_INVALID_INPUT",
+            "Missing required parameter: name",
+            startTime
+          );
+        }
+        const source = params?.source;
+        const isGlobal = params?.isGlobal;
+        const result = await toolsSkillInstall(name, this.projectRoot, source, isGlobal);
+        return wrapResult(result, "mutate", "tools", "skill.install", startTime);
+      }
+      case "uninstall": {
+        const name = params?.name;
+        if (!name) {
+          return errorResult(
+            "mutate",
+            "tools",
+            "skill.uninstall",
+            "E_INVALID_INPUT",
+            "Missing required parameter: name",
+            startTime
+          );
+        }
+        const isGlobal = params?.isGlobal;
+        const result = await toolsSkillUninstall(name, this.projectRoot, isGlobal);
+        return wrapResult(result, "mutate", "tools", "skill.uninstall", startTime);
+      }
+      case "refresh": {
+        const result = await toolsSkillRefresh(this.projectRoot);
+        return wrapResult(result, "mutate", "tools", "skill.refresh", startTime);
+      }
+      // T9691 — skill.import.hermes: migrate Hermes .usage.json into skills.db
+      case "import.hermes": {
+        const hermesHome = params?.hermesHome;
+        const dryRun = params?.dryRun === true;
+        const result = await toolsSkillImportHermes({ hermesHome, dryRun });
+        return wrapResult(result, "mutate", "tools", "skill.import.hermes", startTime);
+      }
+      // T9742 — skill.migrate: legacy XDG store → ~/.cleo/skills/ (SSoT)
+      case "migrate": {
+        const result = await toolsSkillMigrate({
+          dryRun: params?.dryRun === true,
+          rollback: params?.rollback === true
+        });
+        return wrapResult(result, "mutate", "tools", "skill.migrate", startTime);
+      }
+      // T9693 — skill.prune.telemetry: retention sweep on skill_usage
+      case "prune.telemetry": {
+        const olderThanDays = typeof params?.olderThanDays === "number" ? params.olderThanDays : void 0;
+        const result = await toolsSkillPruneTelemetry({
+          olderThanDays,
+          dryRun: params?.dryRun === true,
+          vacuum: params?.vacuum === true
+        });
+        return wrapResult(result, "mutate", "tools", "skill.prune.telemetry", startTime);
+      }
+      default:
+        return unsupportedOp("mutate", "tools", `skill.${sub}`, startTime);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Provider queries
+  // -----------------------------------------------------------------------
+  async queryProvider(sub, params, startTime) {
+    switch (sub) {
+      case "list": {
+        const { limit, offset } = getListParams(params);
+        const result = toolsProviderList(limit, offset);
+        if (!result.success) {
+          return wrapResult(result, "query", "tools", "provider.list", startTime);
+        }
+        return {
+          meta: dispatchMeta("query", "tools", "provider.list", startTime),
+          success: true,
+          data: {
+            providers: result.data.providers,
+            count: result.data.count,
+            total: result.data.total,
+            filtered: result.data.filtered
+          },
+          page: result.data.page
+        };
+      }
+      case "detect": {
+        const result = toolsProviderDetect();
+        return wrapResult(result, "query", "tools", "provider.detect", startTime);
+      }
+      case "inject.status": {
+        const scope = params?.scope;
+        const content = params?.content;
+        const result = await toolsProviderInjectStatus(this.projectRoot, scope, content);
+        return wrapResult(result, "query", "tools", "provider.inject.status", startTime);
+      }
+      case "supports": {
+        const providerId = params?.providerId;
+        const capability = params?.capability;
+        if (!providerId || !capability) {
+          return errorResult(
+            "query",
+            "tools",
+            "provider.supports",
+            "E_INVALID_INPUT",
+            "Missing required parameters: providerId and capability",
+            startTime
+          );
+        }
+        const result = await toolsProviderSupports(providerId, capability);
+        return wrapResult(result, "query", "tools", "provider.supports", startTime);
+      }
+      case "hooks": {
+        const event = params?.event;
+        if (!event) {
+          return errorResult(
+            "query",
+            "tools",
+            "provider.hooks",
+            "E_INVALID_INPUT",
+            "Missing required parameter: event (HookEvent)",
+            startTime
+          );
+        }
+        const result = await toolsProviderHooks(event);
+        return wrapResult(result, "query", "tools", "provider.hooks", startTime);
+      }
+      default:
+        return unsupportedOp("query", "tools", `provider.${sub}`, startTime);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Provider mutations
+  // -----------------------------------------------------------------------
+  async mutateProvider(sub, params, startTime) {
+    switch (sub) {
+      case "inject": {
+        const scope = params?.scope;
+        const references = params?.references;
+        const content = params?.content;
+        const result = await toolsProviderInject(this.projectRoot, scope, references, content);
+        return wrapResult(result, "mutate", "tools", "provider.inject", startTime);
+      }
+      default:
+        return unsupportedOp("mutate", "tools", `provider.${sub}`, startTime);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Adapter queries
+  // -----------------------------------------------------------------------
+  queryAdapter(sub, params, startTime) {
+    switch (sub) {
+      case "list": {
+        const result = toolsAdapterList(this.projectRoot);
+        return wrapResult(result, "query", "tools", "adapter.list", startTime);
+      }
+      case "show": {
+        const id = params?.id;
+        if (!id) {
+          return errorResult(
+            "query",
+            "tools",
+            "adapter.show",
+            "E_INVALID_INPUT",
+            "Missing required parameter: id",
+            startTime
+          );
+        }
+        const result = toolsAdapterShow(this.projectRoot, id);
+        return wrapResult(result, "query", "tools", "adapter.show", startTime);
+      }
+      case "detect": {
+        const result = toolsAdapterDetect(this.projectRoot);
+        return wrapResult(result, "query", "tools", "adapter.detect", startTime);
+      }
+      case "health": {
+        const id = params?.id;
+        const result = toolsAdapterHealth(this.projectRoot, id);
+        return wrapResult(result, "query", "tools", "adapter.health", startTime);
+      }
+      default:
+        return unsupportedOp("query", "tools", `adapter.${sub}`, startTime);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Code analysis queries (Smart Explore)
+  // -----------------------------------------------------------------------
+  async queryCode(sub, params, startTime) {
+    switch (sub) {
+      case "outline": {
+        const result = await codeOutline(this.projectRoot, params);
+        return wrapResult(result, "query", "tools", "code.outline", startTime);
+      }
+      case "search": {
+        const result = await codeSearch(this.projectRoot, params);
+        return wrapResult(result, "query", "tools", "code.search", startTime);
+      }
+      case "unfold": {
+        const result = await codeUnfold(this.projectRoot, params);
+        return wrapResult(result, "query", "tools", "code.unfold", startTime);
+      }
+      case "parse": {
+        const result = await codeParse(this.projectRoot, params);
+        return wrapResult(result, "query", "tools", "code.parse", startTime);
+      }
+      default:
+        return unsupportedOp("query", "tools", `code.${sub}`, startTime);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Adapter mutations
+  // -----------------------------------------------------------------------
+  async mutateAdapter(sub, params, startTime) {
+    switch (sub) {
+      case "activate": {
+        const id = params?.id;
+        if (!id) {
+          return errorResult(
+            "mutate",
+            "tools",
+            "adapter.activate",
+            "E_INVALID_INPUT",
+            "Missing required parameter: id",
+            startTime
+          );
+        }
+        const result = await toolsAdapterActivate(this.projectRoot, id);
+        return wrapResult(result, "mutate", "tools", "adapter.activate", startTime);
+      }
+      case "dispose": {
+        const id = params?.id;
+        const result = await toolsAdapterDispose(this.projectRoot, id);
+        return wrapResult(result, "mutate", "tools", "adapter.dispose", startTime);
+      }
+      default:
+        return unsupportedOp("mutate", "tools", `adapter.${sub}`, startTime);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Helpers
+  // -----------------------------------------------------------------------
+  handleError(gateway, domain, operation, error, startTime) {
+    const message = error instanceof Error ? error.message : String(error);
+    getLogger("domain:tools").error({ gateway, domain, operation, err: error }, message);
+    return handleErrorResult(gateway, domain, operation, error, startTime);
+  }
+};
+export {
+  ToolsHandler
+};
+//# sourceMappingURL=tools-BI74W7VE.js.map

package/dist/cli/{transcript-LORQTV5Z.js → transcript-RGK7RSGQ.js}

@@ -20,7 +20,7 @@ import {
 import {
   cliError,
   cliOutput
-} from "./chunk-3ZO3M37V.js";
+} from "./chunk-4RGSNUUP.js";
 import "./chunk-6JSJNYH2.js";
 
 // packages/cleo/src/cli/commands/transcript.ts
@@ -437,4 +437,4 @@ var transcriptCommand = defineCommand({
 export {
   transcriptCommand
 };
-//# sourceMappingURL=transcript-LORQTV5Z.js.map
+//# sourceMappingURL=transcript-RGK7RSGQ.js.map