@sparkleideas/agentic-flow 2.0.2-alpha-patch.1

package/packages/agentic-jujutsu/typescript/hooks-integration.ts

@@ -0,0 +1,370 @@
+/**
+ * TypeScript integration for @sparkleideas/agentic-flow hooks system
+ *
+ * This module provides type-safe integration between agentic-jujutsu
+ * and the @sparkleideas/agentic-flow hooks system for Node.js and browser environments.
+ */
+
+import { JJWrapper, JJOperation, JJConfig } from './index';
+
+/**
+ * Hook context information
+ */
+export interface HookContext {
+    /** Unique identifier for the agent */
+    agentId: string;
+    /** Session identifier for grouping related operations */
+    sessionId: string;
+    /** Human-readable task description */
+    taskDescription: string;
+    /** Unix timestamp in seconds */
+    timestamp: number;
+    /** Optional metadata for additional context */
+    metadata?: Record<string, any>;
+}
+
+/**
+ * Types of hook events
+ */
+export enum HookEventType {
+    PreTask = 'PreTask',
+    PostEdit = 'PostEdit',
+    PostTask = 'PostTask',
+    ConflictDetected = 'ConflictDetected',
+    OperationLogged = 'OperationLogged',
+    SessionInit = 'SessionInit',
+    SessionEnd = 'SessionEnd',
+}
+
+/**
+ * Hook event data structure
+ */
+export interface JJHookEvent {
+    /** Type of hook event */
+    eventType: HookEventType;
+    /** Associated jj operation (if any) */
+    operation?: JJOperation;
+    /** Hook execution context */
+    context: HookContext;
+    /** Additional event metadata */
+    metadata?: Record<string, any>;
+}
+
+/**
+ * AgentDB episode data structure
+ */
+export interface AgentDBEpisode {
+    sessionId: string;
+    task: string;
+    agentId: string;
+    input?: string;
+    output?: string;
+    critique?: string;
+    success: boolean;
+    reward: number;
+    latencyMs?: number;
+    tokensUsed?: number;
+    operation?: JJOperation;
+    timestamp: number;
+}
+
+/**
+ * Integration layer for @sparkleideas/agentic-flow hooks
+ */
+export class JJHooksIntegration {
+    private wrapper: JJWrapper;
+    private sessionId: string;
+    private agentId: string;
+    private agentdbEnabled: boolean;
+    private currentSession?: HookContext;
+    private operationLog: JJOperation[] = [];
+
+    /**
+     * Create a new hooks integration instance
+     *
+     * @param wrapper - JJWrapper instance
+     * @param sessionId - Session identifier
+     * @param agentId - Agent identifier
+     * @param agentdbEnabled - Whether to sync with AgentDB
+     */
+    constructor(
+        wrapper: JJWrapper,
+        sessionId: string,
+        agentId: string,
+        agentdbEnabled: boolean = false
+    ) {
+        this.wrapper = wrapper;
+        this.sessionId = sessionId;
+        this.agentId = agentId;
+        this.agentdbEnabled = agentdbEnabled;
+    }
+
+    /**
+     * Execute pre-task hook
+     */
+    async onPreTask(description: string, metadata?: Record<string, any>): Promise<JJHookEvent> {
+        const context: HookContext = {
+            agentId: this.agentId,
+            sessionId: this.sessionId,
+            taskDescription: description,
+            timestamp: Math.floor(Date.now() / 1000),
+            metadata,
+        };
+
+        this.currentSession = context;
+
+        const event: JJHookEvent = {
+            eventType: HookEventType.PreTask,
+            context,
+            metadata: {
+                action: 'session_init',
+                description: `[pre-task] Agent: ${this.agentId} | Session: ${this.sessionId} | Task: ${description}`,
+            },
+        };
+
+        console.log(`[jj] 🚀 Pre-task: ${description}`);
+
+        // Sync to AgentDB if enabled
+        if (this.agentdbEnabled) {
+            await this.syncToAgentDB(event);
+        }
+
+        return event;
+    }
+
+    /**
+     * Execute post-edit hook
+     */
+    async onPostEdit(file: string, changeDescription?: string): Promise<JJOperation> {
+        const context: HookContext = {
+            agentId: this.agentId,
+            sessionId: this.sessionId,
+            taskDescription: changeDescription || `Edit ${file}`,
+            timestamp: Math.floor(Date.now() / 1000),
+        };
+
+        const description = `[post-edit] Agent: ${this.agentId} | File: ${file} | Session: ${this.sessionId}`;
+
+        // Create operation record
+        const operation: JJOperation = {
+            id: this.generateOperationId(),
+            operationType: 'Describe',
+            description,
+            timestamp: context.timestamp,
+            user: this.agentId,
+            args: [],
+            metadata: {
+                file,
+                sessionId: this.sessionId,
+                agentId: this.agentId,
+                hook: 'post-edit',
+            },
+        };
+
+        // Add to operation log
+        this.operationLog.push(operation);
+
+        console.log(`[jj] ✏️  Post-edit: ${file}`);
+
+        // Sync to AgentDB if enabled
+        if (this.agentdbEnabled) {
+            await this.syncOperationToAgentDB(operation);
+        }
+
+        return operation;
+    }
+
+    /**
+     * Execute post-task hook
+     */
+    async onPostTask(): Promise<JJOperation[]> {
+        if (!this.currentSession) {
+            throw new Error('No active session. Call onPreTask first.');
+        }
+
+        const operations = [...this.operationLog];
+
+        const context: HookContext = {
+            ...this.currentSession,
+            timestamp: Math.floor(Date.now() / 1000),
+        };
+
+        const event: JJHookEvent = {
+            eventType: HookEventType.PostTask,
+            context,
+            metadata: {
+                sessionId: this.sessionId,
+                agentId: this.agentId,
+                operationsCount: operations.length,
+            },
+        };
+
+        console.log(`[jj] ✅ Post-task: ${operations.length} operations logged`);
+
+        // Sync to AgentDB if enabled
+        if (this.agentdbEnabled) {
+            await this.syncToAgentDB(event);
+        }
+
+        // Clear session
+        this.currentSession = undefined;
+        this.operationLog = [];
+
+        return operations;
+    }
+
+    /**
+     * Handle conflict detection
+     */
+    async onConflictDetected(conflicts: string[]): Promise<JJHookEvent> {
+        if (!this.currentSession) {
+            throw new Error('No active session. Call onPreTask first.');
+        }
+
+        const event: JJHookEvent = {
+            eventType: HookEventType.ConflictDetected,
+            context: this.currentSession,
+            metadata: {
+                conflicts,
+                requiresResolution: true,
+            },
+        };
+
+        console.log(`[jj] ⚠️  Conflicts detected: ${conflicts.join(', ')}`);
+
+        // Sync to AgentDB for learning
+        if (this.agentdbEnabled) {
+            await this.syncToAgentDB(event);
+        }
+
+        return event;
+    }
+
+    /**
+     * Get operations for current session
+     */
+    getSessionOperations(): JJOperation[] {
+        return [...this.operationLog];
+    }
+
+    /**
+     * Sync event to AgentDB
+     */
+    private async syncToAgentDB(event: JJHookEvent): Promise<void> {
+        if (!this.agentdbEnabled) {
+            return;
+        }
+
+        const episode: AgentDBEpisode = {
+            sessionId: event.context.sessionId,
+            task: event.context.taskDescription,
+            agentId: event.context.agentId,
+            success: true,
+            reward: 1.0,
+            operation: event.operation,
+            timestamp: event.context.timestamp,
+        };
+
+        // TODO: Implement actual AgentDB sync via MCP
+        console.log('[jj-agentdb] Would sync event:', JSON.stringify(episode, null, 2));
+
+        // For now, could write to file or call MCP via subprocess
+        if (process.env.AGENTDB_SYNC_FILE) {
+            const fs = await import('fs');
+            fs.appendFileSync(
+                process.env.AGENTDB_SYNC_FILE,
+                JSON.stringify(episode) + '\n'
+            );
+        }
+    }
+
+    /**
+     * Sync operation to AgentDB
+     */
+    private async syncOperationToAgentDB(operation: JJOperation): Promise<void> {
+        if (!this.agentdbEnabled) {
+            return;
+        }
+
+        const episode: AgentDBEpisode = {
+            sessionId: this.sessionId,
+            task: operation.description,
+            agentId: this.agentId,
+            success: true,
+            reward: 1.0,
+            operation,
+            timestamp: operation.timestamp,
+        };
+
+        console.log('[jj-agentdb] Would sync operation:', operation.id);
+
+        // TODO: Implement actual AgentDB sync
+        if (process.env.AGENTDB_SYNC_FILE) {
+            const fs = await import('fs');
+            fs.appendFileSync(
+                process.env.AGENTDB_SYNC_FILE,
+                JSON.stringify(episode) + '\n'
+            );
+        }
+    }
+
+    /**
+     * Generate unique operation ID
+     */
+    private generateOperationId(): string {
+        return `op-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+
+    /**
+     * Check if AgentDB sync is enabled
+     */
+    isAgentDBEnabled(): boolean {
+        return this.agentdbEnabled;
+    }
+
+    /**
+     * Get current session context
+     */
+    getCurrentSession(): HookContext | undefined {
+        return this.currentSession;
+    }
+}
+
+/**
+ * Factory function to create hooks integration
+ */
+export async function createHooksIntegration(
+    config: JJConfig,
+    sessionId: string,
+    agentId: string,
+    agentdbEnabled: boolean = false
+): Promise<JJHooksIntegration> {
+    const wrapper = await JJWrapper.new(config);
+    return new JJHooksIntegration(wrapper, sessionId, agentId, agentdbEnabled);
+}
+
+/**
+ * Helper to execute a full task lifecycle with hooks
+ */
+export async function withHooks<T>(
+    integration: JJHooksIntegration,
+    taskDescription: string,
+    task: (integration: JJHooksIntegration) => Promise<T>
+): Promise<{ result: T; operations: JJOperation[] }> {
+    // Pre-task
+    await integration.onPreTask(taskDescription);
+
+    try {
+        // Execute task
+        const result = await task(integration);
+
+        // Post-task
+        const operations = await integration.onPostTask();
+
+        return { result, operations };
+    } catch (error) {
+        // Even on error, try to capture operations
+        const operations = await integration.onPostTask();
+        throw error;
+    }
+}