claude-memory-layer 1.0.31 → 1.0.33

package/src/core/shared-promoter.ts

@@ -1,249 +0,0 @@
-/**
- * SharedPromoter - Handles auto-promotion of verified troubleshooting entries
- * Promotes entries from project-local storage to cross-project shared storage
- */
-
-import { randomUUID } from 'crypto';
-import { SharedStore } from './shared-store.js';
-import { SharedVectorStore } from './shared-vector-store.js';
-import { Embedder } from './embedder.js';
-import type { Entry, SharedTroubleshootingInput, SharedStoreConfig } from './types.js';
-
-export interface TroubleshootingContent {
-  symptoms?: string[];
-  rootCause?: string;
-  solution?: string;
-  technologies?: string[];
-}
-
-export interface PromotionResult {
-  success: boolean;
-  entryId?: string;
-  error?: string;
-  skipped?: boolean;
-  skipReason?: string;
-}
-
-export class SharedPromoter {
-  constructor(
-    private sharedStore: SharedStore,
-    private sharedVectorStore: SharedVectorStore,
-    private embedder: Embedder,
-    private config?: SharedStoreConfig
-  ) {}
-
-  /**
-   * Check if an entry is eligible for promotion
-   */
-  isEligibleForPromotion(entry: Entry): boolean {
-    // Must be troubleshooting type
-    if (entry.entryType !== 'troubleshooting') {
-      return false;
-    }
-
-    // Must be at least 'verified' stage
-    if (entry.stage !== 'verified' && entry.stage !== 'certified') {
-      return false;
-    }
-
-    // Must be active status
-    if (entry.status !== 'active') {
-      return false;
-    }
-
-    return true;
-  }
-
-  /**
-   * Promote a verified troubleshooting entry to shared storage
-   */
-  async promoteEntry(
-    entry: Entry,
-    projectHash: string
-  ): Promise<PromotionResult> {
-    // Validate eligibility
-    if (!this.isEligibleForPromotion(entry)) {
-      return {
-        success: false,
-        skipped: true,
-        skipReason: `Entry not eligible: type=${entry.entryType}, stage=${entry.stage}, status=${entry.status}`
-      };
-    }
-
-    // Check if already promoted
-    const exists = await this.sharedStore.exists(projectHash, entry.entryId);
-    if (exists) {
-      return {
-        success: true,
-        skipped: true,
-        skipReason: 'Entry already exists in shared store'
-      };
-    }
-
-    try {
-      const content = entry.contentJson as TroubleshootingContent;
-      const confidence = this.calculateConfidence(entry);
-
-      // Check minimum confidence threshold
-      const minConfidence = this.config?.minConfidenceForPromotion ?? 0.8;
-      if (confidence < minConfidence) {
-        return {
-          success: false,
-          skipped: true,
-          skipReason: `Confidence ${confidence} below threshold ${minConfidence}`
-        };
-      }
-
-      const input: SharedTroubleshootingInput = {
-        sourceProjectHash: projectHash,
-        sourceEntryId: entry.entryId,
-        title: entry.title,
-        symptoms: content.symptoms || [],
-        rootCause: content.rootCause || '',
-        solution: content.solution || '',
-        topics: this.extractTopics(entry),
-        technologies: content.technologies || [],
-        confidence
-      };
-
-      // Promote to shared store
-      const entryId = await this.sharedStore.promoteEntry(input);
-
-      // Create embedding for vector search
-      const embeddingContent = this.createEmbeddingContent(input);
-      const embedding = await this.embedder.embed(embeddingContent);
-
-      await this.sharedVectorStore.upsert({
-        id: randomUUID(),
-        entryId,
-        entryType: 'troubleshooting',
-        content: embeddingContent,
-        vector: embedding.vector,
-        topics: input.topics,
-        sourceProjectHash: projectHash
-      });
-
-      return {
-        success: true,
-        entryId
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : String(error)
-      };
-    }
-  }
-
-  /**
-   * Batch promote multiple entries
-   */
-  async promoteEntries(
-    entries: Entry[],
-    projectHash: string
-  ): Promise<Map<string, PromotionResult>> {
-    const results = new Map<string, PromotionResult>();
-
-    for (const entry of entries) {
-      const result = await this.promoteEntry(entry, projectHash);
-      results.set(entry.entryId, result);
-    }
-
-    return results;
-  }
-
-  /**
-   * Extract topics from entry
-   */
-  private extractTopics(entry: Entry): string[] {
-    const topics: string[] = [];
-
-    // Extract from title (meaningful words)
-    const titleWords = entry.title
-      .toLowerCase()
-      .split(/[\s\-_]+/)
-      .filter(w => w.length > 3 && !this.isStopWord(w));
-    topics.push(...titleWords);
-
-    // Extract from content if available
-    const content = entry.contentJson as Record<string, unknown>;
-    if (content.topics && Array.isArray(content.topics)) {
-      topics.push(...content.topics.map(t => String(t).toLowerCase()));
-    }
-
-    // Extract technologies as topics
-    if (content.technologies && Array.isArray(content.technologies)) {
-      topics.push(...content.technologies.map(t => String(t).toLowerCase()));
-    }
-
-    // Dedupe and return
-    return [...new Set(topics)];
-  }
-
-  /**
-   * Check if word is a stop word
-   */
-  private isStopWord(word: string): boolean {
-    const stopWords = new Set([
-      'the', 'and', 'for', 'with', 'this', 'that', 'from', 'have', 'been',
-      'were', 'are', 'was', 'had', 'has', 'will', 'would', 'could', 'should',
-      'when', 'where', 'what', 'which', 'while', 'error', 'problem', 'issue'
-    ]);
-    return stopWords.has(word);
-  }
-
-  /**
-   * Calculate confidence score for entry
-   */
-  private calculateConfidence(entry: Entry): number {
-    let confidence = 0.8; // Base confidence for verified entries
-
-    // Boost if certified
-    if (entry.stage === 'certified') {
-      confidence = 0.95;
-    }
-
-    // Could add more factors:
-    // - Number of evidence items
-    // - Age of entry (older verified entries may be more reliable)
-    // - Usage count if tracked
-
-    return Math.min(confidence, 1.0);
-  }
-
-  /**
-   * Create embedding content from input
-   */
-  private createEmbeddingContent(input: SharedTroubleshootingInput): string {
-    const parts: string[] = [];
-
-    parts.push(`Problem: ${input.title}`);
-
-    if (input.symptoms.length > 0) {
-      parts.push(`Symptoms: ${input.symptoms.join(', ')}`);
-    }
-
-    if (input.rootCause) {
-      parts.push(`Root Cause: ${input.rootCause}`);
-    }
-
-    if (input.solution) {
-      parts.push(`Solution: ${input.solution}`);
-    }
-
-    if (input.technologies && input.technologies.length > 0) {
-      parts.push(`Technologies: ${input.technologies.join(', ')}`);
-    }
-
-    return parts.join('\n');
-  }
-}
-
-export function createSharedPromoter(
-  sharedStore: SharedStore,
-  sharedVectorStore: SharedVectorStore,
-  embedder: Embedder,
-  config?: SharedStoreConfig
-): SharedPromoter {
-  return new SharedPromoter(sharedStore, sharedVectorStore, embedder, config);
-}

