agileflow 3.4.3 → 4.0.0-alpha.2

package/lib/correlation.js

@@ -1,277 +0,0 @@
-/**
- * AgileFlow CLI - Correlation ID Management
- *
- * Generates and propagates trace IDs and session IDs for event correlation.
- * Enables filtering and tracing events across complex workflows.
- */
-
-const crypto = require('crypto');
-const fs = require('fs');
-const path = require('path');
-
-// Global context for correlation IDs
-let currentContext = {
-  traceId: null,
-  sessionId: null,
-  spanId: null,
-  parentSpanId: null,
-};
-
-/**
- * Generate a unique trace ID (16 hex chars, like OpenTelemetry standard)
- * @returns {string} Unique trace ID
- */
-function generateTraceId() {
-  return crypto.randomBytes(8).toString('hex');
-}
-
-/**
- * Generate a span ID (8 hex chars)
- * @returns {string} Unique span ID
- */
-function generateSpanId() {
-  return crypto.randomBytes(4).toString('hex');
-}
-
-/**
- * Generate a session ID based on timestamp and random component
- * Format: session_YYYYMMDD_HHMMSS_XXXX
- * @returns {string} Session ID
- */
-function generateSessionId() {
-  const now = new Date();
-  const date = now.toISOString().slice(0, 10).replace(/-/g, '');
-  const time = now.toISOString().slice(11, 19).replace(/:/g, '');
-  const random = crypto.randomBytes(2).toString('hex');
-  return `session_${date}_${time}_${random}`;
-}
-
-/**
- * Get current correlation context
- * @returns {{ traceId: string | null, sessionId: string | null, spanId: string | null }}
- */
-function getContext() {
-  return { ...currentContext };
-}
-
-/**
- * Set correlation context
- * @param {Object} context
- * @param {string} [context.traceId] - Trace ID
- * @param {string} [context.sessionId] - Session ID
- * @param {string} [context.spanId] - Span ID
- * @param {string} [context.parentSpanId] - Parent span ID
- */
-function setContext(context) {
-  if (context.traceId !== undefined) currentContext.traceId = context.traceId;
-  if (context.sessionId !== undefined) currentContext.sessionId = context.sessionId;
-  if (context.spanId !== undefined) currentContext.spanId = context.spanId;
-  if (context.parentSpanId !== undefined) currentContext.parentSpanId = context.parentSpanId;
-}
-
-/**
- * Start a new trace (generates new trace_id)
- * @param {Object} [options]
- * @param {string} [options.sessionId] - Existing session ID to use
- * @returns {{ traceId: string, sessionId: string, spanId: string }}
- */
-function startTrace(options = {}) {
-  const traceId = generateTraceId();
-  const sessionId = options.sessionId || currentContext.sessionId || generateSessionId();
-  const spanId = generateSpanId();
-
-  setContext({
-    traceId,
-    sessionId,
-    spanId,
-    parentSpanId: null,
-  });
-
-  return { traceId, sessionId, spanId };
-}
-
-/**
- * Start a new span within current trace
- * @returns {{ traceId: string, sessionId: string, spanId: string, parentSpanId: string | null }}
- */
-function startSpan() {
-  const parentSpanId = currentContext.spanId;
-  const spanId = generateSpanId();
-
-  setContext({
-    spanId,
-    parentSpanId,
-  });
-
-  return {
-    traceId: currentContext.traceId,
-    sessionId: currentContext.sessionId,
-    spanId,
-    parentSpanId,
-  };
-}
-
-/**
- * Inject correlation IDs into an event object
- * @param {Object} event - Event to inject into
- * @returns {Object} Event with correlation IDs
- */
-function injectCorrelation(event) {
-  const ctx = getContext();
-  return {
-    ...event,
-    ...(ctx.traceId && { trace_id: ctx.traceId }),
-    ...(ctx.sessionId && { session_id: ctx.sessionId }),
-    ...(ctx.spanId && { span_id: ctx.spanId }),
-    ...(ctx.parentSpanId && { parent_span_id: ctx.parentSpanId }),
-  };
-}
-
-/**
- * Clear correlation context (for testing or new sessions)
- */
-function clearContext() {
-  currentContext = {
-    traceId: null,
-    sessionId: null,
-    spanId: null,
-    parentSpanId: null,
-  };
-}
-
-/**
- * Load session ID from session-state.json if available
- * @param {string} projectDir - Project directory
- * @returns {string | null} Session ID or null
- */
-function loadSessionId(projectDir) {
-  try {
-    const sessionStatePath = path.join(projectDir, 'docs', '09-agents', 'session-state.json');
-    if (fs.existsSync(sessionStatePath)) {
-      const data = JSON.parse(fs.readFileSync(sessionStatePath, 'utf8'));
-      return data.session_id || null;
-    }
-  } catch {
-    // Ignore errors
-  }
-  return null;
-}
-
-/**
- * Save session ID to session-state.json
- * @param {string} projectDir - Project directory
- * @param {string} sessionId - Session ID to save
- */
-function saveSessionId(projectDir, sessionId) {
-  try {
-    const sessionStatePath = path.join(projectDir, 'docs', '09-agents', 'session-state.json');
-    let data = {};
-
-    if (fs.existsSync(sessionStatePath)) {
-      data = JSON.parse(fs.readFileSync(sessionStatePath, 'utf8'));
-    }
-
-    data.session_id = sessionId;
-    data.updated_at = new Date().toISOString();
-
-    const dir = path.dirname(sessionStatePath);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-
-    fs.writeFileSync(sessionStatePath, JSON.stringify(data, null, 2) + '\n');
-  } catch {
-    // Ignore errors - session ID is not critical
-  }
-}
-
-/**
- * Initialize correlation context for a project
- * Loads existing session ID or creates new one
- * @param {string} projectDir - Project directory
- * @param {Object} [options]
- * @param {boolean} [options.newTrace=true] - Start new trace
- * @returns {{ traceId: string, sessionId: string }}
- */
-function initializeForProject(projectDir, options = {}) {
-  const { newTrace = true } = options;
-
-  // Load or create session ID
-  let sessionId = loadSessionId(projectDir);
-  if (!sessionId) {
-    sessionId = generateSessionId();
-    saveSessionId(projectDir, sessionId);
-  }
-
-  setContext({ sessionId });
-
-  if (newTrace) {
-    const trace = startTrace({ sessionId });
-    return { traceId: trace.traceId, sessionId };
-  }
-
-  return {
-    traceId: currentContext.traceId || generateTraceId(),
-    sessionId,
-  };
-}
-
-/**
- * Extract correlation IDs from an event
- * @param {Object} event - Event object
- * @returns {{ traceId: string | null, sessionId: string | null, spanId: string | null }}
- */
-function extractCorrelation(event) {
-  return {
-    traceId: event.trace_id || null,
-    sessionId: event.session_id || null,
-    spanId: event.span_id || null,
-  };
-}
-
-/**
- * Filter events by trace ID
- * @param {Array} events - Array of events
- * @param {string} traceId - Trace ID to filter by
- * @returns {Array} Filtered events
- */
-function filterByTraceId(events, traceId) {
-  return events.filter(e => e.trace_id === traceId);
-}
-
-/**
- * Filter events by session ID
- * @param {Array} events - Array of events
- * @param {string} sessionId - Session ID to filter by
- * @returns {Array} Filtered events
- */
-function filterBySessionId(events, sessionId) {
-  return events.filter(e => e.session_id === sessionId);
-}
-
-module.exports = {
-  // ID generation
-  generateTraceId,
-  generateSpanId,
-  generateSessionId,
-
-  // Context management
-  getContext,
-  setContext,
-  clearContext,
-  startTrace,
-  startSpan,
-
-  // Event injection/extraction
-  injectCorrelation,
-  extractCorrelation,
-
-  // Project integration
-  initializeForProject,
-  loadSessionId,
-  saveSessionId,
-
-  // Filtering
-  filterByTraceId,
-  filterBySessionId,
-};

