@claude-flow/cli 3.32.26 → 3.32.30

package/dist/src/mcp-tools/capability-brain.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Ruflo capability brain.
+ *
+ * This module is deliberately data-only: it describes the complete MCP surface
+ * without importing the MCP registry. The registry injects its live tool list
+ * into guidance-tools after registration, which avoids a circular dependency
+ * and prevents documentation from being mistaken for runtime availability.
+ */
+export type CapabilityMaturity = 'stable' | 'experimental' | 'compatibility';
+export type CapabilityAuthority = 'advisory' | 'capability-plane' | 'control-plane';
+export type CapabilityRisk = 'read-only' | 'reversible' | 'privileged';
+export type AvailabilityState = boolean | 'unknown';
+export type CapabilityRiskFlag = 'read' | 'local-write' | 'memory-poisoning' | 'process-exec' | 'network' | 'credential-pii' | 'spend' | 'concurrency' | 'destructive' | 'approval' | 'promotion';
+export interface CapabilityToolMetadata {
+    name: string;
+    description?: string;
+    category?: string;
+    tags?: string[];
+    version?: string;
+}
+export interface CapabilityHealth {
+    /** Present in this running MCP server's registry. */
+    registered: boolean;
+    /** Requires an operator/provider configuration check. */
+    configured: AvailabilityState;
+    /** Requires a non-mutating dependency probe. */
+    reachable: AvailabilityState;
+    /** Requires a service-specific health check. */
+    healthy: AvailabilityState;
+    /** Requires a policy evaluation for the current subject and action. */
+    authorized: AvailabilityState;
+}
+export interface CapabilityDomainDefinition {
+    id: string;
+    name: string;
+    description: string;
+    prefixes: string[];
+    exactTools?: string[];
+    taskSignals: string[];
+    commands: string[];
+    skills: string[];
+    agents: string[];
+    maturity: CapabilityMaturity;
+    authority: CapabilityAuthority;
+    risk: CapabilityRisk;
+    optionalRuntime?: boolean;
+    packageOwners?: string[];
+    pluginOwners?: string[];
+    availabilityMode?: 'always-local' | 'conditional-registration' | 'registered-degraded' | 'configured-remote' | 'policy-filtered';
+    /**
+     * Conservative union of effects possible anywhere in this domain.
+     * Individual tool descriptors may narrow or expand this reviewed profile.
+     */
+    riskFlags?: CapabilityRiskFlag[];
+    loopPhases?: Array<'discover' | 'recall' | 'authorize-claim' | 'route-plan' | 'branch-propose' | 'execute' | 'validate-critique' | 'commit-validated' | 'observe' | 'publish'>;
+    useWhen: string;
+    verifyBeforeUse: string[];
+}
+export interface CapabilityDomain extends CapabilityDomainDefinition {
+    packageOwners: string[];
+    pluginOwners: string[];
+    availabilityMode: NonNullable<CapabilityDomainDefinition['availabilityMode']>;
+    riskFlags: NonNullable<CapabilityDomainDefinition['riskFlags']>;
+    loopPhases: NonNullable<CapabilityDomainDefinition['loopPhases']>;
+    tools: Array<CapabilityToolMetadata & {
+        domain: string;
+        packageOwner: string;
+        pluginOwner?: string;
+        availabilityMode: NonNullable<CapabilityDomainDefinition['availabilityMode']>;
+        authority: CapabilityAuthority;
+        risk: CapabilityRisk;
+        riskFlags: NonNullable<CapabilityDomainDefinition['riskFlags']>;
+        loopPhases: NonNullable<CapabilityDomainDefinition['loopPhases']>;
+    }>;
+    health: CapabilityHealth;
+}
+export interface CapabilityBrain {
+    schemaVersion: 'ruflo.capability-brain/v1';
+    generatedAt: string;
+    truthModel: {
+        catalogued: string;
+        registered: string;
+        configured: string;
+        reachable: string;
+        healthy: string;
+        authorized: string;
+    };
+    domains: CapabilityDomain[];
+    cliCommands: string[];
+    implementationLoop: ImplementationLoopStep[];
+    coverage: {
+        registeredToolCount: number;
+        classifiedToolCount: number;
+        coveragePercent: number;
+        fallbackClassifiedTools: string[];
+        duplicateToolNames: string[];
+    };
+}
+/** Top-level commands from the CLI command loader. Kept as a checked manifest. */
+export declare const RUFLO_CLI_COMMANDS: readonly ["init", "start", "status", "task", "session", "agent", "swarm", "memory", "mcp", "config", "migrate", "hooks", "workflow", "hive-mind", "process", "daemon", "version", "neural", "security", "performance", "providers", "plugins", "deployment", "claims", "policy", "embeddings", "completions", "doctor", "verify", "analyze", "route", "progress", "issues", "update", "ruvector", "benchmark", "guidance", "appliance", "appliance-advanced", "transfer-store", "cleanup", "autopilot", "gaia-bench", "metaharness", "eject", "funnel", "settings", "auth", "proxy", "advisor", "spinner", "announcements"];
+export interface ImplementationLoopStep {
+    id: string;
+    name: string;
+    purpose: string;
+    preferredTools: string[];
+    requiredEvidence: string;
+    mutation: 'none' | 'workspace' | 'external';
+}
+export declare const IMPLEMENTATION_LOOP: readonly ImplementationLoopStep[];
+/**
+ * Domain order is significant: narrow/specialized matches precede broad
+ * compatibility prefixes. Every registered tool is eventually classified by
+ * the final runtime-services domain, but fallback classifications are reported.
+ */
+export declare const CAPABILITY_DOMAINS: readonly CapabilityDomainDefinition[];
+export declare function classifyCapabilityTool(tool: CapabilityToolMetadata): CapabilityDomainDefinition;
+export declare function buildCapabilityBrain(registeredTools: readonly CapabilityToolMetadata[], now?: Date): CapabilityBrain;
+export interface CapabilityRecommendation {
+    task: string;
+    domains: Array<{
+        id: string;
+        name: string;
+        score: number;
+        registeredTools: string[];
+        health: CapabilityHealth;
+        authority: CapabilityAuthority;
+        risk: CapabilityRisk;
+        verifyBeforeUse: string[];
+    }>;
+    implementationLoop: ImplementationLoopStep[];
+    guardrails: string[];
+}
+export declare function recommendCapabilities(brain: CapabilityBrain, task: string): CapabilityRecommendation;
+//# sourceMappingURL=capability-brain.d.ts.map