@opendash-ai/cli 0.1.0-beta.1

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

@@ -0,0 +1,375 @@
+/**
+ * Workflow Engine - EXECUTABLE OBJECTS WITH STATES & TRANSITIONS
+ * 
+ * Workflows are executable objects with:
+ * - States: pending, running, completed, failed, paused, blocked
+ * - Transitions: valid state changes
+ * - Validation: checks before transitions
+ * - Completion: proper cleanup
+ * 
+ * State lives here, not in Orchestrator.
+ */
+
+import { Effect, Context, Layer } from "effect"
+import { PlannerEngine, type DetailedPlan, type PlanStep } from "../planner"
+import { AnalyticsLoader } from "../loader"
+import { Log } from "../../../util"
+
+const log = Log.create({ service: "analytics.workflow" }
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export type WorkflowStatus = "pending" | "running" | "completed" | "failed" | "paused" | "blocked" | "cancelled"
+
+export interface WorkflowState {
+  id: string
+  planId: string
+  goal: string
+  workflow: string
+  status: WorkflowStatus
+  currentStep: string | undefined
+  completedSteps: string[]
+  failedSteps: string[]
+  blockedSteps: string[]
+  outputs: Record<string, unknown>
+  errors: Record<string, string>
+  startTime: Date
+  endTime?: Date
+  lastTransition: Date
+  transitionHistory: Transition[]
+}
+
+export interface Transition {
+  from: WorkflowStatus
+  to: WorkflowStatus
+  timestamp: Date
+  reason: string
+  stepId?: string
+}
+
+export interface WorkflowStatusInfo {
+  status: WorkflowStatus
+  progress: number
+  currentStep: string | undefined
+  completedSteps: number
+  totalSteps: number
+  failedSteps: number
+  blockedSteps: number
+  estimatedTimeRemaining: string
+  canAdvance: boolean
+  canPause: boolean
+  canCancel: boolean
+}
+
+// ─── Valid Transitions ───────────────────────────────────────────────────────
+
+const VALID_TRANSITIONS: Record<WorkflowStatus, WorkflowStatus[]> = {
+  pending: ["running", "cancelled"],
+  running: ["completed", "failed", "paused", "blocked", "cancelled"],
+  completed: [],  // Terminal state
+  failed: ["pending", "cancelled"],  // Can retry
+  paused: ["running", "cancelled"],
+  blocked: ["running", "cancelled"],
+  cancelled: [],  // Terminal state
+}
+
+// ─── Workflow Interface ──────────────────────────────────────────────────────
+
+export interface WorkflowInterface {
+  readonly create: (plan: DetailedPlan) => Effect.Effect<WorkflowState>
+  readonly start: (state: WorkflowState) => Effect.Effect<WorkflowState>
+  readonly advance: (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>
+  readonly blockStep: (state: WorkflowState, stepId: string, reason: string) -> Effect.Effect<WorkflowState>
+  readonly pause: (state: WorkflowState) => Effect.Effect<WorkflowState>
+  readonly resume: (state: WorkflowState) => Effect.Effect<WorkflowState>
+  readonly cancel: (state: WorkflowState) => Effect.Effect<WorkflowState>
+  readonly retry: (state: WorkflowState) => Effect.Effect<WorkflowState>
+  readonly getStatus: (state: WorkflowState) => Effect.Effect<WorkflowStatusInfo>
+  readonly canTransition: (from: WorkflowStatus, to: WorkflowStatus) => boolean
+  readonly getTransitionHistory: (state: WorkflowState) => Transition[]
+}
+
+export class WorkflowEngine extends Context.Service<WorkflowEngine, WorkflowInterface>()("@opendash/WorkflowEngine") {}
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function createTransition(from: WorkflowStatus, to: WorkflowStatus, reason: string, stepId?: string): Transition {
+  return {
+    from,
+    to,
+    timestamp: new Date(),
+    reason,
+    stepId,
+  }
+}
+
+function calculateProgress(completedSteps: string[], totalSteps: number): number {
+  if (totalSteps === 0) return 0
+  return (completedSteps.length / totalSteps) * 100
+}
+
+function estimateTimeRemaining(completedSteps: number, totalSteps: number): string {
+  const remaining = totalSteps - completedSteps
+  const minutesRemaining = remaining * 15
+  
+  if (minutesRemaining > 60) {
+    return `${Math.floor(minutesRemaining / 60)}-${Math.ceil(minutesRemaining / 60)} hours`
+  }
+  return `${minutesRemaining}-${minutesRemaining + 15} minutes`
+}
+
+// ─── Implementation ──────────────────────────────────────────────────────────
+
+const layer: Layer.Layer<WorkflowEngine, never, PlannerEngine.Service | AnalyticsLoader.Service> = Layer.effect(
+  WorkflowEngine,
+  Effect.gen(function* () {
+    const planner = yield* PlannerEngine.Service
+    const loader = yield* AnalyticsLoader.Service
+
+    // Validate transition is allowed
+    const canTransition = (from: WorkflowStatus, to: WorkflowStatus): boolean => {
+      return VALID_TRANSITIONS[from]?.includes(to) ?? false
+    }
+
+    // Apply transition with validation
+    const applyTransition = (
+      state: WorkflowState,
+      to: WorkflowStatus,
+      reason: string,
+      stepId?: string
+    ): WorkflowState => {
+      if (!canTransition(state.status, to)) {
+        throw new Error(`Invalid transition: ${state.status} -> ${to}`)
+      }
+      
+      const transition = createTransition(state.status, to, reason, stepId)
+      
+      return {
+        ...state,
+        status: to,
+        lastTransition: new Date(),
+        transitionHistory: [...state.transitionHistory, transition],
+        endTime: to === "completed" || to === "failed" || to === "cancelled" ? new Date() : undefined,
+      }
+    }
+
+    // Create workflow from plan
+    const create = Effect.fn("create")(function* (plan: DetailedPlan) {
+      const state: WorkflowState = {
+        id: `workflow_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
+        planId: plan.goal,
+        goal: plan.goal,
+        workflow: plan.workflow,
+        status: "pending",
+        currentStep: plan.steps[0]?.id,
+        completedSteps: [],
+        failedSteps: [],
+        blockedSteps: [],
+        outputs: {},
+        errors: {},
+        startTime: new Date(),
+        lastTransition: new Date(),
+        transitionHistory: [createTransition("pending", "pending", "Workflow created")],
+      }
+
+      log.info("workflow created", {
+        id: state.id,
+        goal: state.goal,
+        workflow: state.workflow,
+        totalSteps: plan.steps.length,
+      })
+
+      return state
+    })
+
+    // Start workflow
+    const start = Effect.fn("start")(function* (state: WorkflowState) {
+      return applyTransition(state, "running", "Workflow started")
+    })
+
+    // Advance to next step
+    const advance = Effect.fn("advance")(function* (state: WorkflowState) {
+      // Find next step that isn't completed or failed
+      const plan = yield* planner.plan({
+        goal: state.goal,
+        workflow: state.workflow,
+        steps: [],
+        requiredAgents: [],
+        requiredTools: [],
+        deliverables: [],
+        estimatedComplexity: "low",
+      })
+      
+      const nextStep = plan.steps.find(
+        s => !state.completedSteps.includes(s.id) && !state.failedSteps.includes(s.id)
+      )
+
+      if (!nextStep) {
+        // No more steps - complete workflow
+        return applyTransition(state, "completed", "All steps completed")
+      }
+
+      return {
+        ...state,
+        currentStep: nextStep.id,
+      }
+    })
+
+    // Complete a step
+    const completeStep = Effect.fn("completeStep")(function* (
+      state: WorkflowState,
+      stepId: string,
+      output: unknown
+    ) {
+      const newState = {
+        ...state,
+        completedSteps: [...state.completedSteps, stepId],
+        outputs: {
+          ...state.outputs,
+          [stepId]: output,
+        },
+      }
+
+      // Find next step
+      const plan = yield* planner.plan({
+        goal: state.goal,
+        workflow: state.workflow,
+        steps: [],
+        requiredAgents: [],
+        requiredTools: [],
+        deliverables: [],
+        estimatedComplexity: "low",
+      })
+      
+      const nextStep = plan.steps.find(
+        s => !newState.completedSteps.includes(s.id) && !newState.failedSteps.includes(s.id)
+      )
+
+      if (!nextStep) {
+        return applyTransition(newState, "completed", "All steps completed", stepId)
+      }
+
+      return {
+        ...newState,
+        currentStep: nextStep.id,
+      }
+    })
+
+    // Fail a step
+    const failStep = Effect.fn("failStep")(function* (
+      state: WorkflowState,
+      stepId: string,
+      error: string
+    ) {
+      const newState = {
+        ...state,
+        failedSteps: [...state.failedSteps, stepId],
+        errors: {
+          ...state.errors,
+          [stepId]: error,
+        },
+      }
+
+      return applyTransition(newState, "failed", `Step ${stepId} failed: ${error}`, stepId)
+    })
+
+    // Block a step
+    const blockStep = Effect.fn("blockStep")(function* (
+      state: WorkflowState,
+      stepId: string,
+      reason: string
+    ) {
+      const newState = {
+        ...state,
+        blockedSteps: [...state.blockedSteps, stepId],
+      }
+
+      return applyTransition(newState, "blocked", `Step ${stepId} blocked: ${reason}`, stepId)
+    })
+
+    // Pause workflow
+    const pause = Effect.fn("pause")(function* (state: WorkflowState) {
+      return applyTransition(state, "paused", "Workflow paused")
+    })
+
+    // Resume workflow
+    const resume = Effect.fn("resume")(function* (state: WorkflowState) {
+      return applyTransition(state, "running", "Workflow resumed")
+    })
+
+    // Cancel workflow
+    const cancel = Effect.fn("cancel")(function* (state: WorkflowState) {
+      return applyTransition(state, "cancelled", "Workflow cancelled")
+    })
+
+    // Retry failed workflow
+    const retry = Effect.fn("retry")(function* (state: WorkflowState) {
+      if (state.status !== "failed") {
+        throw new Error("Can only retry failed workflows")
+      }
+      
+      return {
+        ...applyTransition(state, "pending", "Workflow retrying"),
+        failedSteps: [],
+        errors: {},
+      }
+    })
+
+    // Get workflow status
+    const getStatus = Effect.fn("getStatus")(function* (state: WorkflowState) {
+      const plan = yield* planner.plan({
+        goal: state.goal,
+        workflow: state.workflow,
+        steps: [],
+        requiredAgents: [],
+        requiredTools: [],
+        deliverables: [],
+        estimatedComplexity: "low",
+      })
+      
+      const totalSteps = plan.steps.length
+      
+      return {
+        status: state.status,
+        progress: calculateProgress(state.completedSteps, totalSteps),
+        currentStep: state.currentStep,
+        completedSteps: state.completedSteps.length,
+        totalSteps,
+        failedSteps: state.failedSteps.length,
+        blockedSteps: state.blockedSteps.length,
+        estimatedTimeRemaining: estimateTimeRemaining(state.completedSteps.length, totalSteps),
+        canAdvance: state.status === "running",
+        canPause: state.status === "running",
+        canCancel: ["pending", "running", "paused", "blocked"].includes(state.status),
+      }
+    })
+
+    // Get transition history
+    const getTransitionHistory = (state: WorkflowState): Transition[] => {
+      return state.transitionHistory
+    }
+
+    return WorkflowEngine.of({
+      create,
+      start,
+      advance,
+      completeStep,
+      failStep,
+      blockStep,
+      pause,
+      resume,
+      cancel,
+      retry,
+      getStatus,
+      canTransition,
+      getTransitionHistory,
+    })
+  })
+)
+
+export const defaultLayer = layer.pipe(
+  Layer.provide(PlannerEngine.defaultLayer),
+  Layer.provide(AnalyticsLoader.defaultLayer)
+)

package/src/intelligence/index.ts

@@ -0,0 +1,50 @@
+/**
+ * Intelligence Layer
+ * 
+ * Main entry point for the Data OS Intelligence Layer.
+ * 
+ * This module provides the analytics intelligence subsystem that sits above
+ * OpenDash's runtime. It handles:
+ * - Capability registry and workflow management
+ * - Request routing and classification
+ * - Analytics orchestration
+ * - Memory management for analytics context
+ * - Prompt building with analytics context
+ * 
+ * Architecture:
+ * - Data OS decides WHAT to do and WHY
+ * - OpenDash executes HOW to do it
+ * 
+ * @version 5.0.0
+ * @license MIT
+ */
+
+import { Effect, Layer, Context } from "effect"
+import { Analytics, AnalyticsIntelligence, defaultLayer as analyticsDefaultLayer } from "./analytics"
+
+// Re-export all analytics modules
+export * from "./analytics"
+
+// Intelligence interface
+export interface IntelligenceInterface {
+  readonly analytics: AnalyticsIntelligence.Service
+}
+
+// Service class
+export class Intelligence extends Context.Service<Intelligence, IntelligenceInterface>()("@opendash/Intelligence") {}
+
+// Default layer
+export const defaultLayer = Layer.effect(
+  Intelligence,
+  Effect.gen(function* () {
+    const analytics = yield* AnalyticsIntelligence.Service
+
+    return Intelligence.of({
+      analytics,
+    })
+  })
+).pipe(
+  Layer.provide(analyticsDefaultLayer)
+)
+
+export * as Intelligence from "./index"

package/src/lsp/client.ts

@@ -0,0 +1,249 @@
+import { BusEvent } from "@/bus/bus-event"
+import { Bus } from "@/bus"
+import path from "path"
+import { pathToFileURL, fileURLToPath } from "url"
+import { createMessageConnection, StreamMessageReader, StreamMessageWriter } from "vscode-jsonrpc/node"
+import type { Diagnostic as VSCodeDiagnostic } from "vscode-languageserver-types"
+import { Log } from "../util"
+import { Process } from "../util"
+import { LANGUAGE_EXTENSIONS } from "./language"
+import z from "zod"
+import type * as LSPServer from "./server"
+import { NamedError } from "@opendash-ai/shared/util/error"
+import { withTimeout } from "../util/timeout"
+import { Filesystem } from "../util"
+
+const DIAGNOSTICS_DEBOUNCE_MS = 150
+
+const log = Log.create({ service: "lsp.client" })
+
+export type Info = NonNullable<Awaited<ReturnType<typeof create>>>
+
+export type Diagnostic = VSCodeDiagnostic
+
+export const InitializeError = NamedError.create(
+  "LSPInitializeError",
+  z.object({
+    serverID: z.string(),
+  }),
+)
+
+export const Event = {
+  Diagnostics: BusEvent.define(
+    "lsp.client.diagnostics",
+    z.object({
+      serverID: z.string(),
+      path: z.string(),
+    }),
+  ),
+}
+
+export async function create(input: { serverID: string; server: LSPServer.Handle; root: string; directory: string }) {
+  const l = log.clone().tag("serverID", input.serverID)
+  l.info("starting client")
+
+  const connection = createMessageConnection(
+    new StreamMessageReader(input.server.process.stdout as any),
+    new StreamMessageWriter(input.server.process.stdin as any),
+  )
+
+  const diagnostics = new Map<string, Diagnostic[]>()
+  connection.onNotification("textDocument/publishDiagnostics", (params) => {
+    const filePath = Filesystem.normalizePath(fileURLToPath(params.uri))
+    l.info("textDocument/publishDiagnostics", {
+      path: filePath,
+      count: params.diagnostics.length,
+    })
+    const exists = diagnostics.has(filePath)
+    diagnostics.set(filePath, params.diagnostics)
+    if (!exists && input.serverID === "typescript") return
+    Bus.publish(Event.Diagnostics, { path: filePath, serverID: input.serverID })
+  })
+  connection.onRequest("window/workDoneProgress/create", (params) => {
+    l.info("window/workDoneProgress/create", params)
+    return null
+  })
+  connection.onRequest("workspace/configuration", async () => {
+    // Return server initialization options
+    return [input.server.initialization ?? {}]
+  })
+  connection.onRequest("client/registerCapability", async () => {})
+  connection.onRequest("client/unregisterCapability", async () => {})
+  connection.onRequest("workspace/workspaceFolders", async () => [
+    {
+      name: "workspace",
+      uri: pathToFileURL(input.root).href,
+    },
+  ])
+  connection.listen()
+
+  l.info("sending initialize")
+  await withTimeout(
+    connection.sendRequest("initialize", {
+      rootUri: pathToFileURL(input.root).href,
+      processId: input.server.process.pid,
+      workspaceFolders: [
+        {
+          name: "workspace",
+          uri: pathToFileURL(input.root).href,
+        },
+      ],
+      initializationOptions: {
+        ...input.server.initialization,
+      },
+      capabilities: {
+        window: {
+          workDoneProgress: true,
+        },
+        workspace: {
+          configuration: true,
+          didChangeWatchedFiles: {
+            dynamicRegistration: true,
+          },
+        },
+        textDocument: {
+          synchronization: {
+            didOpen: true,
+            didChange: true,
+          },
+          publishDiagnostics: {
+            versionSupport: true,
+          },
+        },
+      },
+    }),
+    45_000,
+  ).catch((err) => {
+    l.error("initialize error", { error: err })
+    throw new InitializeError(
+      { serverID: input.serverID },
+      {
+        cause: err,
+      },
+    )
+  })
+
+  await connection.sendNotification("initialized", {})
+
+  if (input.server.initialization) {
+    await connection.sendNotification("workspace/didChangeConfiguration", {
+      settings: input.server.initialization,
+    })
+  }
+
+  const files: {
+    [path: string]: number
+  } = {}
+
+  const result = {
+    root: input.root,
+    get serverID() {
+      return input.serverID
+    },
+    get connection() {
+      return connection
+    },
+    notify: {
+      async open(request: { path: string }) {
+        request.path = path.isAbsolute(request.path) ? request.path : path.resolve(input.directory, request.path)
+        const text = await Filesystem.readText(request.path)
+        const extension = path.extname(request.path)
+        const languageId = LANGUAGE_EXTENSIONS[extension] ?? "plaintext"
+
+        const version = files[request.path]
+        if (version !== undefined) {
+          log.info("workspace/didChangeWatchedFiles", request)
+          await connection.sendNotification("workspace/didChangeWatchedFiles", {
+            changes: [
+              {
+                uri: pathToFileURL(request.path).href,
+                type: 2, // Changed
+              },
+            ],
+          })
+
+          const next = version + 1
+          files[request.path] = next
+          log.info("textDocument/didChange", {
+            path: request.path,
+            version: next,
+          })
+          await connection.sendNotification("textDocument/didChange", {
+            textDocument: {
+              uri: pathToFileURL(request.path).href,
+              version: next,
+            },
+            contentChanges: [{ text }],
+          })
+          return
+        }
+
+        log.info("workspace/didChangeWatchedFiles", request)
+        await connection.sendNotification("workspace/didChangeWatchedFiles", {
+          changes: [
+            {
+              uri: pathToFileURL(request.path).href,
+              type: 1, // Created
+            },
+          ],
+        })
+
+        log.info("textDocument/didOpen", request)
+        diagnostics.delete(request.path)
+        await connection.sendNotification("textDocument/didOpen", {
+          textDocument: {
+            uri: pathToFileURL(request.path).href,
+            languageId,
+            version: 0,
+            text,
+          },
+        })
+        files[request.path] = 0
+        return
+      },
+    },
+    get diagnostics() {
+      return diagnostics
+    },
+    async waitForDiagnostics(request: { path: string }) {
+      const normalizedPath = Filesystem.normalizePath(
+        path.isAbsolute(request.path) ? request.path : path.resolve(input.directory, request.path),
+      )
+      log.info("waiting for diagnostics", { path: normalizedPath })
+      let unsub: () => void
+      let debounceTimer: ReturnType<typeof setTimeout> | undefined
+      return await withTimeout(
+        new Promise<void>((resolve) => {
+          unsub = Bus.subscribe(Event.Diagnostics, (event) => {
+            if (event.properties.path === normalizedPath && event.properties.serverID === result.serverID) {
+              // Debounce to allow LSP to send follow-up diagnostics (e.g., semantic after syntax)
+              if (debounceTimer) clearTimeout(debounceTimer)
+              debounceTimer = setTimeout(() => {
+                log.info("got diagnostics", { path: normalizedPath })
+                unsub?.()
+                resolve()
+              }, DIAGNOSTICS_DEBOUNCE_MS)
+            }
+          })
+        }),
+        3000,
+      )
+        .catch(() => {})
+        .finally(() => {
+          if (debounceTimer) clearTimeout(debounceTimer)
+          unsub?.()
+        })
+    },
+    async shutdown() {
+      l.info("shutting down")
+      connection.end()
+      connection.dispose()
+      await Process.stop(input.server.process)
+      l.info("shutdown")
+    },
+  }
+
+  l.info("initialized")
+
+  return result
+}

package/src/lsp/diagnostic.ts

@@ -0,0 +1,29 @@
+import * as LSPClient from "./client"
+
+const MAX_PER_FILE = 20
+
+export function pretty(diagnostic: LSPClient.Diagnostic) {
+  const severityMap = {
+    1: "ERROR",
+    2: "WARN",
+    3: "INFO",
+    4: "HINT",
+  }
+
+  const severity = severityMap[diagnostic.severity || 1]
+  const line = diagnostic.range.start.line + 1
+  const col = diagnostic.range.start.character + 1
+
+  return `${severity} [${line}:${col}] ${diagnostic.message}`
+}
+
+export function report(file: string, issues: LSPClient.Diagnostic[]) {
+  const errors = issues.filter((item) => item.severity === 1)
+  if (errors.length === 0) return ""
+  const limited = errors.slice(0, MAX_PER_FILE)
+  const more = errors.length - MAX_PER_FILE
+  const suffix = more > 0 ? `\n... and ${more} more` : ""
+  return `<diagnostics file="${file}">\n${limited.map(pretty).join("\n")}${suffix}\n</diagnostics>`
+}
+
+export * as Diagnostic from "./diagnostic"

package/src/lsp/index.ts

@@ -0,0 +1,3 @@
+export * as LSP from "./lsp"
+export * as LSPClient from "./client"
+export * as LSPServer from "./server"