@opendash-ai/cli 0.1.0-beta.1 → 0.1.0-beta.3

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

@@ -1,176 +0,0 @@
-/**
- * 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

@@ -1,352 +0,0 @@
-/**
- * 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

@@ -1,127 +0,0 @@
-/**
- * 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)