claude-memory-layer 1.0.1 → 1.0.3

package/dist/core/index.js

@@ -133,7 +133,14 @@ var 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({
@@ -291,7 +298,8 @@ var EntryTypeSchema = z.enum([
   "task_note",
   "reference",
   "preference",
-  "pattern"
+  "pattern",
+  "troubleshooting"
 ]);
 var EntrySchema = z.object({
   entryId: z.string(),
@@ -488,6 +496,34 @@ var ContinuityLogSchema = z.object({
   transitionType: TransitionTypeSchema,
   createdAt: z.date()
 });
+var SharedEntryTypeSchema = z.enum([
+  "troubleshooting",
+  "best_practice",
+  "common_error"
+]);
+var 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()
+});
+var 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")
+});
 
 // src/core/canonical-key.ts
 import { createHash } from "crypto";
@@ -3129,11 +3165,22 @@ var Retriever = class {
   vectorStore;
   embedder;
   matcher;
-  constructor(eventStore, vectorStore, embedder, matcher) {
+  sharedStore;
+  sharedVectorStore;
+  constructor(eventStore, vectorStore, embedder, matcher, sharedOptions) {
     this.eventStore = eventStore;
     this.vectorStore = vectorStore;
     this.embedder = embedder;
     this.matcher = matcher;
+    this.sharedStore = sharedOptions?.sharedStore;
+    this.sharedVectorStore = sharedOptions?.sharedVectorStore;
+  }
+  /**
+   * Set shared stores after construction
+   */
+  setSharedStores(sharedStore, sharedVectorStore) {
+    this.sharedStore = sharedStore;
+    this.sharedVectorStore = sharedVectorStore;
   }
   /**
    * Retrieve relevant memories for a query
@@ -3160,6 +3207,75 @@ var Retriever = class {
       context
     };
   }
+  /**
+   * Retrieve with unified search (project + shared)
+   */
+  async retrieveUnified(query, options = {}) {
+    const projectResult = await this.retrieve(query, options);
+    if (!options.includeShared || !this.sharedStore || !this.sharedVectorStore) {
+      return projectResult;
+    }
+    try {
+      const queryEmbedding = await this.embedder.embed(query);
+      const sharedVectorResults = await this.sharedVectorStore.search(
+        queryEmbedding.vector,
+        {
+          limit: options.topK || 5,
+          minScore: options.minScore || 0.7,
+          excludeProjectHash: options.projectHash
+        }
+      );
+      const sharedMemories = [];
+      for (const result of sharedVectorResults) {
+        const entry = await this.sharedStore.get(result.entryId);
+        if (entry) {
+          if (!options.projectHash || entry.sourceProjectHash !== options.projectHash) {
+            sharedMemories.push(entry);
+            await this.sharedStore.recordUsage(entry.entryId);
+          }
+        }
+      }
+      const unifiedContext = this.buildUnifiedContext(projectResult, sharedMemories);
+      return {
+        ...projectResult,
+        context: unifiedContext,
+        totalTokens: this.estimateTokens(unifiedContext),
+        sharedMemories
+      };
+    } catch (error) {
+      console.error("Shared search failed:", error);
+      return projectResult;
+    }
+  }
+  /**
+   * Build unified context combining project and shared memories
+   */
+  buildUnifiedContext(projectResult, sharedMemories) {
+    let context = projectResult.context;
+    if (sharedMemories.length > 0) {
+      context += "\n\n## Cross-Project Knowledge\n\n";
+      for (const memory of sharedMemories.slice(0, 3)) {
+        context += `### ${memory.title}
+`;
+        if (memory.symptoms.length > 0) {
+          context += `**Symptoms:** ${memory.symptoms.join(", ")}
+`;
+        }
+        context += `**Root Cause:** ${memory.rootCause}
+`;
+        context += `**Solution:** ${memory.solution}
+`;
+        if (memory.technologies && memory.technologies.length > 0) {
+          context += `**Technologies:** ${memory.technologies.join(", ")}
+`;
+        }
+        context += `_Confidence: ${(memory.confidence * 100).toFixed(0)}%_
+
+`;
+      }
+    }
+    return context;
+  }
   /**
    * Retrieve memories from a specific session
    */
@@ -4488,6 +4604,658 @@ var TaskProjector = class {
     return this.processAll();
   }
 };
+
+// src/core/shared-event-store.ts
+var SharedEventStore = class {
+  constructor(dbPath) {
+    this.dbPath = dbPath;
+    this.db = createDatabase(dbPath);
+  }
+  db;
+  initialized = false;
+  async initialize() {
+    if (this.initialized)
+      return;
+    await dbRun(this.db, `
+      CREATE TABLE IF NOT EXISTS shared_troubleshooting (
+        entry_id VARCHAR PRIMARY KEY,
+        source_project_hash VARCHAR NOT NULL,
+        source_entry_id VARCHAR NOT NULL,
+        title VARCHAR NOT NULL,
+        symptoms JSON NOT NULL,
+        root_cause TEXT NOT NULL,
+        solution TEXT NOT NULL,
+        topics JSON NOT NULL,
+        technologies JSON,
+        confidence REAL NOT NULL DEFAULT 0.8,
+        usage_count INTEGER DEFAULT 0,
+        last_used_at TIMESTAMP,
+        promoted_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        UNIQUE(source_project_hash, source_entry_id)
+      )
+    `);
+    await dbRun(this.db, `
+      CREATE TABLE IF NOT EXISTS shared_best_practices (
+        entry_id VARCHAR PRIMARY KEY,
+        source_project_hash VARCHAR NOT NULL,
+        source_entry_id VARCHAR NOT NULL,
+        title VARCHAR NOT NULL,
+        content_json JSON NOT NULL,
+        topics JSON NOT NULL,
+        confidence REAL NOT NULL DEFAULT 0.8,
+        usage_count INTEGER DEFAULT 0,
+        promoted_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        UNIQUE(source_project_hash, source_entry_id)
+      )
+    `);
+    await dbRun(this.db, `
+      CREATE TABLE IF NOT EXISTS shared_common_errors (
+        entry_id VARCHAR PRIMARY KEY,
+        source_project_hash VARCHAR NOT NULL,
+        source_entry_id VARCHAR NOT NULL,
+        title VARCHAR NOT NULL,
+        error_pattern TEXT NOT NULL,
+        solution TEXT NOT NULL,
+        topics JSON NOT NULL,
+        technologies JSON,
+        confidence REAL NOT NULL DEFAULT 0.8,
+        usage_count INTEGER DEFAULT 0,
+        promoted_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        UNIQUE(source_project_hash, source_entry_id)
+      )
+    `);
+    await dbRun(this.db, `
+      CREATE INDEX IF NOT EXISTS idx_shared_ts_confidence
+      ON shared_troubleshooting(confidence DESC)
+    `);
+    await dbRun(this.db, `
+      CREATE INDEX IF NOT EXISTS idx_shared_ts_usage
+      ON shared_troubleshooting(usage_count DESC)
+    `);
+    await dbRun(this.db, `
+      CREATE INDEX IF NOT EXISTS idx_shared_ts_source
+      ON shared_troubleshooting(source_project_hash)
+    `);
+    this.initialized = true;
+  }
+  getDatabase() {
+    return this.db;
+  }
+  isInitialized() {
+    return this.initialized;
+  }
+  async close() {
+    await dbClose(this.db);
+    this.initialized = false;
+  }
+};
+function createSharedEventStore(dbPath) {
+  return new SharedEventStore(dbPath);
+}
+
+// src/core/shared-store.ts
+import { randomUUID as randomUUID8 } from "crypto";
+var SharedStore = class {
+  constructor(sharedEventStore) {
+    this.sharedEventStore = sharedEventStore;
+  }
+  get db() {
+    return this.sharedEventStore.getDatabase();
+  }
+  /**
+   * Promote a verified troubleshooting entry to shared storage
+   */
+  async promoteEntry(input) {
+    const entryId = randomUUID8();
+    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, options) {
+    const topK = options?.topK || 5;
+    const minConfidence = options?.minConfidence || 0.5;
+    const searchPattern = `%${query}%`;
+    const rows = await dbAll(
+      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, options) {
+    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 = [...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(this.db, query, params);
+    return rows.map(this.rowToEntry);
+  }
+  /**
+   * Record usage of a shared entry (for ranking)
+   */
+  async recordUsage(entryId) {
+    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) {
+    const rows = await dbAll(
+      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, sourceEntryId) {
+    const rows = await dbAll(
+      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, sourceEntryId) {
+    const result = await dbAll(
+      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) {
+    const limit = options?.limit || 100;
+    const rows = await dbAll(
+      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() {
+    const result = await dbAll(
+      this.db,
+      `SELECT COUNT(*) as count FROM shared_troubleshooting`
+    );
+    return result[0]?.count || 0;
+  }
+  /**
+   * Get statistics
+   */
+  async getStats() {
+    const countResult = await dbAll(
+      this.db,
+      `SELECT COUNT(*) as count FROM shared_troubleshooting`
+    );
+    const total = countResult[0]?.count || 0;
+    const avgResult = await dbAll(
+      this.db,
+      `SELECT AVG(confidence) as avg FROM shared_troubleshooting`
+    );
+    const averageConfidence = avgResult[0]?.avg || 0;
+    const usageResult = await dbAll(
+      this.db,
+      `SELECT SUM(usage_count) as total FROM shared_troubleshooting`
+    );
+    const totalUsageCount = usageResult[0]?.total || 0;
+    const entries = await this.getAll({ limit: 1e3 });
+    const topicCounts = {};
+    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) {
+    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;
+  }
+  rowToEntry(row) {
+    return {
+      entryId: row.entry_id,
+      sourceProjectHash: row.source_project_hash,
+      sourceEntryId: row.source_entry_id,
+      title: row.title,
+      symptoms: JSON.parse(row.symptoms || "[]"),
+      rootCause: row.root_cause,
+      solution: row.solution,
+      topics: JSON.parse(row.topics || "[]"),
+      technologies: JSON.parse(row.technologies || "[]"),
+      confidence: row.confidence,
+      usageCount: row.usage_count || 0,
+      lastUsedAt: row.last_used_at ? toDate(row.last_used_at) : void 0,
+      promotedAt: toDate(row.promoted_at),
+      createdAt: toDate(row.created_at)
+    };
+  }
+};
+function createSharedStore(sharedEventStore) {
+  return new SharedStore(sharedEventStore);
+}
+
+// src/core/shared-vector-store.ts
+import * as lancedb2 from "@lancedb/lancedb";
+var SharedVectorStore = class {
+  constructor(dbPath) {
+    this.dbPath = dbPath;
+  }
+  db = null;
+  table = null;
+  tableName = "shared_knowledge";
+  /**
+   * Initialize LanceDB connection
+   */
+  async initialize() {
+    if (this.db)
+      return;
+    this.db = await lancedb2.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) {
+    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 {
+      try {
+        await this.table.delete(`entryId = '${record.entryId}'`);
+      } catch {
+      }
+      await this.table.add([data]);
+    }
+  }
+  /**
+   * Add multiple records in batch
+   */
+  async upsertBatch(records) {
+    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, options = {}) {
+    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);
+    const filters = [];
+    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,
+        entryId: r.entryId,
+        content: r.content,
+        score,
+        entryType: r.entryType
+      };
+    });
+  }
+  /**
+   * Delete vector by entry ID
+   */
+  async delete(entryId) {
+    if (!this.table)
+      return;
+    await this.table.delete(`entryId = '${entryId}'`);
+  }
+  /**
+   * Get total count
+   */
+  async count() {
+    if (!this.table)
+      return 0;
+    return this.table.countRows();
+  }
+  /**
+   * Check if vector exists for entry
+   */
+  async exists(entryId) {
+    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;
+    }
+  }
+};
+function createSharedVectorStore(dbPath) {
+  return new SharedVectorStore(dbPath);
+}
+
+// src/core/shared-promoter.ts
+import { randomUUID as randomUUID9 } from "crypto";
+var SharedPromoter = class {
+  constructor(sharedStore, sharedVectorStore, embedder, config) {
+    this.sharedStore = sharedStore;
+    this.sharedVectorStore = sharedVectorStore;
+    this.embedder = embedder;
+    this.config = config;
+  }
+  /**
+   * Check if an entry is eligible for promotion
+   */
+  isEligibleForPromotion(entry) {
+    if (entry.entryType !== "troubleshooting") {
+      return false;
+    }
+    if (entry.stage !== "verified" && entry.stage !== "certified") {
+      return false;
+    }
+    if (entry.status !== "active") {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Promote a verified troubleshooting entry to shared storage
+   */
+  async promoteEntry(entry, projectHash) {
+    if (!this.isEligibleForPromotion(entry)) {
+      return {
+        success: false,
+        skipped: true,
+        skipReason: `Entry not eligible: type=${entry.entryType}, stage=${entry.stage}, status=${entry.status}`
+      };
+    }
+    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;
+      const confidence = this.calculateConfidence(entry);
+      const minConfidence = this.config?.minConfidenceForPromotion ?? 0.8;
+      if (confidence < minConfidence) {
+        return {
+          success: false,
+          skipped: true,
+          skipReason: `Confidence ${confidence} below threshold ${minConfidence}`
+        };
+      }
+      const input = {
+        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
+      };
+      const entryId = await this.sharedStore.promoteEntry(input);
+      const embeddingContent = this.createEmbeddingContent(input);
+      const embedding = await this.embedder.embed(embeddingContent);
+      await this.sharedVectorStore.upsert({
+        id: randomUUID9(),
+        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, projectHash) {
+    const results = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      const result = await this.promoteEntry(entry, projectHash);
+      results.set(entry.entryId, result);
+    }
+    return results;
+  }
+  /**
+   * Extract topics from entry
+   */
+  extractTopics(entry) {
+    const topics = [];
+    const titleWords = entry.title.toLowerCase().split(/[\s\-_]+/).filter((w) => w.length > 3 && !this.isStopWord(w));
+    topics.push(...titleWords);
+    const content = entry.contentJson;
+    if (content.topics && Array.isArray(content.topics)) {
+      topics.push(...content.topics.map((t) => String(t).toLowerCase()));
+    }
+    if (content.technologies && Array.isArray(content.technologies)) {
+      topics.push(...content.technologies.map((t) => String(t).toLowerCase()));
+    }
+    return [...new Set(topics)];
+  }
+  /**
+   * Check if word is a stop word
+   */
+  isStopWord(word) {
+    const stopWords = /* @__PURE__ */ 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
+   */
+  calculateConfidence(entry) {
+    let confidence = 0.8;
+    if (entry.stage === "certified") {
+      confidence = 0.95;
+    }
+    return Math.min(confidence, 1);
+  }
+  /**
+   * Create embedding content from input
+   */
+  createEmbeddingContent(input) {
+    const parts = [];
+    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");
+  }
+};
+function createSharedPromoter(sharedStore, sharedVectorStore, embedder, config) {
+  return new SharedPromoter(sharedStore, sharedVectorStore, embedder, config);
+}
 export {
   AlignedEvidenceSchema,
   BlockerKindSchema,
@@ -4545,6 +5313,13 @@ export {
   Retriever,
   SearchIndexItemSchema,
   SessionSchema,
+  SharedEntryTypeSchema,
+  SharedEventStore,
+  SharedPromoter,
+  SharedStore,
+  SharedStoreConfigSchema,
+  SharedTroubleshootingEntrySchema,
+  SharedVectorStore,
   TaskBlockersSetPayloadSchema,
   TaskCreatedPayloadSchema,
   TaskCurrentJsonSchema,
@@ -4567,6 +5342,10 @@ export {
   WorkingSetItemSchema,
   createGraduationPipeline,
   createRetriever,
+  createSharedEventStore,
+  createSharedPromoter,
+  createSharedStore,
+  createSharedVectorStore,
   createVectorWorker,
   createVectorWorkerV2,
   getDefaultAligner,