@sparkleideas/browser 3.0.0-alpha.18

package/src/infrastructure/hooks-integration.ts

@@ -0,0 +1,170 @@
+/**
+ * @sparkleideas/browser - Hooks Integration
+ * pre-browse and post-browse hooks for claude-flow
+ */
+
+import { getReasoningBank } from './reasoningbank-adapter.js';
+import type { BrowserTrajectory, ActionResult } from '../domain/types.js';
+
+// ============================================================================
+// Hook Handlers
+// ============================================================================
+
+export interface PreBrowseInput {
+  goal: string;
+  url?: string;
+  context?: string;
+}
+
+export interface PreBrowseResult {
+  recommendedSteps: Array<{
+    action: string;
+    selector?: string;
+    value?: string;
+  }>;
+  similarPatterns: number;
+  suggestedModel: 'haiku' | 'sonnet' | 'opus';
+  estimatedDuration: number;
+  warnings: string[];
+}
+
+export interface PostBrowseInput {
+  trajectoryId: string;
+  success: boolean;
+  verdict?: string;
+  duration: number;
+  stepsCompleted: number;
+  errors?: string[];
+}
+
+export interface PostBrowseResult {
+  patternStored: boolean;
+  patternId?: string;
+  learnedFrom: boolean;
+  statsUpdated: boolean;
+}
+
+// ============================================================================
+// Pre-Browse Hook
+// ============================================================================
+
+/**
+ * Pre-browse hook - called before starting browser automation
+ * Returns recommendations based on learned patterns
+ */
+export async function preBrowseHook(input: PreBrowseInput): Promise<PreBrowseResult> {
+  const reasoningBank = getReasoningBank();
+  const warnings: string[] = [];
+
+  // Find similar patterns
+  const similarPatterns = await reasoningBank.findSimilarPatterns(input.goal);
+
+  // Get recommended steps
+  const recommendedSteps = await reasoningBank.getRecommendedSteps(input.goal);
+
+  // Suggest model based on complexity
+  let suggestedModel: 'haiku' | 'sonnet' | 'opus' = 'sonnet';
+  if (recommendedSteps.length <= 3) {
+    suggestedModel = 'haiku';
+  } else if (recommendedSteps.length > 10 || input.goal.toLowerCase().includes('complex')) {
+    suggestedModel = 'opus';
+  }
+
+  // Estimate duration based on patterns
+  let estimatedDuration = 5000; // Default 5s
+  if (similarPatterns.length > 0) {
+    estimatedDuration = Math.round(
+      similarPatterns.reduce((sum, p) => sum + p.avgDuration * p.steps.length, 0) / similarPatterns.length
+    );
+  }
+
+  // Generate warnings
+  if (input.url && !input.url.startsWith('https://')) {
+    warnings.push('URL is not HTTPS - authentication data may be at risk');
+  }
+
+  if (input.goal.toLowerCase().includes('login') && !input.goal.toLowerCase().includes('test')) {
+    warnings.push('Login detected - consider using state-save/state-load for session persistence');
+  }
+
+  if (similarPatterns.length === 0) {
+    warnings.push('No similar patterns found - this is a new workflow');
+  }
+
+  return {
+    recommendedSteps,
+    similarPatterns: similarPatterns.length,
+    suggestedModel,
+    estimatedDuration,
+    warnings,
+  };
+}
+
+// ============================================================================
+// Post-Browse Hook
+// ============================================================================
+
+/**
+ * Post-browse hook - called after browser automation completes
+ * Stores patterns and records learning feedback
+ */
+export async function postBrowseHook(input: PostBrowseInput): Promise<PostBrowseResult> {
+  const reasoningBank = getReasoningBank();
+
+  // Record verdict for learning
+  await reasoningBank.recordVerdict(input.trajectoryId, input.success, input.verdict);
+
+  // If there were errors, analyze them
+  if (input.errors && input.errors.length > 0) {
+    console.log(`[post-browse] Errors to learn from: ${input.errors.join(', ')}`);
+  }
+
+  const stats = reasoningBank.getStats();
+
+  return {
+    patternStored: input.success,
+    patternId: input.success ? `pattern-${input.trajectoryId}` : undefined,
+    learnedFrom: true,
+    statsUpdated: true,
+  };
+}
+
+// ============================================================================
+// Hook Registration for CLI
+// ============================================================================
+
+export const browserHooks = {
+  'pre-browse': {
+    name: 'pre-browse',
+    description: 'Get recommendations before browser automation',
+    handler: preBrowseHook,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        goal: { type: 'string', description: 'What you want to accomplish' },
+        url: { type: 'string', description: 'Target URL (optional)' },
+        context: { type: 'string', description: 'Additional context' },
+      },
+      required: ['goal'],
+    },
+  },
+  'post-browse': {
+    name: 'post-browse',
+    description: 'Record browser automation outcome for learning',
+    handler: postBrowseHook,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        trajectoryId: { type: 'string', description: 'Trajectory ID from browser service' },
+        success: { type: 'boolean', description: 'Whether the automation succeeded' },
+        verdict: { type: 'string', description: 'Human feedback on quality' },
+        duration: { type: 'number', description: 'Total duration in ms' },
+        stepsCompleted: { type: 'number', description: 'Number of steps completed' },
+        errors: { type: 'array', items: { type: 'string' }, description: 'Error messages if any' },
+      },
+      required: ['trajectoryId', 'success', 'duration', 'stepsCompleted'],
+    },
+  },
+};
+
+export default browserHooks;

