claude-memory-layer 1.0.31 → 1.0.33

package/src/core/task/task-projector.ts

@@ -1,358 +0,0 @@
-/**
- * Task Projector - Project task events to entities/edges
- * AXIOMMIND: Incremental processing with offset tracking
- */
-
-import { dbRun, dbAll, toDate, type Database } from '../db-wrapper.js';
-import { randomUUID } from 'crypto';
-import type { BlockerMode, BlockerRef } from '../types.js';
-
-const PROJECTOR_NAME = 'task_projector';
-const TASK_EVENT_TYPES = [
-  'task_created',
-  'task_status_changed',
-  'task_priority_changed',
-  'task_blockers_set',
-  'task_transition_rejected',
-  'condition_resolved_to'
-];
-
-interface ProjectionOffset {
-  lastEventId: string | null;
-  lastTimestamp: Date | null;
-}
-
-interface TaskEvent {
-  id: string;
-  eventType: string;
-  sessionId: string;
-  timestamp: Date;
-  content: Record<string, unknown>;
-}
-
-export class TaskProjector {
-  constructor(private db: Database) {}
-
-  /**
-   * Get current projection offset
-   */
-  async getOffset(): Promise<ProjectionOffset> {
-    const rows = await dbAll<Record<string, unknown>>(
-      this.db,
-      `SELECT last_event_id, last_timestamp
-       FROM projection_offsets
-       WHERE projection_name = ?`,
-      [PROJECTOR_NAME]
-    );
-
-    if (rows.length === 0) {
-      return { lastEventId: null, lastTimestamp: null };
-    }
-
-    return {
-      lastEventId: rows[0].last_event_id as string | null,
-      lastTimestamp: rows[0].last_timestamp
-        ? new Date(rows[0].last_timestamp as string)
-        : null
-    };
-  }
-
-  /**
-   * Update projection offset
-   */
-  private async updateOffset(eventId: string, timestamp: Date): Promise<void> {
-    await dbRun(
-      this.db,
-      `INSERT INTO projection_offsets (projection_name, last_event_id, last_timestamp, updated_at)
-       VALUES (?, ?, ?, CURRENT_TIMESTAMP)
-       ON CONFLICT (projection_name) DO UPDATE SET
-         last_event_id = excluded.last_event_id,
-         last_timestamp = excluded.last_timestamp,
-         updated_at = CURRENT_TIMESTAMP`,
-      [PROJECTOR_NAME, eventId, timestamp.toISOString()]
-    );
-  }
-
-  /**
-   * Fetch events since last offset
-   */
-  async fetchEventsSince(
-    offset: ProjectionOffset,
-    limit: number = 100
-  ): Promise<TaskEvent[]> {
-    let query = `
-      SELECT id, event_type, session_id, timestamp, content
-      FROM events
-      WHERE event_type IN (${TASK_EVENT_TYPES.map(() => '?').join(', ')})
-    `;
-    const params: unknown[] = [...TASK_EVENT_TYPES];
-
-    if (offset.lastTimestamp && offset.lastEventId) {
-      query += ` AND (timestamp > ? OR (timestamp = ? AND id > ?))`;
-      params.push(
-        offset.lastTimestamp.toISOString(),
-        offset.lastTimestamp.toISOString(),
-        offset.lastEventId
-      );
-    }
-
-    query += ` ORDER BY timestamp ASC, id ASC LIMIT ?`;
-    params.push(limit);
-
-    const rows = await dbAll<Record<string, unknown>>(this.db, query, params);
-
-    return rows.map(row => ({
-      id: row.id as string,
-      eventType: row.event_type as string,
-      sessionId: row.session_id as string,
-      timestamp: toDate(row.timestamp),
-      content: typeof row.content === 'string'
-        ? JSON.parse(row.content)
-        : row.content as Record<string, unknown>
-    }));
-  }
-
-  /**
-   * Process a batch of events
-   */
-  async processBatch(batchSize: number = 100): Promise<number> {
-    const offset = await this.getOffset();
-    const events = await this.fetchEventsSince(offset, batchSize);
-
-    if (events.length === 0) {
-      return 0;
-    }
-
-    for (const event of events) {
-      await this.processEvent(event);
-      await this.updateOffset(event.id, event.timestamp);
-    }
-
-    return events.length;
-  }
-
-  /**
-   * Process all pending events
-   */
-  async processAll(): Promise<number> {
-    let totalProcessed = 0;
-    let processed: number;
-
-    do {
-      processed = await this.processBatch();
-      totalProcessed += processed;
-    } while (processed > 0);
-
-    return totalProcessed;
-  }
-
-  /**
-   * Process a single event
-   */
-  private async processEvent(event: TaskEvent): Promise<void> {
-    switch (event.eventType) {
-      case 'task_created':
-        // Entity already created by TaskResolver, just ensure vector outbox entry
-        await this.enqueueForVectorization(event.content.taskId as string, 'task_title');
-        break;
-
-      case 'task_status_changed':
-        await this.handleStatusChanged(event);
-        break;
-
-      case 'task_priority_changed':
-        // Priority change doesn't affect edges
-        break;
-
-      case 'task_blockers_set':
-        await this.handleBlockersSet(event);
-        break;
-
-      case 'condition_resolved_to':
-        await this.handleConditionResolved(event);
-        break;
-
-      case 'task_transition_rejected':
-        // Log event, no state change
-        break;
-    }
-  }
-
-  /**
-   * Handle task_status_changed event
-   */
-  private async handleStatusChanged(event: TaskEvent): Promise<void> {
-    const { taskId, toStatus } = event.content;
-
-    // If status changed to 'done', remove all blocked_by edges
-    if (toStatus === 'done') {
-      await dbRun(
-        this.db,
-        `DELETE FROM edges
-         WHERE src_id = ? AND rel_type IN ('blocked_by', 'blocked_by_suggested')`,
-        [taskId]
-      );
-
-      // Clear blockers cache in entity
-      await dbRun(
-        this.db,
-        `UPDATE entities
-         SET current_json = json_remove(json_remove(current_json, '$.blockers'), '$.blockerSuggestions'),
-             updated_at = CURRENT_TIMESTAMP
-         WHERE entity_id = ?`,
-        [taskId]
-      );
-    }
-  }
-
-  /**
-   * Handle task_blockers_set event
-   */
-  private async handleBlockersSet(event: TaskEvent): Promise<void> {
-    const { taskId, mode, blockers } = event.content as {
-      taskId: string;
-      mode: BlockerMode;
-      blockers: BlockerRef[];
-    };
-
-    if (mode === 'replace') {
-      // Delete existing blocked_by edges
-      await dbRun(
-        this.db,
-        `DELETE FROM edges WHERE src_id = ? AND rel_type = 'blocked_by'`,
-        [taskId]
-      );
-
-      // Create new edges
-      for (const blocker of blockers) {
-        await this.createBlockerEdge(taskId, blocker, 'blocked_by');
-      }
-
-      // Update entity cache
-      const blockerIds = blockers.map(b => b.entityId);
-      await dbRun(
-        this.db,
-        `UPDATE entities
-         SET current_json = json_set(current_json, '$.blockers', ?),
-             updated_at = CURRENT_TIMESTAMP
-         WHERE entity_id = ?`,
-        [JSON.stringify(blockerIds), taskId]
-      );
-
-    } else {
-      // mode === 'suggest'
-      // Delete existing suggested edges
-      await dbRun(
-        this.db,
-        `DELETE FROM edges WHERE src_id = ? AND rel_type = 'blocked_by_suggested'`,
-        [taskId]
-      );
-
-      // Create suggested edges
-      for (const blocker of blockers) {
-        await this.createBlockerEdge(taskId, blocker, 'blocked_by_suggested');
-      }
-
-      // Update entity cache (suggestions)
-      const suggestionIds = blockers.map(b => b.entityId);
-      await dbRun(
-        this.db,
-        `UPDATE entities
-         SET current_json = json_set(current_json, '$.blockerSuggestions', ?),
-             updated_at = CURRENT_TIMESTAMP
-         WHERE entity_id = ?`,
-        [JSON.stringify(suggestionIds), taskId]
-      );
-    }
-  }
-
-  /**
-   * Create blocker edge
-   */
-  private async createBlockerEdge(
-    taskId: string,
-    blocker: BlockerRef,
-    relType: 'blocked_by' | 'blocked_by_suggested'
-  ): Promise<void> {
-    const edgeId = randomUUID();
-
-    await dbRun(
-      this.db,
-      `INSERT INTO edges (edge_id, src_type, src_id, rel_type, dst_type, dst_id, meta_json, created_at)
-       VALUES (?, 'entity', ?, ?, 'entity', ?, ?, CURRENT_TIMESTAMP)
-       ON CONFLICT DO NOTHING`,
-      [
-        edgeId,
-        taskId,
-        relType,
-        blocker.entityId,
-        JSON.stringify({
-          kind: blocker.kind,
-          rawText: blocker.rawText,
-          confidence: blocker.confidence,
-          candidates: blocker.candidates
-        })
-      ]
-    );
-  }
-
-  /**
-   * Handle condition_resolved_to event
-   */
-  private async handleConditionResolved(event: TaskEvent): Promise<void> {
-    const { conditionId, resolvedTo } = event.content as {
-      conditionId: string;
-      resolvedTo: { kind: string; entityId: string };
-    };
-
-    // Update condition entity
-    await dbRun(
-      this.db,
-      `UPDATE entities
-       SET current_json = json_set(json_set(current_json, '$.resolved', true), '$.resolvedTo', ?),
-           updated_at = CURRENT_TIMESTAMP
-       WHERE entity_id = ?`,
-      [JSON.stringify(resolvedTo), conditionId]
-    );
-
-    // Edge already created by TaskResolver
-  }
-
-  /**
-   * Enqueue entity for vectorization
-   */
-  private async enqueueForVectorization(itemId: string, itemKind: string): Promise<void> {
-    const jobId = randomUUID();
-    const embeddingVersion = 'v1';  // Should come from config
-
-    await dbRun(
-      this.db,
-      `INSERT INTO vector_outbox (job_id, item_kind, item_id, embedding_version, status, retry_count)
-       VALUES (?, ?, ?, ?, 'pending', 0)
-       ON CONFLICT (item_kind, item_id, embedding_version) DO NOTHING`,
-      [jobId, itemKind, itemId, embeddingVersion]
-    );
-  }
-
-  /**
-   * Rebuild all projections from scratch
-   * WARNING: This clears all edges and rebuilds from events
-   */
-  async rebuild(): Promise<number> {
-    // Clear task-related edges
-    await dbRun(
-      this.db,
-      `DELETE FROM edges WHERE rel_type IN ('blocked_by', 'blocked_by_suggested', 'resolves_to')`
-    );
-
-    // Reset offset
-    await dbRun(
-      this.db,
-      `DELETE FROM projection_offsets WHERE projection_name = ?`,
-      [PROJECTOR_NAME]
-    );
-
-    // Process all events
-    return this.processAll();
-  }
-}