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

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

@@ -1,152 +0,0 @@
-/**
- * Engine Module
- * 
- * Manages different analytics engines.
- * 
- * Responsibilities:
- * - Register analytics engines
- * - Provide engine capabilities
- * - Manage engine lifecycle
- * - Route to appropriate engine
- */
-
-import { Effect, Context, Layer } from "effect"
-import { AnalyticsLoader } from "../loader"
-import { Log } from "../../../util"
-
-const log = Log.create({ service: "analytics.engine" }
-
-// Engine definition
-export interface AnalyticsEngine {
-  id: string
-  name: string
-  description: string
-  capabilities: string[]
-  requiredTools: string[]
-  requiredModels: string[]
-  version: string
-}
-
-// Engine interface
-export interface EngineInterface {
-  readonly getEngine: (id: string) => Effect.Effect<AnalyticsEngine | undefined>
-  readonly listEngines: () => Effect.Effect<AnalyticsEngine[]>
-  readonly matchEngine: (capability: string) => Effect.Effect<AnalyticsEngine | undefined>
-  readonly getRequiredTools: (engineId: string) => Effect.Effect<string[]>
-  readonly getRequiredModels: (engineId: string) => Effect.Effect<string[]>
-}
-
-// Service class
-export class EngineRegistry extends Context.Service<EngineRegistry, EngineInterface>()("@opendash/EngineRegistry") {}
-
-// Default engines
-const DEFAULT_ENGINES: AnalyticsEngine[] = [
-  {
-    id: "python-analytics",
-    name: "Python Analytics Engine",
-    description: "Python-based analytics using pandas, numpy, scipy",
-    capabilities: ["eda", "regression", "classification", "clustering", "forecasting"],
-    requiredTools: ["python", "bash"],
-    requiredModels: ["anthropic/claude-3-opus", "openai/gpt-4"],
-    version: "5.0.0",
-  },
-  {
-    id: "sql-analytics",
-    name: "SQL Analytics Engine",
-    description: "SQL-based analytics using DuckDB, PostgreSQL",
-    capabilities: ["eda", "aggregation", "reporting"],
-    requiredTools: ["bash", "read"],
-    requiredModels: ["anthropic/claude-3-opus", "openai/gpt-4"],
-    version: "5.0.0",
-  },
-  {
-    id: "visualization",
-    name: "Visualization Engine",
-    description: "Data visualization using matplotlib, seaborn, plotly",
-    capabilities: ["dashboard", "visualization", "reporting"],
-    requiredTools: ["python", "write"],
-    requiredModels: ["anthropic/claude-3-opus", "openai/gpt-4"],
-    version: "5.0.0",
-  },
-  {
-    id: "machine-learning",
-    name: "Machine Learning Engine",
-    description: "ML modeling using scikit-learn, xgboost, lightgbm",
-    capabilities: ["classification", "regression", "clustering", "forecasting"],
-    requiredTools: ["python", "bash"],
-    requiredModels: ["anthropic/claude-3-opus", "openai/gpt-4"],
-    version: "5.0.0",
-  },
-  {
-    id: "statistics",
-    name: "Statistical Analysis Engine",
-    description: "Statistical testing using scipy, statsmodels",
-    capabilities: ["ab_testing", "hypothesis_testing", "statistical_analysis"],
-    requiredTools: ["python", "bash"],
-    requiredModels: ["anthropic/claude-3-opus", "openai/gpt-4"],
-    version: "5.0.0",
-  },
-]
-
-// Implementation
-const layer: Layer.Layer<EngineRegistry, never, AnalyticsLoader.Service> = Layer.effect(
-  EngineRegistry,
-  Effect.gen(function* () {
-    const loader = yield* AnalyticsLoader.Service
-    const engines = new Map<string, AnalyticsEngine>()
-
-    // Initialize with default engines
-    for (const engine of DEFAULT_ENGINES) {
-      engines.set(engine.id, engine)
-    }
-
-    return EngineRegistry.of({
-      getEngine: (id: string) =>
-        Effect.gen(function* () {
-          return engines.get(id)
-        }),
-
-      listEngines: () =>
-        Effect.gen(function* () {
-          return Array.from(engines.values())
-        }),
-
-      matchEngine: (capability: string) =>
-        Effect.gen(function* () {
-          let bestMatch: AnalyticsEngine | undefined
-          let bestScore = 0
-
-          for (const engine of engines.values()) {
-            let score = 0
-            for (const cap of engine.capabilities) {
-              if (cap.includes(capability) || capability.includes(cap)) {
-                score += 1
-              }
-            }
-            if (score > bestScore) {
-              bestScore = score
-              bestMatch = engine
-            }
-          }
-
-          return bestMatch
-        }),
-
-      getRequiredTools: (engineId: string) =>
-        Effect.gen(function* () {
-          const engine = engines.get(engineId)
-          return engine?.requiredTools || []
-        }),
-
-      getRequiredModels: (engineId: string) =>
-        Effect.gen(function* () {
-          const engine = engines.get(engineId)
-          return engine?.requiredModels || []
-        }),
-    })
-  })
-)
-
-export const defaultLayer = layer.pipe(
-  Layer.provide(AnalyticsLoader.defaultLayer)
-)

package/src/intelligence/analytics/hook.ts

@@ -1,154 +0,0 @@
-/**
- * Analytics Hook
- * 
- * Hook into OpenDash's prompt building to add analytics context.
- * 
- * This module provides a hook that can be used to:
- * - Intercept analytics requests
- * - Add analytics context to prompts
- * - Route to analytics orchestrator
- * - Build execution plans
- * 
- * Integration Point:
- * - Extend buildLLMRequestPrefix() in session/prompt.ts
- * - Add analytics context to system prompt
- * - Add analytics tools to tool list
- */
-
-import { Effect } from "effect"
-import { AnalyticsAdapters } from "./adapters"
-import { Log } from "../../util"
-
-const log = Log.create({ service: "analytics.hook" }
-
-// Hook result
-export interface AnalyticsHookResult {
-  shouldIntercept: boolean
-  analyticsContext?: string
-  additionalTools?: string[]
-  additionalSystemPrompt?: string
-}
-
-// Check if request should be intercepted
-export async function shouldInterceptRequest(request: string): Promise<boolean> {
-  try {
-    // Simple keyword-based check for now
-    const keywords = [
-      "analyze", "analysis", "forecast", "predict", "model",
-      "data", "clean", "eda", "dashboard", "visualization",
-      "kpi", "metrics", "trend", "segment", "churn",
-      "revenue", "sales", "profit", "regression", "classification",
-      "clustering", "ab_test", "experiment", "root_cause", "cohort",
-      "time_series", "machine_learning", "sql", "python",
-    ]
-    
-    const lowerRequest = request.toLowerCase()
-    for (const keyword of keywords) {
-      if (lowerRequest.includes(keyword)) {
-        return true
-      }
-    }
-    
-    return false
-  } catch (error) {
-    log.error("error checking request", { error })
-    return false
-  }
-}
-
-// Build analytics context for prompt
-export async function buildAnalyticsContext(request: string): Promise<AnalyticsHookResult> {
-  try {
-    const shouldIntercept = await shouldInterceptRequest(request)
-    
-    if (!shouldIntercept) {
-      return {
-        shouldIntercept: false,
-      }
-    }
-
-    // Build analytics context
-    const analyticsContext = `
-## Analytics Intelligence Layer
-You are operating with the Data OS Analytics Intelligence Layer.
-
-### Analytics Capabilities Available
-- Time Series Forecasting
-- Classification Modeling
-- Regression Modeling
-- Customer Segmentation
-- Churn Prediction
-- Root Cause Analysis
-- A/B Testing
-- Cohort Analysis
-- Exploratory Data Analysis
-- Dashboard Design
-
-### Analytics Workflow
-1. Business Consultant: Frame the problem
-2. Data Auditor: Validate data quality
-3. Data Analyst: Exploratory analysis
-4. Statistician: Statistical validation
-5. Data Scientist: Build models
-6. Executive Advisor: Strategic recommendations
-7. Report Writer: Compile deliverables
-
-### Quality Gates
-- Data Quality Gate
-- Statistical Rigor Gate
-- Model Quality Gate
-- Business Logic Gate
-- Communication Gate
-
-### Memory System
-- Track KPIs, stakeholders, assumptions
-- Remember previous analyses
-- Maintain business context
-`.trim()
-
-    const additionalSystemPrompt = `
-## Analytics Instructions
-When working with data or analytics requests:
-1. First understand the business problem
-2. Validate data quality before analysis
-3. Use appropriate statistical methods
-4. Report confidence scores
-5. Consider alternative explanations
-6. Provide actionable recommendations
-`.trim()
-
-    return {
-      shouldIntercept: true,
-      analyticsContext,
-      additionalTools: ["python", "bash", "read", "write"],
-      additionalSystemPrompt,
-    }
-  } catch (error) {
-    log.error("error building analytics context", { error })
-    return {
-      shouldIntercept: false,
-    }
-  }
-}
-
-// Hook into OpenDash's prompt building
-export function analyticsPromptHook(systemPrompt: string, request: string): Promise<string> {
-  return buildAnalyticsContext(request).then(result => {
-    if (!result.shouldIntercept) {
-      return systemPrompt
-    }
-
-    // Add analytics context to system prompt
-    let enhancedPrompt = systemPrompt
-    
-    if (result.analyticsContext) {
-      enhancedPrompt += "\n\n" + result.analyticsContext
-    }
-    
-    if (result.additionalSystemPrompt) {
-      enhancedPrompt += "\n\n" + result.additionalSystemPrompt
-    }
-
-    return enhancedPrompt
-  })
-}

package/src/intelligence/analytics/index.ts

@@ -1,194 +0,0 @@
-/**
- * Data OS Analytics Intelligence Layer - MAIN ENTRY
- * 
- * Phase 1: Intelligence Foundation
- * - Analytical Reasoning Engine
- * - Business problem decomposition
- * - Hypothesis generation
- * - Root cause reasoning
- * - Statistical decision logic
- * - Confidence calibration
- * - Decision tree for workflow selection
- * - Business-first reasoning (not tool-first)
- * 
- * Core Principle:
- * "Sales dropped by 18%" should trigger reasoning BEFORE code generation.
- */
-
-import { Effect, Layer, Context } from "effect"
-import { AnalyticsLoader } from "./loader"
-import { CapabilityRegistry } from "./registry"
-import { AnalyticsRouter, type ClassificationResult, type RouteDecision } from "./router"
-import { AnalyticsOrchestrator, type ExecutionPlan } from "./orchestrator"
-import { PlannerEngine, type DetailedPlan } from "./planner"
-import { WorkflowEngine, type WorkflowState } from "./workflow"
-import { EngineRegistry } from "./engine"
-import { AnalyticsMemory, type AnalyticsContext } from "./memory"
-import { AnalyticsPromptBuilder, type AnalyticsPrompt } from "./prompt"
-import { AnalyticsAdapters } from "./adapters"
-import { AnalyticalReasoning, type ReasoningResult } from "./reasoning"
-
-// ─── Main Interface ──────────────────────────────────────────────────────────
-
-export interface AnalyticsIntelligenceInterface {
-  // Phase 1: Reasoning (Business-first)
-  readonly reason: (request: string, context?: AnalyticsContext) => Effect.Effect<ReasoningResult>
-  
-  // Core pipeline
-  readonly classify: (request: string) => Effect.Effect<ClassificationResult>
-  readonly route: (classification: ClassificationResult) => Effect.Effect<RouteDecision>
-  readonly orchestrate: (route: RouteDecision) => Effect.Effect<ExecutionPlan>
-  readonly plan: (executionPlan: ExecutionPlan) => Effect.Effect<DetailedPlan>
-  readonly buildPrompt: (plan: DetailedPlan, context?: AnalyticsContext) => Effect.Effect<AnalyticsPrompt>
-  
-  // Workflow execution
-  readonly createWorkflow: (plan: DetailedPlan) => Effect.Effect<WorkflowState>
-  readonly startWorkflow: (state: WorkflowState) => Effect.Effect<WorkflowState>
-  readonly completeStep: (state: WorkflowState, stepId: string, output: unknown) => Effect.Effect<WorkflowState>
-  readonly failStep: (state: WorkflowState, stepId: string, error: string) => Effect.Effect<WorkflowState>
-  
-  // Memory
-  readonly remember: (context: AnalyticsContext) => Effect.Effect<void>
-  readonly recall: (sessionId: string) => Effect.Effect<AnalyticsContext | undefined>
-  
-  // Explain (for debugging)
-  readonly explain: (request: string) => Effect.Effect<ExplainResult>
-  
-  // Full pipeline with reasoning
-  readonly process: (request: string, sessionId: string) => Effect.Effect<ProcessResult>
-}
-
-export interface ExplainResult {
-  chosenWorkflows: string[]
-  chosenEngines: string[]
-  reason: string
-  requiredTools: string[]
-  confidence: number
-  matchedCapabilities: string[]
-  multipleCapabilitiesDetected: boolean
-}
-
-export interface ProcessResult {
-  reasoning: ReasoningResult
-  classification: ClassificationResult
-  route: RouteDecision
-  executionPlan: ExecutionPlan
-  detailedPlan: DetailedPlan
-  prompt: AnalyticsPrompt
-  workflow?: WorkflowState
-}
-
-// ─── Service ─────────────────────────────────────────────────────────────────
-
-export class AnalyticsIntelligence extends Context.Service<AnalyticsIntelligence, AnalyticsIntelligenceInterface>()("@opendash/AnalyticsIntelligence") {}
-
-// ─── Layer ───────────────────────────────────────────────────────────────────
-
-const layer = Layer.effect(
-  AnalyticsIntelligence,
-  Effect.gen(function* () {
-    const loader = yield* AnalyticsLoader.Service
-    const registry = yield* CapabilityRegistry.Service
-    const router = yield* AnalyticsRouter.Service
-    const orchestrator = yield* AnalyticsOrchestrator.Service
-    const planner = yield* PlannerEngine.Service
-    const workflowEngine = yield* WorkflowEngine.Service
-    const memory = yield* AnalyticsMemory.Service
-    const promptBuilder = yield* AnalyticsPromptBuilder.Service
-    const reasoning = yield* AnalyticalReasoning.Service
-
-    // Initialize loader on startup
-    yield* loader.load()
-
-    return AnalyticsIntelligence.of({
-      // Phase 1: Reasoning (Business-first)
-      reason: (request: string, context?: AnalyticsContext) =>
-        reasoning.reason(request, context),
-      
-      // Core pipeline
-      classify: (request: string) => router.classify(request),
-      
-      route: (classification: ClassificationResult) => router.route(classification),
-      
-      orchestrate: (route: RouteDecision) => orchestrator.orchestrate(route),
-      
-      plan: (executionPlan: ExecutionPlan) => planner.plan(executionPlan),
-      
-      buildPrompt: (plan: DetailedPlan, context?: AnalyticsContext) =>
-        promptBuilder.build(plan, context),
-      
-      createWorkflow: (plan: DetailedPlan) => workflowEngine.create(plan),
-      
-      startWorkflow: (state: WorkflowState) => workflowEngine.start(state),
-      
-      completeStep: (state: WorkflowState, stepId: string, output: unknown) =>
-        workflowEngine.completeStep(state, stepId, output),
-      
-      failStep: (state: WorkflowState, stepId: string, error: string) =>
-        workflowEngine.failStep(state, stepId, error),
-      
-      remember: (context: AnalyticsContext) =>
-        memory.update(context.sessionId, context),
-      
-      recall: (sessionId: string) => memory.recall(sessionId),
-      
-      explain: (request: string) => router.explain(request),
-      
-      // Full pipeline with reasoning FIRST
-      process: (request: string, sessionId: string) =>
-        Effect.gen(function* () {
-          // 1. REASON FIRST (Business-first, not tool-first)
-          const reasoningResult = yield* reasoning.reason(request)
-          
-          // 2. Classify
-          const classification = yield* router.classify(request)
-          
-          // 3. Route (using reasoning insights)
-          const route = yield* router.route(classification)
-          
-          // 4. Orchestrate
-          const executionPlan = yield* orchestrator.orchestrate(route)
-          
-          // 5. Plan
-          const detailedPlan = yield* planner.plan(executionPlan)
-          
-          // 6. Recall memory
-          const context = yield* memory.recall(sessionId)
-          
-          // 7. Build prompt (with reasoning context)
-          const prompt = yield* promptBuilder.build(detailedPlan, context)
-          
-          // 8. Create workflow
-          const workflow = yield* workflowEngine.create(detailedPlan)
-          
-          return {
-            reasoning: reasoningResult,
-            classification,
-            route,
-            executionPlan,
-            detailedPlan,
-            prompt,
-            workflow,
-          }
-        }),
-    })
-  })
-)
-
-// ─── Default Layer ───────────────────────────────────────────────────────────
-
-export const defaultLayer = layer.pipe(
-  Layer.provide(AnalyticsLoader.defaultLayer),
-  Layer.provide(CapabilityRegistry.defaultLayer),
-  Layer.provide(AnalyticsRouter.defaultLayer),
-  Layer.provide(AnalyticsOrchestrator.defaultLayer),
-  Layer.provide(PlannerEngine.defaultLayer),
-  Layer.provide(WorkflowEngine.defaultLayer),
-  Layer.provide(EngineRegistry.defaultLayer),
-  Layer.provide(AnalyticsMemory.defaultLayer),
-  Layer.provide(AnalyticsPromptBuilder.defaultLayer),
-  Layer.provide(AnalyticsAdapters.defaultLayer),
-  Layer.provide(AnalyticalReasoning.defaultLayer)
-)
-
-export * as Analytics from "./index"