package/src/core/shared-store.ts

@@ -1,289 +0,0 @@
-/**
- * SharedStore - Cross-project troubleshooting knowledge store
- * Manages promotion from verified entries to shared storage
- */
-
-import { randomUUID } from 'crypto';
-import { dbRun, dbAll, toDate, type Database } from './db-wrapper.js';
-import type {
-  SharedTroubleshootingEntry,
-  SharedTroubleshootingInput
-} from './types.js';
-import { SharedEventStore } from './shared-event-store.js';
-
-export class SharedStore {
-  constructor(private sharedEventStore: SharedEventStore) {}
-
-  private get db(): Database {
-    return this.sharedEventStore.getDatabase();
-  }
-
-  /**
-   * Promote a verified troubleshooting entry to shared storage
-   */
-  async promoteEntry(
-    input: SharedTroubleshootingInput
-  ): Promise<string> {
-    const entryId = randomUUID();
-
-    await dbRun(
-      this.db,
-      `INSERT INTO shared_troubleshooting (
-        entry_id, source_project_hash, source_entry_id,
-        title, symptoms, root_cause, solution, topics,
-        technologies, confidence, promoted_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
-      ON CONFLICT (source_project_hash, source_entry_id)
-      DO UPDATE SET
-        title = excluded.title,
-        symptoms = excluded.symptoms,
-        root_cause = excluded.root_cause,
-        solution = excluded.solution,
-        topics = excluded.topics,
-        technologies = excluded.technologies,
-        confidence = CASE
-          WHEN excluded.confidence > shared_troubleshooting.confidence
-          THEN excluded.confidence
-          ELSE shared_troubleshooting.confidence
-        END`,
-      [
-        entryId,
-        input.sourceProjectHash,
-        input.sourceEntryId,
-        input.title,
-        JSON.stringify(input.symptoms),
-        input.rootCause,
-        input.solution,
-        JSON.stringify(input.topics),
-        JSON.stringify(input.technologies || []),
-        input.confidence
-      ]
-    );
-
-    return entryId;
-  }
-
-  /**
-   * Search troubleshooting entries by text query
-   */
-  async search(
-    query: string,
-    options?: { topK?: number; minConfidence?: number }
-  ): Promise<SharedTroubleshootingEntry[]> {
-    const topK = options?.topK || 5;
-    const minConfidence = options?.minConfidence || 0.5;
-    const searchPattern = `%${query}%`;
-
-    const rows = await dbAll<Record<string, unknown>>(
-      this.db,
-      `SELECT * FROM shared_troubleshooting
-       WHERE (title LIKE ? OR root_cause LIKE ? OR solution LIKE ?)
-       AND confidence >= ?
-       ORDER BY confidence DESC, usage_count DESC
-       LIMIT ?`,
-      [searchPattern, searchPattern, searchPattern, minConfidence, topK]
-    );
-
-    return rows.map(this.rowToEntry);
-  }
-
-  /**
-   * Search by topics
-   */
-  async searchByTopics(
-    topics: string[],
-    options?: { topK?: number; excludeProjectHash?: string }
-  ): Promise<SharedTroubleshootingEntry[]> {
-    const topK = options?.topK || 5;
-
-    if (topics.length === 0) {
-      return [];
-    }
-
-    const topicConditions = topics.map(() => `topics LIKE ?`).join(' OR ');
-    const topicParams = topics.map(t => `%"${t}"%`);
-
-    let query = `SELECT * FROM shared_troubleshooting WHERE (${topicConditions})`;
-    const params: unknown[] = [...topicParams];
-
-    if (options?.excludeProjectHash) {
-      query += ` AND source_project_hash != ?`;
-      params.push(options.excludeProjectHash);
-    }
-
-    query += ` ORDER BY confidence DESC, usage_count DESC LIMIT ?`;
-    params.push(topK);
-
-    const rows = await dbAll<Record<string, unknown>>(this.db, query, params);
-    return rows.map(this.rowToEntry);
-  }
-
-  /**
-   * Record usage of a shared entry (for ranking)
-   */
-  async recordUsage(entryId: string): Promise<void> {
-    await dbRun(
-      this.db,
-      `UPDATE shared_troubleshooting
-       SET usage_count = usage_count + 1,
-           last_used_at = CURRENT_TIMESTAMP
-       WHERE entry_id = ?`,
-      [entryId]
-    );
-  }
-
-  /**
-   * Get entry by ID
-   */
-  async get(entryId: string): Promise<SharedTroubleshootingEntry | null> {
-    const rows = await dbAll<Record<string, unknown>>(
-      this.db,
-      `SELECT * FROM shared_troubleshooting WHERE entry_id = ?`,
-      [entryId]
-    );
-
-    if (rows.length === 0) return null;
-    return this.rowToEntry(rows[0]);
-  }
-
-  /**
-   * Get entry by source (project hash + entry ID)
-   */
-  async getBySource(
-    projectHash: string,
-    sourceEntryId: string
-  ): Promise<SharedTroubleshootingEntry | null> {
-    const rows = await dbAll<Record<string, unknown>>(
-      this.db,
-      `SELECT * FROM shared_troubleshooting
-       WHERE source_project_hash = ? AND source_entry_id = ?`,
-      [projectHash, sourceEntryId]
-    );
-
-    if (rows.length === 0) return null;
-    return this.rowToEntry(rows[0]);
-  }
-
-  /**
-   * Check if an entry already exists in shared store
-   */
-  async exists(projectHash: string, sourceEntryId: string): Promise<boolean> {
-    const result = await dbAll<{ count: number }>(
-      this.db,
-      `SELECT COUNT(*) as count FROM shared_troubleshooting
-       WHERE source_project_hash = ? AND source_entry_id = ?`,
-      [projectHash, sourceEntryId]
-    );
-    return (result[0]?.count || 0) > 0;
-  }
-
-  /**
-   * Get all entries (with limit for safety)
-   */
-  async getAll(options?: { limit?: number }): Promise<SharedTroubleshootingEntry[]> {
-    const limit = options?.limit || 100;
-    const rows = await dbAll<Record<string, unknown>>(
-      this.db,
-      `SELECT * FROM shared_troubleshooting
-       ORDER BY confidence DESC, usage_count DESC
-       LIMIT ?`,
-      [limit]
-    );
-
-    return rows.map(this.rowToEntry);
-  }
-
-  /**
-   * Get total count
-   */
-  async count(): Promise<number> {
-    const result = await dbAll<{ count: number }>(
-      this.db,
-      `SELECT COUNT(*) as count FROM shared_troubleshooting`
-    );
-    return result[0]?.count || 0;
-  }
-
-  /**
-   * Get statistics
-   */
-  async getStats(): Promise<{
-    total: number;
-    averageConfidence: number;
-    topTopics: Array<{ topic: string; count: number }>;
-    totalUsageCount: number;
-  }> {
-    const countResult = await dbAll<{ count: number }>(
-      this.db,
-      `SELECT COUNT(*) as count FROM shared_troubleshooting`
-    );
-    const total = countResult[0]?.count || 0;
-
-    const avgResult = await dbAll<{ avg: number | null }>(
-      this.db,
-      `SELECT AVG(confidence) as avg FROM shared_troubleshooting`
-    );
-    const averageConfidence = avgResult[0]?.avg || 0;
-
-    const usageResult = await dbAll<{ total: number }>(
-      this.db,
-      `SELECT SUM(usage_count) as total FROM shared_troubleshooting`
-    );
-    const totalUsageCount = usageResult[0]?.total || 0;
-
-    // Get topic counts
-    const entries = await this.getAll({ limit: 1000 });
-    const topicCounts: Record<string, number> = {};
-    for (const entry of entries) {
-      for (const topic of entry.topics) {
-        topicCounts[topic] = (topicCounts[topic] || 0) + 1;
-      }
-    }
-
-    const topTopics = Object.entries(topicCounts)
-      .map(([topic, count]) => ({ topic, count }))
-      .sort((a, b) => b.count - a.count)
-      .slice(0, 10);
-
-    return { total, averageConfidence, topTopics, totalUsageCount };
-  }
-
-  /**
-   * Delete an entry
-   */
-  async delete(entryId: string): Promise<boolean> {
-    const before = await this.count();
-    await dbRun(
-      this.db,
-      `DELETE FROM shared_troubleshooting WHERE entry_id = ?`,
-      [entryId]
-    );
-    const after = await this.count();
-    return before > after;
-  }
-
-  private rowToEntry(row: Record<string, unknown>): SharedTroubleshootingEntry {
-    return {
-      entryId: row.entry_id as string,
-      sourceProjectHash: row.source_project_hash as string,
-      sourceEntryId: row.source_entry_id as string,
-      title: row.title as string,
-      symptoms: JSON.parse(row.symptoms as string || '[]'),
-      rootCause: row.root_cause as string,
-      solution: row.solution as string,
-      topics: JSON.parse(row.topics as string || '[]'),
-      technologies: JSON.parse(row.technologies as string || '[]'),
-      confidence: row.confidence as number,
-      usageCount: row.usage_count as number || 0,
-      lastUsedAt: row.last_used_at ? toDate(row.last_used_at) : undefined,
-      promotedAt: toDate(row.promoted_at),
-      createdAt: toDate(row.created_at)
-    };
-  }
-}
-
-export function createSharedStore(
-  sharedEventStore: SharedEventStore
-): SharedStore {
-  return new SharedStore(sharedEventStore);
-}