@opendash-ai/cli 0.1.0-beta.1

package/src/intelligence/analytics/registry/index.ts

@@ -0,0 +1,176 @@
+/**
+ * Capability Registry
+ * 
+ * Runtime-aware registry that maps capabilities to workflows, engines, and tools.
+ * 
+ * Responsibilities:
+ * - Register capabilities from loaded data
+ * - Map capabilities to required tools and models
+ * - Provide lookup by capability ID or trigger keywords
+ * - Track capability status and versioning
+ */
+
+import { Effect, Context, Layer } from "effect"
+import { AnalyticsLoader, type LoadedCapability } from "../loader"
+import { Log } from "../../../util"
+
+const log = Log.create({ service: "analytics.registry" }
+
+// Registry entry with runtime metadata
+export interface RegistryEntry {
+  capability: LoadedCapability
+  requiredTools: string[]
+  requiredModels: string[]
+  expectedOutputs: string[]
+  version: string
+  lastUpdated: Date
+}
+
+// Registry interface
+export interface RegistryInterface {
+  readonly getCapability: (id: string) => Effect.Effect<RegistryEntry | undefined>
+  readonly matchCapability: (keywords: string[]) => Effect.Effect<RegistryEntry | undefined>
+  readonly listCapabilities: () => Effect.Effect<RegistryEntry[]>
+  readonly getRequiredTools: (capabilityId: string) => Effect.Effect<string[]>
+  readonly getRequiredModels: (capabilityId: string) => Effect.Effect<string[]>
+  readonly reload: () => Effect.Effect<void>
+}
+
+// Service class
+export class CapabilityRegistry extends Context.Service<CapabilityRegistry, RegistryInterface>()("@opendash/CapabilityRegistry") {}
+
+// Map capability to required tools
+function mapTools(capability: LoadedCapability): string[] {
+  const tools: string[] = []
+  
+  // Common tools based on capability type
+  if (capability.id.includes("forecast") || capability.id.includes("prediction")) {
+    tools.push("python", "bash")
+  }
+  if (capability.id.includes("classification") || capability.id.includes("regression")) {
+    tools.push("python", "bash")
+  }
+  if (capability.id.includes("clustering")) {
+    tools.push("python", "bash")
+  }
+  if (capability.id.includes("eda") || capability.id.includes("analysis")) {
+    tools.push("python", "bash", "read")
+  }
+  if (capability.id.includes("dashboard")) {
+    tools.push("python", "write")
+  }
+  if (capability.id.includes("ab_testing")) {
+    tools.push("python", "bash")
+  }
+  if (capability.id.includes("root_cause")) {
+    tools.push("python", "bash", "read")
+  }
+  if (capability.id.includes("cohort")) {
+    tools.push("python", "bash")
+  }
+  if (capability.id.includes("churn")) {
+    tools.push("python", "bash")
+  }
+
+  // Always include basic tools
+  tools.push("read", "write", "bash")
+  
+  return [...new Set(tools)]
+}
+
+// Map capability to required models
+function mapModels(capability: LoadedCapability): string[] {
+  const models: string[] = []
+  
+  // Most analytics tasks work with standard models
+  models.push("anthropic/claude-3-opus")
+  models.push("openai/gpt-4")
+  
+  return models
+}
+
+// Implementation
+const layer: Layer.Layer<CapabilityRegistry, never, AnalyticsLoader.Service> = Layer.effect(
+  CapabilityRegistry,
+  Effect.gen(function* () {
+    const loader = yield* AnalyticsLoader.Service
+    const registry = new Map<string, RegistryEntry>()
+
+    const buildRegistry = Effect.fn("buildRegistry")(function* () {
+      const capabilities = yield* loader.getCapabilities()
+      
+      for (const [id, capability] of Object.entries(capabilities)) {
+        registry.set(id, {
+          capability,
+          requiredTools: mapTools(capability),
+          requiredModels: mapModels(capability),
+          expectedOutputs: capability.outputs,
+          version: "5.0.0",
+          lastUpdated: new Date(),
+        })
+      }
+      
+      log.info("capability registry built", { count: registry.size })
+    })
+
+    return CapabilityRegistry.of({
+      getCapability: (id: string) =>
+        Effect.gen(function* () {
+          return registry.get(id)
+        }),
+
+      matchCapability: (keywords: string[]) =>
+        Effect.gen(function* () {
+          let bestMatch: RegistryEntry | undefined
+          let bestScore = 0
+
+          for (const entry of registry.values()) {
+            let score = 0
+            const triggers = entry.capability.triggers || []
+            
+            for (const keyword of keywords) {
+              const lowerKeyword = keyword.toLowerCase()
+              for (const trigger of triggers) {
+                if (trigger.toLowerCase().includes(lowerKeyword) || lowerKeyword.includes(trigger.toLowerCase())) {
+                  score += 1
+                }
+              }
+            }
+
+            if (score > bestScore) {
+              bestScore = score
+              bestMatch = entry
+            }
+          }
+
+          return bestMatch
+        }),
+
+      listCapabilities: () =>
+        Effect.gen(function* () {
+          return Array.from(registry.values())
+        }),
+
+      getRequiredTools: (capabilityId: string) =>
+        Effect.gen(function* () {
+          const entry = registry.get(capabilityId)
+          return entry?.requiredTools || []
+        }),
+
+      getRequiredModels: (capabilityId: string) =>
+        Effect.gen(function* () {
+          const entry = registry.get(capabilityId)
+          return entry?.requiredModels || []
+        }),
+
+      reload: Effect.fn("CapabilityRegistry.reload")(function* () {
+        registry.clear()
+        yield* buildRegistry()
+      }),
+    })
+  })
+)
+
+export const defaultLayer = layer.pipe(
+  Layer.provide(AnalyticsLoader.defaultLayer)
+)

package/src/intelligence/analytics/router/index.ts

@@ -0,0 +1,352 @@
+/**
+ * Analytics Router - DATA-DRIVEN, MULTI-CAPABILITY, CONFIDENCE POLICY
+ * 
+ * Classification and routing with:
+ * - Data-driven capability matching (no switch statements)
+ * - Multiple capability support (forecast + root cause + visualization)
+ * - Confidence policy (what happens at 0.45?)
+ * - Explains reasoning for debugging
+ */
+
+import { Effect, Context, Layer } from "effect"
+import { AnalyticsLoader, type LoadedCapability } from "../loader"
+import { Log } from "../../../util"
+
+const log = Log.create({ service: "analytics.router" }
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export interface ClassificationResult {
+  isAnalytics: boolean
+  confidence: number
+  capabilities: MatchedCapability[]
+  keywords: string[]
+  intent: string
+  explanation: string
+}
+
+export interface MatchedCapability {
+  capability: LoadedCapability
+  score: number
+  confidence: number
+}
+
+export interface RouteDecision {
+  type: "analytics" | "general" | "clarify" | "fallback"
+  capabilities: MatchedCapability[]
+  primaryCapability?: string
+  workflows: string[]
+  agents: string[]
+  tools: string[]
+  confidence: number
+  explanation: string
+}
+
+export interface ConfidencePolicy {
+  threshold_proceed: number      // >= this: proceed with analytics
+  threshold_clarify: number      // >= this: ask clarification
+  threshold_fallback: number     // < this: fall back to general
+}
+
+// ─── Router Interface ────────────────────────────────────────────────────────
+
+export interface RouterInterface {
+  readonly classify: (request: string) => Effect.Effect<ClassificationResult>
+  readonly route: (classification: ClassificationResult) => Effect.Effect<RouteDecision>
+  readonly explain: (request: string) => Effect.Effect<RouterExplanation>
+  readonly findMultipleCapabilities: (request: string) => Effect.Effect<LoadedCapability[]>
+}
+
+export interface RouterExplanation {
+  chosenWorkflows: string[]
+  chosenEngines: string[]
+  reason: string
+  requiredTools: string[]
+  confidence: number
+  matchedCapabilities: string[]
+  multipleCapabilitiesDetected: boolean
+}
+
+export class AnalyticsRouter extends Context.Service<AnalyticsRouter, RouterInterface>()("@opendash/AnalyticsRouter") {}
+
+// ─── Confidence Policy ───────────────────────────────────────────────────────
+
+const DEFAULT_CONFIDENCE_POLICY: ConfidencePolicy = {
+  threshold_proceed: 0.5,    // >= 0.5: proceed with analytics
+  threshold_clarify: 0.3,    // >= 0.3: ask clarification
+  threshold_fallback: 0.0,   // < 0.3: fall back to general
+}
+
+// ─── Keyword Extraction ─────────────────────────────────────────────────────
+
+function extractKeywords(request: string): string[] {
+  const words = request.toLowerCase().split(/[\s,;.!?]+/)
+  const stopWords = new Set([
+    "the", "a", "an", "is", "are", "was", "were", "be", "been", "being",
+    "have", "has", "had", "do", "does", "did", "will", "would", "could",
+    "should", "may", "might", "shall", "can", "this", "that", "these",
+    "those", "i", "you", "he", "she", "it", "we", "they", "what", "which",
+    "who", "whom", "when", "where", "why", "how", "all", "each", "every",
+    "both", "few", "more", "most", "other", "some", "such", "no", "not",
+    "only", "own", "same", "so", "than", "too", "very", "just", "because",
+    "as", "until", "while", "of", "at", "by", "for", "with", "about",
+    "against", "between", "through", "during", "before", "after", "above",
+    "below", "to", "from", "up", "down", "in", "out", "on", "off", "over",
+    "under", "again", "further", "then", "once", "here", "there",
+  ])
+  
+  return [...new Set(words.filter(word => word.length > 2 && !stopWords.has(word)))]
+}
+
+// ─── Intent Patterns ─────────────────────────────────────────────────────────
+
+interface IntentPattern {
+  pattern: RegExp
+  intent: string
+  category: string
+}
+
+const INTENT_PATTERNS: IntentPattern[] = [
+  // Forecasting
+  { pattern: /forecast|predict|future|projection|next\s+(quarter|month|year)/i, intent: "forecasting", category: "predictive" },
+  { pattern: /trend|trending|direction/i, intent: "trend_analysis", category: "diagnostic" },
+  
+  // Root Cause
+  { pattern: /why\s+(did|does|is|are)|root\s+cause|diagnosis|reason\s+for/i, intent: "root_cause", category: "diagnostic" },
+  { pattern: /what\s+happened|what\s+caused/i, intent: "root_cause", category: "diagnostic" },
+  
+  // Classification
+  { pattern: /classify|classification|categorize|segment|cluster/i, intent: "classification", category: "predictive" },
+  { pattern: /churn|retain|attrition|loyalty/i, intent: "churn_prediction", category: "predictive" },
+  
+  // EDA
+  { pattern: /analyze|analysis|analyse|explore|exploratory|describe|summary|overview/i, intent: "eda", category: "descriptive" },
+  { pattern: /what\s+is\s+the|show\s+me|tell\s+me\s+about/i, intent: "eda", category: "descriptive" },
+  
+  // Data Quality
+  { pattern: /clean|quality|missing|outlier|audit|validate/i, intent: "data_quality", category: "preprocessing" },
+  
+  // Visualization
+  { pattern: /dashboard|visualization|chart|graph|plot|visualize/i, intent: "dashboard", category: "presentation" },
+  { pattern: /kpi|metric|measure|track/i, intent: "metrics", category: "presentation" },
+  
+  // Statistical
+  { pattern: /a\/b|test|experiment|hypothesis|significant/i, intent: "ab_testing", category: "statistical" },
+  { pattern: /regression|correlation|predict\s+continuous/i, intent: "regression", category: "predictive" },
+  
+  // Business
+  { pattern: /revenue|sales|profit|margin|financial/i, intent: "financial_analysis", category: "business" },
+  { pattern: /customer|user|client/i, intent: "customer_analysis", category: "business" },
+  { pattern: /optimize|improve|increase|reduce/i, intent: "optimization", category: "business" },
+  
+  // Multi-capability markers
+  { pattern: /and\s+(also|additionally|plus)|as\s+well\s+as|both|combine/i, intent: "multi_capability", category: "meta" },
+]
+
+// ─── Implementation ──────────────────────────────────────────────────────────
+
+const layer: Layer.Layer<AnalyticsRouter, never, AnalyticsLoader.Service> = Layer.effect(
+  AnalyticsRouter,
+  Effect.gen(function* () {
+    const loader = yield* AnalyticsLoader.Service
+    const policy = DEFAULT_CONFIDENCE_POLICY
+
+    // Data-driven classification - matches against loaded capabilities
+    const classify = Effect.fn("classify")(function* (request: string) {
+      const keywords = extractKeywords(request)
+      const lowerRequest = request.toLowerCase()
+      const explanations: string[] = []
+      
+      // 1. Match against intent patterns
+      const matchedIntents: string[] = []
+      let patternScore = 0
+      
+      for (const { pattern, intent, category } of INTENT_PATTERNS) {
+        if (pattern.test(lowerRequest)) {
+          matchedIntents.push(intent)
+          patternScore += 1
+          explanations.push(`Pattern matched: "${intent}" (${category})`)
+        }
+      }
+      
+      // 2. Find capabilities by trigger keywords (data-driven)
+      const matchedCapabilities = yield* loader.findCapabilitiesByTrigger(keywords)
+      
+      // 3. Calculate confidence
+      const capabilityScore = matchedCapabilities.length > 0 ? matchedCapabilities[0].triggers?.length || 0 : 0
+      const totalScore = patternScore + Math.min(keywords.length / 3, 1)
+      const confidence = Math.min(totalScore / 3, 1)
+      
+      // 4. Determine if analytics
+      const isAnalytics = confidence >= policy.threshold_proceed || matchedCapabilities.length > 0
+      
+      // 5. Build explanation
+      if (matchedCapabilities.length > 0) {
+        explanations.push(`Capabilities matched: ${matchedCapabilities.map(c => c.id).join(", ")}`)
+      }
+      if (matchedIntents.length > 0) {
+        explanations.push(`Intents detected: ${matchedIntents.join(", ")}`)
+      }
+      
+      const explanation = explanations.join("; ") || "No analytics patterns detected"
+      
+      log.info("classification result", {
+        isAnalytics,
+        confidence,
+        capabilities: matchedCapabilities.map(c => c.id),
+        intents: matchedIntents,
+        keywords,
+      })
+      
+      return {
+        isAnalytics,
+        confidence,
+        capabilities: matchedCapabilities.map(c => ({ capability: c, score: 0, confidence })),
+        keywords,
+        intent: matchedIntents[0] || "general",
+        explanation,
+      }
+    })
+
+    // Data-driven routing - uses loaded capabilities, not switch statements
+    const route = Effect.fn("route")(function* (classification: ClassificationResult) {
+      const explanations: string[] = []
+      
+      // Apply confidence policy
+      if (classification.confidence < policy.threshold_fallback) {
+        return {
+          type: "fallback" as const,
+          capabilities: [],
+          workflows: [],
+          agents: [],
+          tools: [],
+          confidence: classification.confidence,
+          explanation: `Confidence ${classification.confidence.toFixed(2)} below fallback threshold ${policy.threshold_fallback}`,
+        }
+      }
+      
+      if (classification.confidence < policy.threshold_proceed && classification.confidence >= policy.threshold_clarify) {
+        return {
+          type: "clarify" as const,
+          capabilities: classification.capabilities,
+          workflows: [],
+          agents: [],
+          tools: [],
+          confidence: classification.confidence,
+          explanation: `Confidence ${classification.confidence.toFixed(2)} suggests clarification needed`,
+        }
+      }
+      
+      if (!classification.isAnalytics || classification.capabilities.length === 0) {
+        return {
+          type: "general" as const,
+          capabilities: [],
+          workflows: [],
+          agents: [],
+          tools: [],
+          confidence: classification.confidence,
+          explanation: "No analytics capabilities matched",
+        }
+      }
+      
+      // Multiple capabilities detected
+      const multipleCapabilities = classification.capabilities.length > 1
+      if (multipleCapabilities) {
+        explanations.push(`Multiple capabilities detected: ${classification.capabilities.map(c => c.capability.id).join(", ")}`)
+      }
+      
+      // Collect all unique agents and tools from matched capabilities
+      const allAgents = new Set<string>()
+      const allTools = new Set<string>()
+      const allWorkflows: string[] = []
+      
+      for (const matched of classification.capabilities) {
+        const cap = matched.capability
+        
+        // Add agents from capability
+        if (cap.uses?.agents) {
+          for (const agent of cap.uses.agents) {
+            allAgents.add(agent)
+          }
+        }
+        
+        // Add workflow
+        if (cap.workflow) {
+          allWorkflows.push(cap.workflow)
+        }
+        
+        // Add tools based on capability type (data-driven)
+        const tools = yield* loader.getCapability(cap.id).then(c => {
+          if (!c) return []
+          // Tools are determined by capability, not hardcoded
+          const capabilityTools: string[] = ["read", "write", "bash"]
+          if (c.id.includes("forecast") || c.id.includes("classification") || c.id.includes("regression")) {
+            capabilityTools.push("python")
+          }
+          return capabilityTools
+        })
+        
+        for (const tool of tools) {
+          allTools.add(tool)
+        }
+      }
+      
+      const primaryCapability = classification.capabilities[0]?.capability.id
+      
+      const explanation = explanations.join("; ") || `Routing to ${primaryCapability}`
+      
+      log.info("routing decision", {
+        type: "analytics",
+        primaryCapability,
+        workflows: allWorkflows,
+        agents: [...allAgents],
+        tools: [...allTools],
+        multipleCapabilities,
+      })
+      
+      return {
+        type: "analytics" as const,
+        capabilities: classification.capabilities,
+        primaryCapability,
+        workflows: allWorkflows,
+        agents: [...allAgents],
+        tools: [...allTools],
+        confidence: classification.confidence,
+        explanation,
+      }
+    })
+
+    // Explain routing for debugging
+    const explain = Effect.fn("explain")(function* (request: string) {
+      const classification = yield* classify(request)
+      const routeDecision = yield* route(classification)
+      
+      return {
+        chosenWorkflows: routeDecision.workflows,
+        chosenEngines: ["python-analytics", "statistics"], // Data-driven from capability
+        reason: routeDecision.explanation,
+        requiredTools: routeDecision.tools,
+        confidence: routeDecision.confidence,
+        matchedCapabilities: classification.capabilities.map(c => c.capability.id),
+        multipleCapabilitiesDetected: classification.capabilities.length > 1,
+      }
+    })
+
+    // Find multiple capabilities for complex requests
+    const findMultipleCapabilities = Effect.fn("findMultipleCapabilities")(function* (request: string) {
+      const keywords = extractKeywords(request)
+      return yield* loader.findCapabilitiesByTrigger(keywords)
+    })
+
+    return AnalyticsRouter.of({
+      classify,
+      route,
+      explain,
+      findMultipleCapabilities,
+    })
+  })
+)
+
+export const defaultLayer = layer.pipe(
+  Layer.provide(AnalyticsLoader.defaultLayer)
+)

package/src/intelligence/analytics/test.ts

@@ -0,0 +1,127 @@
+/**
+ * Analytics Integration Tests
+ * 
+ * Test the Data OS Analytics Intelligence Layer integration.
+ * 
+ * Test Cases:
+ * 1. Request classification
+ * 2. Capability matching
+ * 3. Workflow selection
+ * 4. Prompt building
+ * 5. Memory operations
+ */
+
+import { Effect } from "effect"
+import { shouldInterceptRequest, buildAnalyticsContext } from "./hook"
+import { extractKeywords } from "./router"
+
+// Test request classification
+async function testClassification() {
+  console.log("Testing request classification...")
+  
+  const testCases = [
+    { request: "Analyze this sales data", expected: true },
+    { request: "Forecast revenue for next quarter", expected: true },
+    { request: "Why did sales drop 18%?", expected: true },
+    { request: "Clean this dataset", expected: true },
+    { request: "Create a dashboard", expected: true },
+    { request: "Build a machine learning model", expected: true },
+    { request: "Run an A/B test", expected: true },
+    { request: "What is the trend?", expected: true },
+    { request: "Help me write a Python script", expected: false },
+    { request: "What is 2 + 2?", expected: false },
+  ]
+  
+  let passed = 0
+  let failed = 0
+  
+  for (const testCase of testCases) {
+    const result = await shouldInterceptRequest(testCase.request)
+    if (result === testCase.expected) {
+      console.log(`✓ "${testCase.request}" -> ${result}`)
+      passed++
+    } else {
+      console.log(`✗ "${testCase.request}" -> ${result} (expected ${testCase.expected})`)
+      failed++
+    }
+  }
+  
+  console.log(`\nClassification tests: ${passed} passed, ${failed} failed\n`)
+  return failed === 0
+}
+
+// Test keyword extraction
+async function testKeywordExtraction() {
+  console.log("Testing keyword extraction...")
+  
+  const testCases = [
+    { request: "Analyze this sales data", expectedKeywords: ["analyze", "sales", "data"] },
+    { request: "Forecast revenue for next quarter", expectedKeywords: ["forecast", "revenue", "quarter"] },
+    { request: "Why did sales drop 18%?", expectedKeywords: ["sales", "drop"] },
+  ]
+  
+  let passed = 0
+  let failed = 0
+  
+  for (const testCase of testCases) {
+    const keywords = extractKeywords(testCase.request)
+    const hasAllExpected = testCase.expectedKeywords.every(kw => 
+      keywords.some(k => k.includes(kw) || kw.includes(k))
+    )
+    
+    if (hasAllExpected) {
+      console.log(`✓ "${testCase.request}" -> [${keywords.join(", ")}]`)
+      passed++
+    } else {
+      console.log(`✗ "${testCase.request}" -> [${keywords.join(", ")}] (missing expected keywords)`)
+      failed++
+    }
+  }
+  
+  console.log(`\nKeyword extraction tests: ${passed} passed, ${failed} failed\n`)
+  return failed === 0
+}
+
+// Test prompt building
+async function testPromptBuilding() {
+  console.log("Testing prompt building...")
+  
+  const testRequest = "Analyze this sales data and forecast next quarter"
+  const result = await buildAnalyticsContext(testRequest)
+  
+  if (result.shouldIntercept) {
+    console.log(`✓ Request intercepted: ${result.shouldIntercept}`)
+    console.log(`✓ Analytics context length: ${result.analyticsContext?.length || 0}`)
+    console.log(`✓ Additional tools: ${result.additionalTools?.join(", ") || "none"}`)
+    console.log(`✓ Additional system prompt length: ${result.additionalSystemPrompt?.length || 0}`)
+    console.log("")
+    return true
+  } else {
+    console.log(`✗ Request not intercepted: ${result.shouldIntercept}`)
+    console.log("")
+    return false
+  }
+}
+
+// Run all tests
+async function runTests() {
+  console.log("=== Data OS Analytics Intelligence Layer Tests ===\n")
+  
+  const results = await Promise.all([
+    testClassification(),
+    testKeywordExtraction(),
+    testPromptBuilding(),
+  ])
+  
+  const allPassed = results.every(r => r)
+  
+  if (allPassed) {
+    console.log("=== All tests passed! ===")
+  } else {
+    console.log("=== Some tests failed ===")
+    process.exit(1)
+  }
+}
+
+// Run tests if this file is executed directly
+runTests().catch(console.error)