package/lib/drivers/claude-driver.ts

@@ -1,312 +0,0 @@
-/**
- * Claude Code Driver
- *
- * Driver implementation for Claude Code CLI (Anthropic).
- * Translates Claude's native protocol to the unified IR format.
- */
-
-import {
-  Driver,
-  DriverConfig,
-  DriverStatus,
-  Capability,
-  CapabilityName,
-  CLICommand,
-  IREventHandler,
-  CLAUDE_CAPABILITIES,
-} from '../protocol/driver';
-import {
-  IREnvelope,
-  IRSource,
-  createIREnvelope,
-  IRTextDelta,
-  IRToolStart,
-  IRToolResult,
-  IRSession,
-  IRInit,
-  IRTask,
-  IRGit,
-  IRError,
-} from '../protocol/ir';
-
-// ============================================================================
-// Tool Name Mapping (Claude -> IR normalized names)
-// ============================================================================
-
-const CLAUDE_TOOL_MAPPING: Record<string, string> = {
-  Read: 'file_read',
-  Write: 'file_write',
-  Edit: 'file_edit',
-  Bash: 'shell_exec',
-  Glob: 'file_glob',
-  Grep: 'file_grep',
-  WebSearch: 'web_search',
-  WebFetch: 'web_fetch',
-  Task: 'agent_spawn',
-  TaskCreate: 'todo_create',
-  TaskUpdate: 'todo_update',
-  TaskList: 'todo_list',
-  TaskGet: 'todo_get',
-  AskUserQuestion: 'user_question',
-  EnterPlanMode: 'plan_mode_enter',
-  ExitPlanMode: 'plan_mode_exit',
-  Skill: 'skill_invoke',
-  NotebookEdit: 'notebook_edit',
-};
-
-/**
- * Normalize Claude tool name to IR format
- */
-function normalizeToolName(claudeName: string): string {
-  return CLAUDE_TOOL_MAPPING[claudeName] || claudeName.toLowerCase();
-}
-
-// ============================================================================
-// Claude Driver Implementation
-// ============================================================================
-
-export class ClaudeDriver implements Driver {
-  readonly id: IRSource = 'claude';
-  readonly name = 'Claude Code';
-
-  private _status: DriverStatus = {
-    state: 'stopped',
-    provider: 'claude',
-  };
-
-  private _capabilities: Capability[] = [...CLAUDE_CAPABILITIES];
-  private _eventHandlers: Set<IREventHandler> = new Set();
-  private _sessions: Map<string, { config: DriverConfig; seqCounter: number }> = new Map();
-
-  // -------------------------------------------------------------------------
-  // Getters
-  // -------------------------------------------------------------------------
-
-  get status(): DriverStatus {
-    return this._status;
-  }
-
-  // -------------------------------------------------------------------------
-  // Lifecycle
-  // -------------------------------------------------------------------------
-
-  async start(sessionId: string, config: DriverConfig): Promise<void> {
-    this._sessions.set(sessionId, { config, seqCounter: 0 });
-
-    this._status = {
-      state: 'ready',
-      provider: 'claude',
-      model: config.model || 'claude-3-opus',
-      contextMax: config.maxTokens || 200000,
-    };
-
-    // Emit init event
-    const initPayload: IRInit = {
-      provider: 'claude',
-      version: '1.0.0', // TODO: Get actual version from CLI
-      capabilities: this._capabilities.filter(c => c.available).map(c => c.name),
-      maxContext: config.maxTokens || 200000,
-    };
-
-    this._emit(createIREnvelope('init', sessionId, 'claude', initPayload));
-  }
-
-  async stop(sessionId: string): Promise<void> {
-    this._sessions.delete(sessionId);
-
-    if (this._sessions.size === 0) {
-      this._status = {
-        ...this._status,
-        state: 'stopped',
-      };
-    }
-  }
-
-  async isAvailable(): Promise<boolean> {
-    // Check if 'claude' command is available
-    // In a real implementation, this would use exec/spawn to check
-    return true; // Assume available for now
-  }
-
-  // -------------------------------------------------------------------------
-  // Capabilities
-  // -------------------------------------------------------------------------
-
-  capabilities(): Capability[] {
-    return this._capabilities;
-  }
-
-  hasCapability(name: CapabilityName): boolean {
-    const cap = this._capabilities.find(c => c.name === name);
-    return cap?.available ?? false;
-  }
-
-  // -------------------------------------------------------------------------
-  // Communication
-  // -------------------------------------------------------------------------
-
-  async send(sessionId: string, command: CLICommand): Promise<void> {
-    // Mark as busy
-    this._status = { ...this._status, state: 'busy' };
-
-    // This would normally send to the CLI process
-    // For now, just emit a session state change
-    const sessionPayload: IRSession = {
-      state: 'thinking',
-    };
-    this._emit(createIREnvelope('session', sessionId, 'claude', sessionPayload));
-  }
-
-  // -------------------------------------------------------------------------
-  // Message Translation (Claude -> IR)
-  // -------------------------------------------------------------------------
-
-  /**
-   * Translate a Claude-native message to IR format
-   * Called by the dashboard server when it receives messages from Claude
-   */
-  translateToIR(sessionId: string, claudeMessage: ClaudeNativeMessage): IREnvelope | null {
-    const session = this._sessions.get(sessionId);
-    if (!session) return null;
-
-    switch (claudeMessage.type) {
-      case 'text':
-        return createIREnvelope<IRTextDelta>('text_delta', sessionId, 'claude', {
-          text: claudeMessage.content,
-          done: claudeMessage.done ?? false,
-        });
-
-      case 'tool_use':
-        return createIREnvelope<IRToolStart>('tool_start', sessionId, 'claude', {
-          id: claudeMessage.id || `tool_${Date.now()}`,
-          name: normalizeToolName(claudeMessage.tool),
-          nativeName: claudeMessage.tool,
-          input: claudeMessage.input || {},
-        });
-
-      case 'tool_result':
-        return createIREnvelope<IRToolResult>('tool_result', sessionId, 'claude', {
-          id: claudeMessage.id || '',
-          ok: !claudeMessage.error,
-          output: claudeMessage.content,
-          error: claudeMessage.error,
-        });
-
-      case 'task':
-        return createIREnvelope<IRTask>('task', sessionId, 'claude', {
-          action: claudeMessage.action as 'create' | 'update' | 'delete' | 'list',
-          task: claudeMessage.task
-            ? {
-                ...claudeMessage.task,
-                status: claudeMessage.task.status as 'pending' | 'in_progress' | 'completed',
-              }
-            : undefined,
-          tasks: claudeMessage.tasks?.map((t: { id: string; subject: string; status: string }) => ({
-            ...t,
-            status: t.status as 'pending' | 'in_progress' | 'completed',
-          })),
-        });
-
-      case 'git_status':
-        return createIREnvelope<IRGit>('git', sessionId, 'claude', {
-          action: 'status',
-          branch: claudeMessage.branch,
-          staged: claudeMessage.staged,
-          unstaged: claudeMessage.unstaged,
-        });
-
-      case 'session_state':
-        return createIREnvelope<IRSession>('session', sessionId, 'claude', {
-          state: claudeMessage.state as 'connected' | 'thinking' | 'idle' | 'error',
-          message: claudeMessage.message,
-        });
-
-      case 'error':
-        return createIREnvelope<IRError>('error', sessionId, 'claude', {
-          code: claudeMessage.code || 'UNKNOWN',
-          message: claudeMessage.message,
-          details: claudeMessage.details,
-          recoverable: claudeMessage.recoverable ?? true,
-        });
-
-      default:
-        // Unknown message type, skip
-        return null;
-    }
-  }
-
-  /**
-   * Emit translated IR message to all handlers
-   */
-  emitIR(envelope: IREnvelope): void {
-    this._emit(envelope);
-  }
-
-  // -------------------------------------------------------------------------
-  // Events
-  // -------------------------------------------------------------------------
-
-  onEvent(handler: IREventHandler): void {
-    this._eventHandlers.add(handler);
-  }
-
-  offEvent(handler: IREventHandler): void {
-    this._eventHandlers.delete(handler);
-  }
-
-  private _emit(envelope: IREnvelope): void {
-    Array.from(this._eventHandlers).forEach(handler => {
-      try {
-        handler(envelope);
-      } catch (error) {
-        console.error('[ClaudeDriver] Event handler error:', error);
-      }
-    });
-  }
-}
-
-// ============================================================================
-// Claude Native Message Types
-// ============================================================================
-
-export interface ClaudeNativeMessage {
-  type: string;
-  id?: string;
-  content?: string;
-  done?: boolean;
-  tool?: string;
-  input?: Record<string, unknown>;
-  error?: string;
-  action?: string;
-  task?: {
-    id: string;
-    subject: string;
-    description?: string;
-    status: string;
-    activeForm?: string;
-  };
-  tasks?: Array<{
-    id: string;
-    subject: string;
-    status: string;
-  }>;
-  branch?: string;
-  staged?: Array<{ path: string; status: string }>;
-  unstaged?: Array<{ path: string; status: string }>;
-  state?: string;
-  message?: string;
-  code?: string;
-  details?: unknown;
-  recoverable?: boolean;
-}
-
-// ============================================================================
-// Factory Function
-// ============================================================================
-
-/**
- * Create a new Claude driver instance
- */
-export function createClaudeDriver(): ClaudeDriver {
-  return new ClaudeDriver();
-}