claude-memory-layer 1.0.1 → 1.0.3

package/src/core/shared-store.ts

@@ -0,0 +1,289 @@
+/**
+ * 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);
+}

package/src/core/shared-vector-store.ts

@@ -0,0 +1,203 @@
+/**
+ * SharedVectorStore - Vector store for cross-project semantic search
+ * Location: ~/.claude-code/memory/shared/vectors/
+ */
+
+import * as lancedb from '@lancedb/lancedb';
+import type { SharedEntryType, SharedSearchResult } from './types.js';
+
+export interface SharedVectorRecord {
+  id: string;
+  entryId: string;
+  entryType: SharedEntryType;
+  content: string;
+  vector: number[];
+  topics: string[];
+  sourceProjectHash?: string;
+}
+
+export class SharedVectorStore {
+  private db: lancedb.Connection | null = null;
+  private table: lancedb.Table | null = null;
+  private readonly tableName = 'shared_knowledge';
+
+  constructor(private dbPath: string) {}
+
+  /**
+   * Initialize LanceDB connection
+   */
+  async initialize(): Promise<void> {
+    if (this.db) return;
+
+    this.db = await lancedb.connect(this.dbPath);
+
+    try {
+      const tables = await this.db.tableNames();
+      if (tables.includes(this.tableName)) {
+        this.table = await this.db.openTable(this.tableName);
+      }
+    } catch {
+      this.table = null;
+    }
+  }
+
+  /**
+   * Add or update a shared vector record
+   */
+  async upsert(record: SharedVectorRecord): Promise<void> {
+    await this.initialize();
+
+    if (!this.db) {
+      throw new Error('Database not initialized');
+    }
+
+    const data = {
+      id: record.id,
+      entryId: record.entryId,
+      entryType: record.entryType,
+      content: record.content,
+      vector: record.vector,
+      topics: JSON.stringify(record.topics),
+      sourceProjectHash: record.sourceProjectHash || ''
+    };
+
+    if (!this.table) {
+      this.table = await this.db.createTable(this.tableName, [data]);
+    } else {
+      // Delete existing entry before adding (upsert behavior)
+      try {
+        await this.table.delete(`entryId = '${record.entryId}'`);
+      } catch {
+        // Entry might not exist, ignore
+      }
+      await this.table.add([data]);
+    }
+  }
+
+  /**
+   * Add multiple records in batch
+   */
+  async upsertBatch(records: SharedVectorRecord[]): Promise<void> {
+    if (records.length === 0) return;
+
+    await this.initialize();
+
+    if (!this.db) {
+      throw new Error('Database not initialized');
+    }
+
+    const data = records.map(record => ({
+      id: record.id,
+      entryId: record.entryId,
+      entryType: record.entryType,
+      content: record.content,
+      vector: record.vector,
+      topics: JSON.stringify(record.topics),
+      sourceProjectHash: record.sourceProjectHash || ''
+    }));
+
+    if (!this.table) {
+      this.table = await this.db.createTable(this.tableName, data);
+    } else {
+      await this.table.add(data);
+    }
+  }
+
+  /**
+   * Search for similar vectors
+   */
+  async search(
+    queryVector: number[],
+    options: {
+      limit?: number;
+      minScore?: number;
+      excludeProjectHash?: string;
+      entryType?: SharedEntryType;
+    } = {}
+  ): Promise<SharedSearchResult[]> {
+    await this.initialize();
+
+    if (!this.table) {
+      return [];
+    }
+
+    const { limit = 5, minScore = 0.7, excludeProjectHash, entryType } = options;
+
+    let query = this.table
+      .search(queryVector)
+      .distanceType('cosine')
+      .limit(limit * 2);
+
+    // Apply filters
+    const filters: string[] = [];
+    if (excludeProjectHash) {
+      filters.push(`sourceProjectHash != '${excludeProjectHash}'`);
+    }
+    if (entryType) {
+      filters.push(`entryType = '${entryType}'`);
+    }
+
+    if (filters.length > 0) {
+      query = query.where(filters.join(' AND '));
+    }
+
+    const results = await query.toArray();
+
+    return results
+      .filter(r => {
+        const distance = r._distance || 0;
+        const score = 1 - (distance / 2);
+        return score >= minScore;
+      })
+      .slice(0, limit)
+      .map(r => {
+        const distance = r._distance || 0;
+        const score = 1 - (distance / 2);
+        return {
+          id: r.id as string,
+          entryId: r.entryId as string,
+          content: r.content as string,
+          score,
+          entryType: r.entryType as SharedEntryType
+        };
+      });
+  }
+
+  /**
+   * Delete vector by entry ID
+   */
+  async delete(entryId: string): Promise<void> {
+    if (!this.table) return;
+    await this.table.delete(`entryId = '${entryId}'`);
+  }
+
+  /**
+   * Get total count
+   */
+  async count(): Promise<number> {
+    if (!this.table) return 0;
+    return this.table.countRows();
+  }
+
+  /**
+   * Check if vector exists for entry
+   */
+  async exists(entryId: string): Promise<boolean> {
+    if (!this.table) return false;
+
+    try {
+      const results = await this.table
+        .search([])
+        .where(`entryId = '${entryId}'`)
+        .limit(1)
+        .toArray();
+      return results.length > 0;
+    } catch {
+      return false;
+    }
+  }
+}
+
+export function createSharedVectorStore(dbPath: string): SharedVectorStore {
+  return new SharedVectorStore(dbPath);
+}