package/src/infrastructure/memory-integration.ts

@@ -0,0 +1,449 @@
+/**
+ * @sparkleideas/browser - Memory Integration
+ * Persistent memory storage with HNSW semantic search for browser patterns
+ */
+
+import type { BrowserTrajectory, BrowserTrajectoryStep, Snapshot, ActionResult } from '../domain/types.js';
+
+// ============================================================================
+// Memory Types
+// ============================================================================
+
+export interface BrowserMemoryEntry {
+  id: string;
+  type: 'trajectory' | 'pattern' | 'snapshot' | 'session' | 'error';
+  key: string;
+  value: Record<string, unknown>;
+  metadata: {
+    sessionId: string;
+    url?: string;
+    goal?: string;
+    success?: boolean;
+    duration?: number;
+    timestamp: string;
+    embedding?: number[];
+  };
+}
+
+export interface MemorySearchResult {
+  entry: BrowserMemoryEntry;
+  score: number;
+  distance: number;
+}
+
+export interface MemoryStats {
+  totalEntries: number;
+  byType: Record<string, number>;
+  bySession: Record<string, number>;
+  avgEmbeddingDim: number;
+  indexSize: number;
+}
+
+// ============================================================================
+// Memory Adapter Interface
+// ============================================================================
+
+export interface IMemoryAdapter {
+  store(entry: BrowserMemoryEntry): Promise<void>;
+  retrieve(key: string): Promise<BrowserMemoryEntry | null>;
+  search(query: string, options?: MemorySearchOptions): Promise<MemorySearchResult[]>;
+  delete(key: string): Promise<boolean>;
+  list(filter?: MemoryFilter): Promise<BrowserMemoryEntry[]>;
+  getStats(): Promise<MemoryStats>;
+}
+
+export interface MemorySearchOptions {
+  topK?: number;
+  minScore?: number;
+  type?: BrowserMemoryEntry['type'];
+  sessionId?: string;
+  namespace?: string;
+}
+
+export interface MemoryFilter {
+  type?: BrowserMemoryEntry['type'];
+  sessionId?: string;
+  startTime?: string;
+  endTime?: string;
+  success?: boolean;
+}
+
+// ============================================================================
+// Claude Flow Memory Adapter
+// ============================================================================
+
+/**
+ * Adapter for claude-flow memory system with HNSW indexing
+ */
+export class ClaudeFlowMemoryAdapter implements IMemoryAdapter {
+  private namespace: string;
+  private cache: Map<string, BrowserMemoryEntry> = new Map();
+  private embeddingCache: Map<string, number[]> = new Map();
+
+  constructor(namespace = 'browser') {
+    this.namespace = namespace;
+  }
+
+  /**
+   * Store a browser memory entry with optional embedding
+   */
+  async store(entry: BrowserMemoryEntry): Promise<void> {
+    const key = `${this.namespace}:${entry.type}:${entry.key}`;
+
+    // Generate text for embedding
+    const embeddingText = this.generateEmbeddingText(entry);
+
+    // Store in memory via MCP (when available)
+    try {
+      // This would call claude-flow memory_store MCP tool
+      // For now, store in local cache
+      this.cache.set(key, {
+        ...entry,
+        metadata: {
+          ...entry.metadata,
+          timestamp: entry.metadata.timestamp || new Date().toISOString(),
+        },
+      });
+
+      // Store embedding text for search
+      if (embeddingText) {
+        this.embeddingCache.set(key, this.simpleHash(embeddingText));
+      }
+    } catch (error) {
+      console.error('[memory] Failed to store entry:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Retrieve a specific memory entry
+   */
+  async retrieve(key: string): Promise<BrowserMemoryEntry | null> {
+    const fullKey = key.includes(':') ? key : `${this.namespace}:${key}`;
+    return this.cache.get(fullKey) || null;
+  }
+
+  /**
+   * Semantic search using HNSW index (falls back to keyword search)
+   */
+  async search(query: string, options: MemorySearchOptions = {}): Promise<MemorySearchResult[]> {
+    const { topK = 10, minScore = 0.3, type, sessionId } = options;
+
+    const results: MemorySearchResult[] = [];
+    const queryTerms = query.toLowerCase().split(/\s+/);
+
+    for (const [key, entry] of this.cache.entries()) {
+      // Apply filters
+      if (type && entry.type !== type) continue;
+      if (sessionId && entry.metadata.sessionId !== sessionId) continue;
+
+      // Calculate relevance score
+      const entryText = this.generateEmbeddingText(entry).toLowerCase();
+      let matches = 0;
+      for (const term of queryTerms) {
+        if (entryText.includes(term)) matches++;
+      }
+      const score = matches / queryTerms.length;
+
+      if (score >= minScore) {
+        results.push({
+          entry,
+          score,
+          distance: 1 - score,
+        });
+      }
+    }
+
+    // Sort by score and limit
+    return results
+      .sort((a, b) => b.score - a.score)
+      .slice(0, topK);
+  }
+
+  /**
+   * Delete a memory entry
+   */
+  async delete(key: string): Promise<boolean> {
+    const fullKey = key.includes(':') ? key : `${this.namespace}:${key}`;
+    const deleted = this.cache.delete(fullKey);
+    this.embeddingCache.delete(fullKey);
+    return deleted;
+  }
+
+  /**
+   * List entries with optional filters
+   */
+  async list(filter: MemoryFilter = {}): Promise<BrowserMemoryEntry[]> {
+    const entries: BrowserMemoryEntry[] = [];
+
+    for (const entry of this.cache.values()) {
+      if (filter.type && entry.type !== filter.type) continue;
+      if (filter.sessionId && entry.metadata.sessionId !== filter.sessionId) continue;
+      if (filter.success !== undefined && entry.metadata.success !== filter.success) continue;
+      if (filter.startTime && entry.metadata.timestamp < filter.startTime) continue;
+      if (filter.endTime && entry.metadata.timestamp > filter.endTime) continue;
+
+      entries.push(entry);
+    }
+
+    return entries;
+  }
+
+  /**
+   * Get memory statistics
+   */
+  async getStats(): Promise<MemoryStats> {
+    const byType: Record<string, number> = {};
+    const bySession: Record<string, number> = {};
+
+    for (const entry of this.cache.values()) {
+      byType[entry.type] = (byType[entry.type] || 0) + 1;
+      bySession[entry.metadata.sessionId] = (bySession[entry.metadata.sessionId] || 0) + 1;
+    }
+
+    return {
+      totalEntries: this.cache.size,
+      byType,
+      bySession,
+      avgEmbeddingDim: 0, // Would be calculated from actual embeddings
+      indexSize: this.embeddingCache.size,
+    };
+  }
+
+  /**
+   * Generate text for embedding from entry
+   */
+  private generateEmbeddingText(entry: BrowserMemoryEntry): string {
+    const parts: string[] = [];
+
+    if (entry.metadata.goal) parts.push(entry.metadata.goal);
+    if (entry.metadata.url) parts.push(entry.metadata.url);
+
+    if (entry.type === 'trajectory') {
+      const trajectory = entry.value as unknown as BrowserTrajectory;
+      parts.push(trajectory.goal);
+      trajectory.steps?.forEach((step) => {
+        parts.push(`${step.action} ${JSON.stringify(step.input)}`);
+      });
+    }
+
+    if (entry.type === 'error') {
+      parts.push(String(entry.value.message || ''));
+      parts.push(String(entry.value.stack || ''));
+    }
+
+    return parts.join(' ');
+  }
+
+  /**
+   * Simple hash for embedding placeholder (real implementation would use ONNX)
+   */
+  private simpleHash(text: string): number[] {
+    const hash: number[] = new Array(128).fill(0);
+    for (let i = 0; i < text.length; i++) {
+      hash[i % 128] += text.charCodeAt(i);
+    }
+    const max = Math.max(...hash);
+    return hash.map((v) => v / max);
+  }
+}
+
+// ============================================================================
+// Browser Memory Manager
+// ============================================================================
+
+/**
+ * High-level memory manager for browser automation
+ */
+export class BrowserMemoryManager {
+  private adapter: IMemoryAdapter;
+  private sessionId: string;
+
+  constructor(sessionId: string, adapter?: IMemoryAdapter) {
+    this.sessionId = sessionId;
+    this.adapter = adapter || new ClaudeFlowMemoryAdapter();
+  }
+
+  /**
+   * Store a completed trajectory
+   */
+  async storeTrajectory(trajectory: BrowserTrajectory): Promise<void> {
+    await this.adapter.store({
+      id: trajectory.id,
+      type: 'trajectory',
+      key: trajectory.id,
+      value: trajectory as unknown as Record<string, unknown>,
+      metadata: {
+        sessionId: this.sessionId,
+        url: trajectory.steps[0]?.input?.url as string,
+        goal: trajectory.goal,
+        success: trajectory.success,
+        duration: this.calculateDuration(trajectory),
+        timestamp: trajectory.completedAt || new Date().toISOString(),
+      },
+    });
+  }
+
+  /**
+   * Store a learned pattern
+   */
+  async storePattern(
+    patternId: string,
+    goal: string,
+    steps: Array<{ action: string; selector?: string; value?: string }>,
+    success: boolean
+  ): Promise<void> {
+    await this.adapter.store({
+      id: patternId,
+      type: 'pattern',
+      key: patternId,
+      value: { goal, steps, success },
+      metadata: {
+        sessionId: this.sessionId,
+        goal,
+        success,
+        timestamp: new Date().toISOString(),
+      },
+    });
+  }
+
+  /**
+   * Store a snapshot for later retrieval
+   */
+  async storeSnapshot(snapshotId: string, snapshot: Snapshot): Promise<void> {
+    await this.adapter.store({
+      id: snapshotId,
+      type: 'snapshot',
+      key: snapshotId,
+      value: snapshot as unknown as Record<string, unknown>,
+      metadata: {
+        sessionId: this.sessionId,
+        url: snapshot.url,
+        timestamp: snapshot.timestamp,
+      },
+    });
+  }
+
+  /**
+   * Store an error for learning
+   */
+  async storeError(
+    errorId: string,
+    error: Error,
+    context: { action?: string; selector?: string; url?: string }
+  ): Promise<void> {
+    await this.adapter.store({
+      id: errorId,
+      type: 'error',
+      key: errorId,
+      value: {
+        message: error.message,
+        stack: error.stack,
+        name: error.name,
+        ...context,
+      },
+      metadata: {
+        sessionId: this.sessionId,
+        url: context.url,
+        success: false,
+        timestamp: new Date().toISOString(),
+      },
+    });
+  }
+
+  /**
+   * Find similar trajectories for a given goal
+   */
+  async findSimilarTrajectories(goal: string, topK = 5): Promise<BrowserTrajectory[]> {
+    const results = await this.adapter.search(goal, {
+      topK,
+      type: 'trajectory',
+      minScore: 0.3,
+    });
+
+    return results.map((r) => r.entry.value as unknown as BrowserTrajectory);
+  }
+
+  /**
+   * Find patterns for a given goal
+   */
+  async findPatterns(goal: string, successfulOnly = true): Promise<MemorySearchResult[]> {
+    const results = await this.adapter.search(goal, {
+      topK: 10,
+      type: 'pattern',
+      minScore: 0.2,
+    });
+
+    if (successfulOnly) {
+      return results.filter((r) => r.entry.metadata.success === true);
+    }
+    return results;
+  }
+
+  /**
+   * Get session memory stats
+   */
+  async getSessionStats(): Promise<{
+    trajectories: number;
+    patterns: number;
+    snapshots: number;
+    errors: number;
+    successRate: number;
+  }> {
+    const entries = await this.adapter.list({ sessionId: this.sessionId });
+
+    let trajectories = 0;
+    let patterns = 0;
+    let snapshots = 0;
+    let errors = 0;
+    let successCount = 0;
+
+    for (const entry of entries) {
+      switch (entry.type) {
+        case 'trajectory':
+          trajectories++;
+          if (entry.metadata.success) successCount++;
+          break;
+        case 'pattern':
+          patterns++;
+          break;
+        case 'snapshot':
+          snapshots++;
+          break;
+        case 'error':
+          errors++;
+          break;
+      }
+    }
+
+    return {
+      trajectories,
+      patterns,
+      snapshots,
+      errors,
+      successRate: trajectories > 0 ? successCount / trajectories : 0,
+    };
+  }
+
+  private calculateDuration(trajectory: BrowserTrajectory): number {
+    if (!trajectory.startedAt || !trajectory.completedAt) return 0;
+    return new Date(trajectory.completedAt).getTime() - new Date(trajectory.startedAt).getTime();
+  }
+}
+
+// ============================================================================
+// Singleton Factory
+// ============================================================================
+
+let defaultAdapter: IMemoryAdapter | null = null;
+
+export function getMemoryAdapter(): IMemoryAdapter {
+  if (!defaultAdapter) {
+    defaultAdapter = new ClaudeFlowMemoryAdapter();
+  }
+  return defaultAdapter;
+}
+
+export function createMemoryManager(sessionId: string): BrowserMemoryManager {
+  return new BrowserMemoryManager(sessionId, getMemoryAdapter());
+}