@perceo/observer-engine 0.1.0 → 2.0.1

package/dist/index.d.ts

@@ -1,3 +1,12 @@
+import { TestRun, Insight, Flow, FlowInsert, PerceoDataClient } from '@perceo/supabase';
+
+interface TemporalConfig {
+    enabled: boolean;
+    address?: string;
+    namespace?: string;
+    taskQueue?: string;
+    apiKey?: string;
+}
 interface ObserverEngineConfig {
     observer: {
         watch: {
@@ -30,6 +39,7 @@ interface ObserverEngineConfig {
         type: "in-memory" | "redis";
         redisUrl?: string;
     };
+    temporal?: TemporalConfig;
 }
 interface ChangeAnalysisFile {
     path: string;
@@ -96,26 +106,42 @@ declare class ObserverEngine {
     private readonly config;
     private readonly deps;
     private readonly apiClient;
+    private readonly temporalClient;
     constructor(config: ObserverEngineConfig, deps?: ObserverEngineDeps);
     /**
      * Bootstrap flows/personas for the current project.
      *
-     * Delegates to the managed Observer API when configured, otherwise returns
-     * a fast local no-op result so init remains non-blocking.
+     * Delegates to Temporal workflow if enabled, otherwise uses the managed
+     * Observer API directly. Returns a local no-op result if no API is configured.
      */
     bootstrapProject(options: BootstrapOptions): Promise<BootstrapResult>;
+    /**
+     * Bootstrap via Temporal workflow
+     */
+    private bootstrapProjectViaWorkflow;
+    /**
+     * Bootstrap via direct API call (original implementation)
+     */
+    private bootstrapProjectDirect;
     /**
      * Analyze changes between two Git refs and return an ImpactReport.
      *
-     * Uses local Git diff to build a ChangeAnalysis, then delegates to the
-     * managed Observer API when configured. If no API is configured, returns
-     * a minimal, local-only report that still captures the changed files.
+     * Delegates to Temporal workflow if enabled, otherwise uses local Git diff
+     * and managed Observer API directly.
      */
     analyzeChanges(params: {
         baseSha: string;
         headSha: string;
         projectRoot: string;
     }): Promise<ImpactReport>;
+    /**
+     * Analyze changes via Temporal workflow
+     */
+    private analyzeChangesViaWorkflow;
+    /**
+     * Analyze changes via direct API call (original implementation)
+     */
+    private analyzeChangesDirect;
     /**
      * Core entry point for watch-mode integration.
      *
@@ -146,4 +172,127 @@ declare class ObserverApiClient {
     private post;
 }
 
-export { type BootstrapOptions, type BootstrapResult, type ChangeAnalysis, type ChangeAnalysisFile, type EventBusLike, type FlowGraphClientLike, type ImpactReport, type ImpactedFlow, ObserverApiClient, type ObserverApiClientOptions, ObserverEngine, type ObserverEngineConfig, type ObserverEngineDeps, type PerceoEvent };
+declare function computeChangeAnalysis(projectRoot: string, baseSha: string, headSha: string): Promise<ChangeAnalysis>;
+
+/**
+ * Supabase-Powered Observer Engine
+ *
+ * Implements the Observer Engine workflow using Supabase for:
+ * - Persistent storage of code changes, flows, and analysis results
+ * - Realtime event bus via Supabase Realtime (replaces Redis pub/sub)
+ * - File watching with change detection and flow impact analysis
+ */
+
+interface SupabaseObserverConfig {
+    supabaseUrl: string;
+    supabaseKey: string;
+    projectId: string;
+    projectName: string;
+    watch?: {
+        paths: string[];
+        ignore?: string[];
+        debounceMs?: number;
+    };
+    analysis?: {
+        useLLM?: boolean;
+        llmThreshold?: number;
+    };
+}
+interface FileChange {
+    path: string;
+    type: "add" | "change" | "unlink";
+    timestamp: number;
+}
+interface ObserverCallbacks {
+    onFileChange?: (change: FileChange) => void | Promise<void>;
+    onAnalysisStart?: (changeId: string) => void | Promise<void>;
+    onAnalysisComplete?: (report: ImpactReport) => void | Promise<void>;
+    onFlowsAffected?: (flows: ImpactedFlow[]) => void | Promise<void>;
+    onTestRunUpdate?: (testRun: TestRun) => void | Promise<void>;
+    onInsightCreated?: (insight: Insight) => void | Promise<void>;
+    onError?: (error: Error) => void | Promise<void>;
+}
+declare class SupabaseObserverEngine {
+    private readonly config;
+    private readonly client;
+    private readonly callbacks;
+    private watcher;
+    private pendingChanges;
+    private debounceTimer;
+    private isAnalyzing;
+    constructor(config: SupabaseObserverConfig, callbacks?: ObserverCallbacks);
+    /**
+     * Create from observer engine config (backwards compatible)
+     */
+    static fromConfig(config: ObserverEngineConfig, projectId: string, projectName: string, callbacks?: ObserverCallbacks): SupabaseObserverEngine | null;
+    /**
+     * Start watching for file changes
+     */
+    startWatch(projectRoot: string): Promise<void>;
+    /**
+     * Stop watching for file changes
+     */
+    stopWatch(): Promise<void>;
+    /**
+     * Set up Supabase Realtime subscriptions
+     */
+    private setupRealtimeSubscriptions;
+    /**
+     * Handle individual file change
+     */
+    private handleFileChange;
+    /**
+     * Process accumulated changes
+     */
+    private processChanges;
+    /**
+     * Match flows affected by changed files
+     */
+    private matchAffectedFlows;
+    /**
+     * Check if a flow is affected by changed files
+     */
+    private doesFlowMatchChanges;
+    /**
+     * Check if a file path matches a pattern
+     */
+    private pathMatchesPattern;
+    /**
+     * Calculate aggregate risk score from affected flows
+     */
+    private calculateRiskScore;
+    /**
+     * Get risk level from score
+     */
+    private getRiskLevel;
+    /**
+     * Get current HEAD commit SHA
+     */
+    private getCurrentHead;
+    /**
+     * Manually analyze changes between two commits
+     */
+    analyzeChanges(projectRoot: string, baseSha: string, headSha: string): Promise<ImpactReport>;
+    /**
+     * Get all flows for the project
+     */
+    getFlows(): Promise<Flow[]>;
+    /**
+     * Get flows affected by recent changes
+     */
+    getAffectedFlows(): Promise<Flow[]>;
+    /**
+     * Create or update flows (bootstrap)
+     */
+    upsertFlows(flows: FlowInsert[]): Promise<Flow[]>;
+    /**
+     * Clear affected status from flows (e.g., after tests pass)
+     */
+    clearAffectedFlows(flowIds: string[]): Promise<void>;
+    /**
+     * Get the data client for direct access
+     */
+    getDataClient(): PerceoDataClient;
+}
+
+export { type BootstrapOptions, type BootstrapResult, type ChangeAnalysis, type ChangeAnalysisFile, type EventBusLike, type FileChange, type FlowGraphClientLike, type ImpactReport, type ImpactedFlow, ObserverApiClient, type ObserverApiClientOptions, type ObserverCallbacks, ObserverEngine, type ObserverEngineConfig, type ObserverEngineDeps, type PerceoEvent, type SupabaseObserverConfig, SupabaseObserverEngine, type TemporalConfig, computeChangeAnalysis };

package/dist/index.js

@@ -52,7 +52,9 @@ async function computeChangeAnalysis(projectRoot, baseSha, headSha) {
     cwd: projectRoot
   });
   const files = stdout.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).map((line) => {
-    const [status, filePath] = line.split(/\s+/, 2);
+    const parts = line.split(/\s+/);
+    const status = parts[0] ?? "M";
+    const filePath = parts[1] ?? "";
     return {
       path: normalizePath(filePath),
       status: mapStatus(status)
@@ -84,23 +86,144 @@ function normalizePath(p) {
   return p.split("\\").join("/");
 }
 
+// src/temporal-client.ts
+import { Client, Connection } from "@temporalio/client";
+var TemporalClient = class {
+  config;
+  clientPromise = null;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Gets or creates the Temporal client
+   */
+  async getClient() {
+    if (!this.clientPromise) {
+      this.clientPromise = this.createClient();
+    }
+    return this.clientPromise;
+  }
+  /**
+   * Creates a new Temporal client with connection
+   */
+  async createClient() {
+    const address = this.config.address || "localhost:7233";
+    const namespace = this.config.namespace || "perceo";
+    const connection = await Connection.connect({
+      address,
+      tls: true,
+      apiKey: this.config.apiKey
+    });
+    return new Client({
+      connection,
+      namespace
+    });
+  }
+  /**
+   * Executes a workflow and waits for result
+   */
+  async executeWorkflow(workflowName, input, options) {
+    const client = await this.getClient();
+    const taskQueue = options.taskQueue || this.config.taskQueue || "observer-engine";
+    const handle = await client.workflow.start(workflowName, {
+      args: [input],
+      taskQueue,
+      workflowId: options.workflowId
+    });
+    return await handle.result();
+  }
+  /**
+   * Starts a workflow without waiting for result
+   */
+  async startWorkflow(workflowName, input, options) {
+    const client = await this.getClient();
+    const taskQueue = options.taskQueue || this.config.taskQueue || "observer-engine";
+    return await client.workflow.start(workflowName, {
+      args: [input],
+      taskQueue,
+      workflowId: options.workflowId
+    });
+  }
+  /**
+   * Gets a handle to an existing workflow
+   */
+  async getWorkflowHandle(workflowId) {
+    const client = await this.getClient();
+    return client.workflow.getHandle(workflowId);
+  }
+  /**
+   * Signals a running workflow
+   */
+  async signalWorkflow(workflowId, signalName, args) {
+    const handle = await this.getWorkflowHandle(workflowId);
+    await handle.signal(signalName, ...args || []);
+  }
+  /**
+   * Queries a running workflow
+   */
+  async queryWorkflow(workflowId, queryName) {
+    const handle = await this.getWorkflowHandle(workflowId);
+    return await handle.query(queryName);
+  }
+};
+
 // src/engine.ts
 var ObserverEngine = class {
   config;
   deps;
   apiClient;
+  temporalClient;
   constructor(config, deps = {}) {
     this.config = config;
     this.deps = deps;
     this.apiClient = ObserverApiClient.fromConfig(config);
+    this.temporalClient = config.temporal?.enabled ? new TemporalClient(config.temporal) : null;
   }
   /**
    * Bootstrap flows/personas for the current project.
    *
-   * Delegates to the managed Observer API when configured, otherwise returns
-   * a fast local no-op result so init remains non-blocking.
+   * Delegates to Temporal workflow if enabled, otherwise uses the managed
+   * Observer API directly. Returns a local no-op result if no API is configured.
    */
   async bootstrapProject(options) {
+    if (this.temporalClient) {
+      return this.bootstrapProjectViaWorkflow(options);
+    }
+    return this.bootstrapProjectDirect(options);
+  }
+  /**
+   * Bootstrap via Temporal workflow
+   */
+  async bootstrapProjectViaWorkflow(options) {
+    if (!this.config.observer.apiBaseUrl) {
+      throw new Error("Observer API base URL is required for Temporal workflows");
+    }
+    const workflowInput = {
+      projectDir: options.projectDir,
+      projectName: options.projectName,
+      framework: options.framework,
+      apiConfig: {
+        baseUrl: this.config.observer.apiBaseUrl,
+        apiKey: this.config.observer.apiKey
+      },
+      eventBusConfig: this.config.eventBus?.type === "redis" ? {
+        redisUrl: this.config.eventBus.redisUrl || process.env.PERCEO_REDIS_URL || ""
+      } : void 0
+    };
+    const result = await this.temporalClient.executeWorkflow("bootstrapProjectWorkflow", workflowInput, {
+      workflowId: `bootstrap-${options.projectName}-${Date.now()}`
+    });
+    return {
+      projectName: result.projectName || options.projectName,
+      framework: result.framework,
+      flowsInitialized: result.flows?.length || 0,
+      personasInitialized: result.personas?.length || 0
+    };
+  }
+  /**
+   * Bootstrap via direct API call (original implementation)
+   */
+  async bootstrapProjectDirect(options) {
     if (!this.apiClient) {
       return {
         projectName: options.projectName,
@@ -119,11 +242,57 @@ var ObserverEngine = class {
   /**
    * Analyze changes between two Git refs and return an ImpactReport.
    *
-   * Uses local Git diff to build a ChangeAnalysis, then delegates to the
-   * managed Observer API when configured. If no API is configured, returns
-   * a minimal, local-only report that still captures the changed files.
+   * Delegates to Temporal workflow if enabled, otherwise uses local Git diff
+   * and managed Observer API directly.
    */
   async analyzeChanges(params) {
+    if (this.temporalClient) {
+      return this.analyzeChangesViaWorkflow(params);
+    }
+    return this.analyzeChangesDirect(params);
+  }
+  /**
+   * Analyze changes via Temporal workflow
+   */
+  async analyzeChangesViaWorkflow(params) {
+    if (!this.config.observer.apiBaseUrl) {
+      throw new Error("Observer API base URL is required for Temporal workflows");
+    }
+    const workflowInput = {
+      projectId: "default",
+      // TODO: Get from config or context
+      projectRoot: params.projectRoot,
+      baseSha: params.baseSha,
+      headSha: params.headSha,
+      apiConfig: {
+        baseUrl: this.config.observer.apiBaseUrl,
+        apiKey: this.config.observer.apiKey
+      },
+      eventBusConfig: this.config.eventBus?.type === "redis" ? {
+        redisUrl: this.config.eventBus.redisUrl || process.env.PERCEO_REDIS_URL || ""
+      } : void 0
+    };
+    const result = await this.temporalClient.executeWorkflow("analyzeChangesWorkflow", workflowInput, {
+      workflowId: `analyze-${params.baseSha}-${params.headSha}-${Date.now()}`
+    });
+    return {
+      changeId: `${params.baseSha}...${params.headSha}`,
+      baseSha: params.baseSha,
+      headSha: params.headSha,
+      flows: result.affectedFlows.map((flowId) => ({
+        name: flowId,
+        confidence: 0.8,
+        riskScore: result.riskLevel === "high" ? 0.8 : result.riskLevel === "medium" ? 0.5 : 0.2
+      })),
+      changes: [],
+      // Changes already analyzed by workflow
+      createdAt: Date.now()
+    };
+  }
+  /**
+   * Analyze changes via direct API call (original implementation)
+   */
+  async analyzeChangesDirect(params) {
     const change = await computeChangeAnalysis(params.projectRoot, params.baseSha, params.headSha);
     let report;
     if (this.apiClient) {
@@ -163,7 +332,403 @@ var ObserverEngine = class {
     };
   }
 };
+
+// src/supabase-observer.ts
+import chokidar from "chokidar";
+import { PerceoDataClient } from "@perceo/supabase";
+var SupabaseObserverEngine = class _SupabaseObserverEngine {
+  config;
+  client;
+  callbacks;
+  watcher = null;
+  pendingChanges = /* @__PURE__ */ new Map();
+  debounceTimer = null;
+  isAnalyzing = false;
+  constructor(config, callbacks = {}) {
+    this.config = config;
+    this.callbacks = callbacks;
+    this.client = new PerceoDataClient({
+      supabaseUrl: config.supabaseUrl,
+      supabaseKey: config.supabaseKey,
+      projectId: config.projectId
+    });
+  }
+  /**
+   * Create from observer engine config (backwards compatible)
+   */
+  static fromConfig(config, projectId, projectName, callbacks) {
+    const supabaseUrl = process.env.PERCEO_SUPABASE_URL;
+    const supabaseKey = process.env.PERCEO_SUPABASE_SERVICE_ROLE_KEY || process.env.PERCEO_SUPABASE_ANON_KEY;
+    if (!supabaseUrl || !supabaseKey) {
+      return null;
+    }
+    return new _SupabaseObserverEngine(
+      {
+        supabaseUrl,
+        supabaseKey,
+        projectId,
+        projectName,
+        watch: config.observer.watch,
+        analysis: config.observer.analysis
+      },
+      callbacks
+    );
+  }
+  /**
+   * Start watching for file changes
+   */
+  async startWatch(projectRoot) {
+    const watchPaths = this.config.watch?.paths ?? ["src/", "app/", "pages/", "components/"];
+    const ignorePaths = this.config.watch?.ignore ?? ["node_modules/", ".next/", ".git/", "dist/"];
+    const debounceMs = this.config.watch?.debounceMs ?? 500;
+    await this.setupRealtimeSubscriptions();
+    this.watcher = chokidar.watch(
+      watchPaths.map((p) => `${projectRoot}/${p}`),
+      {
+        ignored: ignorePaths.map((p) => `**/${p}**`),
+        ignoreInitial: true,
+        persistent: true,
+        awaitWriteFinish: {
+          stabilityThreshold: 100,
+          pollInterval: 50
+        }
+      }
+    );
+    this.watcher.on("add", (path) => this.handleFileChange(path, "add"));
+    this.watcher.on("change", (path) => this.handleFileChange(path, "change"));
+    this.watcher.on("unlink", (path) => this.handleFileChange(path, "unlink"));
+    this.watcher.on("error", (error) => {
+      this.callbacks.onError?.(error);
+    });
+    this.watcher.on("all", () => {
+      if (this.debounceTimer) {
+        clearTimeout(this.debounceTimer);
+      }
+      this.debounceTimer = setTimeout(() => {
+        this.processChanges(projectRoot);
+      }, debounceMs);
+    });
+  }
+  /**
+   * Stop watching for file changes
+   */
+  async stopWatch() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+    if (this.watcher) {
+      await this.watcher.close();
+      this.watcher = null;
+    }
+    await this.client.cleanup();
+  }
+  /**
+   * Set up Supabase Realtime subscriptions
+   */
+  async setupRealtimeSubscriptions() {
+    const projectId = this.config.projectId;
+    this.client.subscribeToTestRuns(projectId, (payload) => {
+      if (payload.eventType === "INSERT" || payload.eventType === "UPDATE") {
+        this.callbacks.onTestRunUpdate?.(payload.new);
+      }
+    });
+    this.client.subscribeToInsights(projectId, (payload) => {
+      if (payload.eventType === "INSERT") {
+        this.callbacks.onInsightCreated?.(payload.new);
+      }
+    });
+    this.client.subscribeToFlows(projectId, (payload) => {
+      if (payload.eventType === "UPDATE" && payload.new.affected_by_changes?.length > 0) {
+        const impactedFlow = {
+          name: payload.new.name,
+          confidence: 0.8,
+          riskScore: payload.new.risk_score,
+          priority: payload.new.priority
+        };
+        this.callbacks.onFlowsAffected?.([impactedFlow]);
+      }
+    });
+  }
+  /**
+   * Handle individual file change
+   */
+  handleFileChange(path, type) {
+    const change = {
+      path,
+      type,
+      timestamp: Date.now()
+    };
+    this.pendingChanges.set(path, change);
+    this.callbacks.onFileChange?.(change);
+  }
+  /**
+   * Process accumulated changes
+   */
+  async processChanges(projectRoot) {
+    if (this.isAnalyzing || this.pendingChanges.size === 0) {
+      return;
+    }
+    this.isAnalyzing = true;
+    const changes = Array.from(this.pendingChanges.values());
+    this.pendingChanges.clear();
+    try {
+      const headSha = await this.getCurrentHead(projectRoot);
+      const baseSha = `${headSha}~1`;
+      const changeId = `change-${Date.now()}`;
+      this.callbacks.onAnalysisStart?.(changeId);
+      const analysis = await computeChangeAnalysis(projectRoot, baseSha, headSha);
+      const codeChange = await this.client.createCodeChange({
+        project_id: this.config.projectId,
+        base_sha: baseSha,
+        head_sha: headSha,
+        files: analysis.files.map((f) => ({
+          path: f.path,
+          status: f.status
+        }))
+      });
+      const flows = await this.client.getFlows(this.config.projectId);
+      const affectedFlows = await this.matchAffectedFlows(flows, analysis.files);
+      const riskScore = this.calculateRiskScore(affectedFlows);
+      const riskLevel = this.getRiskLevel(riskScore);
+      await this.client.updateCodeChangeAnalysis(codeChange.id, {
+        risk_level: riskLevel,
+        risk_score: riskScore,
+        affected_flow_ids: affectedFlows.map((f) => f.id)
+      });
+      await this.client.markFlowsAffected(
+        affectedFlows.map((f) => f.id),
+        codeChange.id,
+        riskScore * 0.2
+      );
+      await this.client.publishFlowsAffected(
+        codeChange.id,
+        affectedFlows.map((f) => ({
+          id: f.id,
+          name: f.name,
+          riskScore: f.risk_score
+        })),
+        "observer"
+      );
+      const impactReport = {
+        changeId: codeChange.id,
+        baseSha,
+        headSha,
+        flows: affectedFlows.map((f) => ({
+          name: f.name,
+          confidence: 0.8,
+          // TODO: Use LLM for better confidence
+          riskScore: f.risk_score,
+          priority: f.priority
+        })),
+        changes: analysis.files,
+        createdAt: Date.now()
+      };
+      this.callbacks.onAnalysisComplete?.(impactReport);
+      this.callbacks.onFlowsAffected?.(impactReport.flows);
+    } catch (error) {
+      this.callbacks.onError?.(error instanceof Error ? error : new Error(String(error)));
+    } finally {
+      this.isAnalyzing = false;
+    }
+  }
+  /**
+   * Match flows affected by changed files
+   */
+  async matchAffectedFlows(flows, changedFiles) {
+    const affectedFlows = [];
+    for (const flow of flows) {
+      const isAffected = this.doesFlowMatchChanges(flow, changedFiles);
+      if (isAffected) {
+        affectedFlows.push(flow);
+      }
+    }
+    return affectedFlows;
+  }
+  /**
+   * Check if a flow is affected by changed files
+   */
+  doesFlowMatchChanges(flow, changedFiles) {
+    if (flow.entry_point) {
+      for (const file of changedFiles) {
+        if (this.pathMatchesPattern(file.path, flow.entry_point)) {
+          return true;
+        }
+      }
+    }
+    const graphData = flow.graph_data;
+    if (graphData) {
+      const patterns = [
+        ...graphData.components ?? [],
+        ...graphData.pages ?? [],
+        ...graphData.dependencies ?? []
+      ];
+      for (const pattern of patterns) {
+        for (const file of changedFiles) {
+          if (this.pathMatchesPattern(file.path, pattern)) {
+            return true;
+          }
+        }
+      }
+    }
+    const flowKeywords = flow.name.toLowerCase().split(/[\s-_]+/);
+    for (const file of changedFiles) {
+      const filePath = file.path.toLowerCase();
+      for (const keyword of flowKeywords) {
+        if (filePath.includes(keyword) && keyword.length > 3) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * Check if a file path matches a pattern
+   */
+  pathMatchesPattern(filePath, pattern) {
+    const normalizedPath = filePath.toLowerCase();
+    const normalizedPattern = pattern.toLowerCase();
+    if (normalizedPath.includes(normalizedPattern)) {
+      return true;
+    }
+    const fileName = filePath.split("/").pop()?.replace(/\.[^/.]+$/, "") ?? "";
+    if (fileName.toLowerCase() === normalizedPattern.replace(/\.[^/.]+$/, "").toLowerCase()) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Calculate aggregate risk score from affected flows
+   */
+  calculateRiskScore(flows) {
+    if (flows.length === 0) return 0;
+    const priorityWeights = {
+      critical: 1,
+      high: 0.75,
+      medium: 0.5,
+      low: 0.25
+    };
+    let totalWeight = 0;
+    let weightedScore = 0;
+    for (const flow of flows) {
+      const weight = priorityWeights[flow.priority ?? "medium"] ?? 0.5;
+      totalWeight += weight;
+      weightedScore += weight * (flow.risk_score + 0.3);
+    }
+    return Math.min(1, weightedScore / Math.max(totalWeight, 1));
+  }
+  /**
+   * Get risk level from score
+   */
+  getRiskLevel(score) {
+    if (score >= 0.8) return "critical";
+    if (score >= 0.6) return "high";
+    if (score >= 0.3) return "medium";
+    return "low";
+  }
+  /**
+   * Get current HEAD commit SHA
+   */
+  async getCurrentHead(projectRoot) {
+    const { execSync } = await import("child_process");
+    try {
+      return execSync("git rev-parse HEAD", { cwd: projectRoot, encoding: "utf-8" }).trim();
+    } catch {
+      return "HEAD";
+    }
+  }
+  // ==========================================================================
+  // Public API Methods
+  // ==========================================================================
+  /**
+   * Manually analyze changes between two commits
+   */
+  async analyzeChanges(projectRoot, baseSha, headSha) {
+    const analysis = await computeChangeAnalysis(projectRoot, baseSha, headSha);
+    const codeChange = await this.client.createCodeChange({
+      project_id: this.config.projectId,
+      base_sha: baseSha,
+      head_sha: headSha,
+      files: analysis.files.map((f) => ({
+        path: f.path,
+        status: f.status
+      }))
+    });
+    const flows = await this.client.getFlows(this.config.projectId);
+    const affectedFlows = await this.matchAffectedFlows(flows, analysis.files);
+    const riskScore = this.calculateRiskScore(affectedFlows);
+    await this.client.updateCodeChangeAnalysis(codeChange.id, {
+      risk_level: this.getRiskLevel(riskScore),
+      risk_score: riskScore,
+      affected_flow_ids: affectedFlows.map((f) => f.id)
+    });
+    await this.client.markFlowsAffected(
+      affectedFlows.map((f) => f.id),
+      codeChange.id,
+      riskScore * 0.2
+    );
+    await this.client.publishFlowsAffected(
+      codeChange.id,
+      affectedFlows.map((f) => ({
+        id: f.id,
+        name: f.name,
+        riskScore: f.risk_score
+      })),
+      "observer"
+    );
+    return {
+      changeId: codeChange.id,
+      baseSha,
+      headSha,
+      flows: affectedFlows.map((f) => ({
+        name: f.name,
+        confidence: 0.8,
+        riskScore: f.risk_score,
+        priority: f.priority
+      })),
+      changes: analysis.files,
+      createdAt: Date.now()
+    };
+  }
+  /**
+   * Get all flows for the project
+   */
+  async getFlows() {
+    return this.client.getFlows(this.config.projectId);
+  }
+  /**
+   * Get flows affected by recent changes
+   */
+  async getAffectedFlows() {
+    return this.client.getAffectedFlows(this.config.projectId);
+  }
+  /**
+   * Create or update flows (bootstrap)
+   */
+  async upsertFlows(flows) {
+    return this.client.upsertFlows(
+      flows.map((f) => ({
+        ...f,
+        project_id: this.config.projectId
+      }))
+    );
+  }
+  /**
+   * Clear affected status from flows (e.g., after tests pass)
+   */
+  async clearAffectedFlows(flowIds) {
+    await this.client.clearAffectedFlows(flowIds);
+  }
+  /**
+   * Get the data client for direct access
+   */
+  getDataClient() {
+    return this.client;
+  }
+};
 export {
   ObserverApiClient,
-  ObserverEngine
+  ObserverEngine,
+  SupabaseObserverEngine,
+  computeChangeAnalysis
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@perceo/observer-engine",
-  "version": "0.1.0",
+  "version": "2.0.1",
   "description": "Observer Engine core used by the Perceo CLI for flow/persona bootstrap and change impact analysis.",
   "keywords": [
     "perceo",
@@ -16,14 +16,19 @@
   "files": [
     "dist"
   ],
+  "dependencies": {
+    "@temporalio/client": "^1.11.5",
+    "chokidar": "^3.5.3",
+    "@perceo/supabase": "0.2.0"
+  },
   "devDependencies": {
     "@types/node": "^22.15.3",
     "tsup": "^8.0.1",
     "typescript": "5.9.2",
-    "@repo/typescript-config": "0.1.0"
+    "@repo/typescript-config": "0.3.0"
   },
   "peerDependencies": {
-    "@perceo/perceo": "0.x"
+    "@perceo/perceo": "0.3.1"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm --dts --clean",