package/src/core/types.ts

@@ -194,7 +194,14 @@ export const ConfigSchema = z.object({
     sessionSummary: z.boolean().default(true),
     insightExtraction: z.boolean().default(true),
     crossProjectLearning: z.boolean().default(false),
-    singleWriterMode: z.boolean().default(true)
+    singleWriterMode: z.boolean().default(true),
+    sharedStore: z.object({
+      enabled: z.boolean().default(true),
+      autoPromote: z.boolean().default(true),
+      searchShared: z.boolean().default(true),
+      minConfidenceForPromotion: z.number().default(0.8),
+      sharedStoragePath: z.string().default('~/.claude-code/memory/shared')
+    }).default({})
   }).default({}),
   mode: z.enum(['session', 'endless']).default('session'),
   endless: z.object({
@@ -499,7 +506,8 @@ export const EntryTypeSchema = z.enum([
   'task_note',
   'reference',
   'preference',
-  'pattern'
+  'pattern',
+  'troubleshooting'
 ]);
 export type EntryType = z.infer<typeof EntryTypeSchema>;
 
@@ -839,3 +847,62 @@ export interface EndlessModeStatus {
   consolidatedCount: number;
   lastConsolidation: Date | null;
 }
+
+// ============================================================
+// Shared Store Types (Cross-Project Knowledge)
+// ============================================================
+
+export const SharedEntryTypeSchema = z.enum([
+  'troubleshooting',
+  'best_practice',
+  'common_error'
+]);
+export type SharedEntryType = z.infer<typeof SharedEntryTypeSchema>;
+
+export const SharedTroubleshootingEntrySchema = z.object({
+  entryId: z.string(),
+  sourceProjectHash: z.string(),
+  sourceEntryId: z.string(),
+  title: z.string(),
+  symptoms: z.array(z.string()),
+  rootCause: z.string(),
+  solution: z.string(),
+  topics: z.array(z.string()),
+  technologies: z.array(z.string()).optional(),
+  confidence: z.number().min(0).max(1),
+  usageCount: z.number().default(0),
+  lastUsedAt: z.date().optional(),
+  promotedAt: z.date(),
+  createdAt: z.date()
+});
+export type SharedTroubleshootingEntry = z.infer<typeof SharedTroubleshootingEntrySchema>;
+
+export interface SharedTroubleshootingInput {
+  sourceProjectHash: string;
+  sourceEntryId: string;
+  title: string;
+  symptoms: string[];
+  rootCause: string;
+  solution: string;
+  topics: string[];
+  technologies?: string[];
+  confidence: number;
+}
+
+export const SharedStoreConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  autoPromote: z.boolean().default(true),
+  searchShared: z.boolean().default(true),
+  minConfidenceForPromotion: z.number().default(0.8),
+  sharedStoragePath: z.string().default('~/.claude-code/memory/shared')
+});
+export type SharedStoreConfig = z.infer<typeof SharedStoreConfigSchema>;
+
+// Shared search result
+export interface SharedSearchResult {
+  id: string;
+  entryId: string;
+  content: string;
+  score: number;
+  entryType: SharedEntryType;
+}

package/src/hooks/user-prompt-submit.ts

@@ -16,10 +16,14 @@ async function main(): Promise<void> {
   const memoryService = getMemoryServiceForSession(input.session_id);
 
   try {
-    // Retrieve relevant memories for the prompt
+    // Check if shared store is enabled
+    const includeShared = memoryService.isSharedStoreEnabled();
+
+    // Retrieve relevant memories for the prompt (including shared if enabled)
     const retrievalResult = await memoryService.retrieveMemories(input.prompt, {
       topK: 5,
-      minScore: 0.7
+      minScore: 0.7,
+      includeShared
     });
 
     // Store the user prompt for future retrieval