centient 2.20.0

package/dist/utils/SessionCoordinator.js

@@ -0,0 +1,1062 @@
+import { QdrantClient } from "@qdrant/js-client-rest";
+import { GoogleGenAI } from "@google/genai";
+import { readFile } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+import { embeddingCache, embeddingCacheKey, } from "./CacheManager.js";
+import { withExternalSpan } from "../telemetry/index.js";
+import { getCostTracker } from "./CostTracker.js";
+import { ServiceCircuitBreakers } from "./CircuitBreaker.js";
+import { ServiceRateLimiters } from "./RateLimiter.js";
+export class SessionCoordinator {
+    qdrant;
+    genai;
+    sessionId;
+    projectPath;
+    collectionName;
+    constructor(sessionId, projectPath) {
+        const qdrantUrl = process.env.QDRANT_URL;
+        const qdrantApiKey = process.env.QDRANT_API_KEY;
+        const geminiApiKey = process.env.GEMINI_API_KEY;
+        console.error("[SessionCoordinator] Environment check:", {
+            hasQdrantUrl: !!qdrantUrl,
+            hasQdrantApiKey: !!qdrantApiKey,
+            hasGeminiKey: !!geminiApiKey,
+            qdrantUrlLength: qdrantUrl?.length || 0,
+            allEnvKeys: Object.keys(process.env).filter((k) => k.includes("QDRANT") || k.includes("GEMINI")),
+        });
+        if (!qdrantUrl || !qdrantApiKey) {
+            throw new Error("Missing QDRANT_URL or QDRANT_API_KEY environment variables");
+        }
+        if (!geminiApiKey) {
+            throw new Error("Missing GEMINI_API_KEY environment variable");
+        }
+        this.sessionId = sessionId;
+        this.projectPath = projectPath;
+        const projectName = projectPath.split("/").pop() || "default";
+        this.collectionName = `session-${projectName}-${sessionId}`;
+        this.qdrant = new QdrantClient({
+            url: qdrantUrl,
+            apiKey: qdrantApiKey,
+        });
+        this.genai = new GoogleGenAI({ apiKey: geminiApiKey });
+    }
+    async withQdrantCircuitBreaker(operation) {
+        const rateLimiter = ServiceRateLimiters.qdrant();
+        await rateLimiter.acquire(1);
+        const qdrantBreaker = ServiceCircuitBreakers.qdrant();
+        return qdrantBreaker.execute(operation);
+    }
+    async initialize(seedTopic) {
+        const result = {};
+        try {
+            const collections = await this.withQdrantCircuitBreaker(() => this.qdrant.getCollections());
+            const exists = collections.collections.some((c) => c.name === this.collectionName);
+            if (exists) {
+                console.error(`📦 Session collection already exists: ${this.collectionName}`);
+                await this.ensurePayloadIndex();
+                if (seedTopic) {
+                    result.memoryBankSeeding = await this.seedFromMemoryBank(seedTopic);
+                }
+                return result;
+            }
+            await this.withQdrantCircuitBreaker(() => this.qdrant.createCollection(this.collectionName, {
+                vectors: {
+                    size: 3072,
+                    distance: "Cosine",
+                },
+            }));
+            console.error(`✅ Session collection created: ${this.collectionName}`);
+            await this.ensurePayloadIndex();
+            if (seedTopic) {
+                result.memoryBankSeeding = await this.seedFromMemoryBank(seedTopic);
+            }
+            await this.seedFromArchive();
+            return result;
+        }
+        catch (error) {
+            console.error(`❌ Failed to initialize session: ${error.message}`);
+            throw error;
+        }
+    }
+    async ensurePayloadIndex() {
+        try {
+            await this.qdrant.createPayloadIndex(this.collectionName, {
+                field_name: "type",
+                field_schema: "keyword",
+            });
+            console.error(`✅ Created payload index on 'type' field`);
+        }
+        catch (error) {
+            if (error.message?.includes("already exists")) {
+                console.error(`   Payload index already exists (OK)`);
+            }
+            else {
+                console.error(`⚠️  Failed to create payload index: ${error.message}`);
+            }
+        }
+    }
+    async seedFromMemoryBank(topic) {
+        console.error(`🧠 Seeding session from Memory Bank: "${topic}"...`);
+        try {
+            const projectName = this.projectPath.split("/").pop()?.toLowerCase() || "default";
+            const scriptPath = join(homedir(), "Dev/ClaudeDev/scripts/memory-bank/query-memories.py");
+            const { runPythonScriptJSON } = await import("./pythonRunner.js");
+            const result = await runPythonScriptJSON(scriptPath, [
+                "--query",
+                topic,
+                "--project-name",
+                projectName,
+                "--top-k",
+                "5",
+                "--format",
+                "json",
+            ]);
+            if (!result.success || !result.memories || result.memories.length === 0) {
+                console.error(`   ℹ️ No Memory Bank results for "${topic}" in project "${projectName}"`);
+                return { query: topic, count: 0 };
+            }
+            let seededCount = 0;
+            for (const memory of result.memories) {
+                try {
+                    await this.saveNote({
+                        type: "prior_knowledge",
+                        content: memory.fact,
+                        metadata: {
+                            source: "memory_bank",
+                            source_query: topic,
+                            memory_name: memory.name,
+                            similarity_distance: memory.distance,
+                        },
+                    });
+                    seededCount++;
+                }
+                catch (error) {
+                    console.error(`   ⚠️ Failed to save memory: ${error}`);
+                }
+            }
+            console.error(`   ✅ Seeded ${seededCount} memories from Memory Bank`);
+            return { query: topic, count: seededCount };
+        }
+        catch (error) {
+            console.error(`   ⚠️ Memory Bank seeding failed: ${error.message}`);
+            return { query: topic, count: 0 };
+        }
+    }
+    async seedFromArchive() {
+        console.error("🌱 Seeding session with past knowledge...");
+        try {
+            const geminiApiKey = process.env.GEMINI_API_KEY;
+            if (!geminiApiKey) {
+                console.error("   ⚠️ GEMINI_API_KEY not set - skipping archive seeding");
+                return;
+            }
+            const expandedPath = this.projectPath.replace(/^~/, homedir());
+            const configPath = join(expandedPath, ".gemini-config.json");
+            let config;
+            try {
+                const configContent = await readFile(configPath, "utf-8");
+                config = JSON.parse(configContent);
+            }
+            catch {
+                console.error("   ℹ️ No .gemini-config.json found - skipping archive seeding");
+                return;
+            }
+            if (!config.enabled) {
+                console.error("   ℹ️ Google File Search disabled in config - skipping archive seeding");
+                return;
+            }
+            const ai = new GoogleGenAI({ apiKey: geminiApiKey });
+            const storesResponse = await ai.fileSearchStores.list();
+            const stores = [];
+            for await (const store of storesResponse) {
+                stores.push(store);
+            }
+            const store = stores.find((s) => s.displayName === config.store_name);
+            if (!store) {
+                console.error(`   ℹ️ File Search store "${config.store_name}" not found - skipping archive seeding`);
+                return;
+            }
+            const projectName = this.projectPath.split("/").pop() || "project";
+            const query = `What are the key decisions, patterns, and learnings from recent sessions in ${projectName}? Focus on architectural decisions, design patterns used, and lessons learned.`;
+            console.error(`   🔍 Querying archive for relevant context...`);
+            const response = await ai.models.generateContent({
+                model: "gemini-2.5-flash",
+                contents: query,
+                config: {
+                    tools: [
+                        {
+                            fileSearch: {
+                                fileSearchStoreNames: [store.name],
+                            },
+                        },
+                    ],
+                },
+            });
+            const answer = response.text || "";
+            const groundingChunks = response.candidates?.[0]?.groundingMetadata?.groundingChunks || [];
+            if (!answer || answer.length < 50) {
+                console.error("   ℹ️ No relevant archive content found");
+                return;
+            }
+            const sessionIds = groundingChunks
+                .map((chunk) => {
+                const source = chunk.uri || "";
+                const match = source.match(/([^/]+?)(?:-compressed)?\.(?:json|md)$/);
+                return match
+                    ? match[1].replace(/-(?:finalization-pack|session-summary|compressed)$/, "")
+                    : null;
+            })
+                .filter((id) => id !== null)
+                .slice(0, 3);
+            const insights = this.extractInsightsFromAnswer(answer);
+            let seededCount = 0;
+            for (const insight of insights.slice(0, 5)) {
+                try {
+                    await this.saveNote({
+                        type: "prior_knowledge",
+                        content: insight.content,
+                        metadata: {
+                            source: "archive_seeding",
+                            source_sessions: sessionIds,
+                            insight_type: insight.type,
+                        },
+                    });
+                    seededCount++;
+                }
+                catch (error) {
+                    console.error(`   ⚠️ Failed to save insight: ${error}`);
+                }
+            }
+            console.error(`   ✅ Seeded ${seededCount} prior knowledge items from ${sessionIds.length} sessions`);
+        }
+        catch (error) {
+            console.error(`   ⚠️ Archive seeding failed: ${error.message}`);
+        }
+    }
+    extractInsightsFromAnswer(answer) {
+        const insights = [];
+        const segments = answer.split(/(?<=[.!?])\s+/).filter((s) => s.length > 20);
+        for (const segment of segments) {
+            const lowerSegment = segment.toLowerCase();
+            let type = "general";
+            if (lowerSegment.includes("decided") ||
+                lowerSegment.includes("decision") ||
+                lowerSegment.includes("chose")) {
+                type = "decision";
+            }
+            else if (lowerSegment.includes("pattern") ||
+                lowerSegment.includes("approach")) {
+                type = "pattern";
+            }
+            else if (lowerSegment.includes("learned") ||
+                lowerSegment.includes("lesson") ||
+                lowerSegment.includes("discovered")) {
+                type = "learning";
+            }
+            else if (lowerSegment.includes("implemented") ||
+                lowerSegment.includes("created") ||
+                lowerSegment.includes("added")) {
+                type = "implementation";
+            }
+            if (segment.length >= 30 && segment.length <= 300) {
+                insights.push({ type, content: segment.trim() });
+            }
+        }
+        const unique = [];
+        for (const insight of insights) {
+            const isDuplicate = unique.some((u) => u.content
+                .toLowerCase()
+                .includes(insight.content.toLowerCase().slice(0, 30)) ||
+                insight.content
+                    .toLowerCase()
+                    .includes(u.content.toLowerCase().slice(0, 30)));
+            if (!isDuplicate) {
+                unique.push(insight);
+            }
+        }
+        return unique;
+    }
+    async saveNote(note) {
+        try {
+            const embedding = await this.generateEmbedding(note.content);
+            const pointId = Date.now() * 1000 + Math.floor(Math.random() * 1000);
+            await withExternalSpan("qdrant", {
+                operation: "upsert",
+                collection: this.collectionName,
+            }, async (span) => {
+                span.setAttribute("service.note_type", note.type);
+                span.setAttribute("service.content_length", note.content.length);
+                await this.withQdrantCircuitBreaker(() => this.qdrant.upsert(this.collectionName, {
+                    points: [
+                        {
+                            id: pointId,
+                            vector: embedding,
+                            payload: {
+                                type: note.type,
+                                content: note.content,
+                                timestamp: new Date().toISOString(),
+                                session_id: this.sessionId,
+                                project_path: this.projectPath,
+                                ...note.metadata,
+                            },
+                        },
+                    ],
+                }));
+            });
+            console.error(`📝 Saved ${note.type}: ${note.content.slice(0, 60)}${note.content.length > 60 ? "..." : ""}`);
+        }
+        catch (error) {
+            console.error(`❌ Failed to save note: ${error.message}`);
+            throw error;
+        }
+    }
+    async search(query, limit = 5) {
+        try {
+            const embedding = await this.generateEmbedding(query);
+            const results = await withExternalSpan("qdrant", {
+                operation: "search",
+                collection: this.collectionName,
+            }, async (span) => {
+                const searchResults = await this.withQdrantCircuitBreaker(() => this.qdrant.search(this.collectionName, {
+                    vector: embedding,
+                    limit,
+                    with_payload: true,
+                }));
+                span.setAttribute("service.result_count", searchResults.length);
+                return searchResults;
+            });
+            return results.map((r) => ({
+                score: r.score || 0,
+                type: r.payload?.type || "unknown",
+                content: r.payload?.content || "",
+                timestamp: r.payload?.timestamp || "",
+                metadata: r.payload,
+            }));
+        }
+        catch (error) {
+            console.error(`❌ Search failed: ${error.message}`);
+            return [];
+        }
+    }
+    async checkDuplicate(description, threshold = 0.75) {
+        const results = await this.search(description, 5);
+        const duplicates = results.filter((r) => r.score >= threshold);
+        if (duplicates.length > 0) {
+            console.error(`⚠️  Found ${duplicates.length} potential duplicate(s):`);
+            duplicates.forEach((dup, i) => {
+                console.error(`   ${i + 1}. [${(dup.score * 100).toFixed(1)}% similar] ${dup.content.slice(0, 60)}...`);
+            });
+        }
+        return duplicates;
+    }
+    async getNotesByType(type) {
+        try {
+            const result = await this.qdrant.scroll(this.collectionName, {
+                limit: 100,
+                with_payload: true,
+                with_vector: false,
+                filter: {
+                    must: [
+                        {
+                            key: "type",
+                            match: { value: type },
+                        },
+                    ],
+                },
+            });
+            const points = result.points || [];
+            return points.map((point) => ({
+                score: 1.0,
+                type: point.payload?.type || "unknown",
+                content: point.payload?.content || "",
+                timestamp: point.payload?.timestamp || "",
+                metadata: point.payload,
+            }));
+        }
+        catch (error) {
+            console.error(`❌ Failed to get notes by type: ${error.message}`);
+            return [];
+        }
+    }
+    async extractValuableMemories() {
+        console.error("💎 Extracting high-value memories...");
+        const allTypes = [
+            "decision",
+            "hypothesis",
+            "blocker",
+            "learning",
+            "pattern",
+            "finding",
+            "prior_knowledge",
+            "decision_point",
+            "branch",
+        ];
+        const allNotes = [];
+        for (const type of allTypes) {
+            const notes = await this.getNotesByType(type);
+            allNotes.push(...notes);
+        }
+        allNotes.sort((a, b) => {
+            return new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime();
+        });
+        console.error(`   Found ${allNotes.length} total notes`);
+        return allNotes;
+    }
+    async cleanup() {
+        try {
+            await this.qdrant.deleteCollection(this.collectionName);
+            console.error(`🗑️  Cleaned up session collection: ${this.collectionName}`);
+        }
+        catch (error) {
+            if (error.message?.includes("Not found")) {
+                console.error(`ℹ️  Session collection already removed: ${this.collectionName}`);
+            }
+            else {
+                console.error(`⚠️  Failed to cleanup session: ${error.message}`);
+            }
+        }
+    }
+    async generateEmbedding(text) {
+        const MODEL = "gemini-embedding-001";
+        const DIMENSIONS = 3072;
+        const truncatedText = text.slice(0, 8000);
+        const cacheKey = embeddingCacheKey(truncatedText, MODEL);
+        const cached = embeddingCache.get(cacheKey);
+        if (cached) {
+            console.error(`   📦 Embedding cache hit`);
+            return cached.embedding;
+        }
+        const rateLimiter = ServiceRateLimiters.gemini();
+        await rateLimiter.acquire(1);
+        const geminiBreaker = ServiceCircuitBreakers.gemini();
+        return geminiBreaker.execute(async () => {
+            return withExternalSpan("gemini", {
+                operation: "embedding",
+                model: MODEL,
+            }, async (span) => {
+                try {
+                    const response = await this.genai.models.embedContent({
+                        model: MODEL,
+                        contents: truncatedText,
+                        config: {
+                            outputDimensionality: DIMENSIONS,
+                        },
+                    });
+                    const embedding = response.embeddings?.[0]?.values;
+                    if (!embedding) {
+                        throw new Error("No embedding returned from Gemini");
+                    }
+                    span.setAttribute("service.input_chars", truncatedText.length);
+                    span.setAttribute("service.dimensions", embedding.length);
+                    const cacheEntry = {
+                        embedding,
+                        model: MODEL,
+                        dimensions: embedding.length,
+                    };
+                    embeddingCache.set(cacheKey, cacheEntry);
+                    console.error(`   💾 Embedding cached (${embedding.length} dims)`);
+                    const inputTokens = Math.ceil(truncatedText.length / 4);
+                    getCostTracker().recordCost({
+                        service: "google",
+                        operation: "embedding",
+                        model: MODEL,
+                        inputTokens,
+                        outputTokens: 0,
+                        cached: false,
+                        duration: 0,
+                        module: "session",
+                    });
+                    return embedding;
+                }
+                catch (error) {
+                    console.error(`❌ Failed to generate embedding: ${error.message}`);
+                    throw error;
+                }
+            });
+        });
+    }
+    async getStats() {
+        const collectionInfo = await this.qdrant.getCollection(this.collectionName);
+        const notesByType = {};
+        const allTypes = [
+            "decision",
+            "hypothesis",
+            "blocker",
+            "learning",
+            "pattern",
+            "constraint",
+            "finding",
+            "prior_knowledge",
+            "decision_point",
+            "branch",
+        ];
+        for (const type of allTypes) {
+            const notes = await this.getNotesByType(type);
+            notesByType[type] = notes.length;
+        }
+        return {
+            collection: this.collectionName,
+            sessionId: this.sessionId,
+            totalNotes: collectionInfo.points_count || 0,
+            notesByType,
+        };
+    }
+    async trackConstraint(content, detectedFrom = "explicit", scope = "session", keywords) {
+        const constraint = {
+            id: `constraint-${Date.now()}`,
+            content,
+            detected_from: detectedFrom,
+            timestamp: new Date().toISOString(),
+            scope,
+            status: "active",
+            keywords: keywords || this.extractKeywords(content),
+            violated_count: 0,
+        };
+        const embedding = await this.generateEmbedding(content);
+        const pointId = Date.now() * 1000 + Math.floor(Math.random() * 1000);
+        await this.qdrant.upsert(this.collectionName, {
+            points: [
+                {
+                    id: pointId,
+                    vector: embedding,
+                    payload: {
+                        type: "constraint",
+                        content,
+                        timestamp: constraint.timestamp,
+                        session_id: this.sessionId,
+                        project_path: this.projectPath,
+                        constraint_id: constraint.id,
+                        detected_from: detectedFrom,
+                        scope,
+                        status: "active",
+                        keywords: constraint.keywords,
+                        point_id: pointId,
+                    },
+                },
+            ],
+        });
+        console.log(`🔒 Tracked constraint: ${content}`);
+        return constraint;
+    }
+    async getActiveConstraints() {
+        const constraintNotes = await this.getNotesByType("constraint");
+        return constraintNotes
+            .filter((note) => note.metadata?.status === "active")
+            .map((note) => ({
+            id: note.metadata?.constraint_id || `constraint-${Date.now()}`,
+            content: note.content,
+            detected_from: note.metadata?.detected_from || "explicit",
+            timestamp: note.timestamp,
+            scope: note.metadata?.scope || "session",
+            status: "active",
+            keywords: note.metadata?.keywords || [],
+            violated_count: note.metadata?.violated_count || 0,
+            metadata: note.metadata,
+        }));
+    }
+    async liftConstraint(constraintId) {
+        const constraintNotes = await this.getNotesByType("constraint");
+        const constraint = constraintNotes.find((n) => n.metadata?.constraint_id === constraintId);
+        if (!constraint) {
+            throw new Error(`Constraint not found: ${constraintId}`);
+        }
+        const pointId = constraint.metadata?.point_id;
+        if (!pointId) {
+            throw new Error(`Constraint missing point_id: ${constraintId}`);
+        }
+        await this.qdrant.setPayload(this.collectionName, {
+            points: [pointId],
+            payload: {
+                status: "lifted",
+                lifted_at: new Date().toISOString(),
+            },
+        });
+        console.log(`🔓 Lifted constraint: ${constraint.content}`);
+    }
+    async checkViolation(proposedAction) {
+        const activeConstraints = await this.getActiveConstraints();
+        if (activeConstraints.length === 0) {
+            return { violated: false, violations: [] };
+        }
+        const actionEmbedding = await this.generateEmbedding(proposedAction);
+        const constraintScores = [];
+        for (const constraint of activeConstraints) {
+            const constraintEmbedding = await this.generateEmbedding(constraint.content);
+            const semanticScore = this.cosineSimilarity(actionEmbedding, constraintEmbedding);
+            const keywordScore = this.calculateKeywordScore(proposedAction, constraint.keywords);
+            constraintScores.push({
+                constraint,
+                semanticScore,
+                keywordScore,
+            });
+        }
+        const semanticRanks = this.rankByScore(constraintScores, (s) => s.semanticScore);
+        const keywordRanks = this.rankByScore(constraintScores, (s) => s.keywordScore);
+        const RRF_THRESHOLD = 0.02;
+        const violations = [];
+        for (const scored of constraintScores) {
+            const semRank = semanticRanks.get(scored) ?? activeConstraints.length;
+            const kwRank = keywordRanks.get(scored) ?? activeConstraints.length;
+            const rrfScore = this.calculateRRFScore([semRank, kwRank]);
+            const hasSemanticSignal = scored.semanticScore > 0.4;
+            const hasKeywordSignal = scored.keywordScore > 0.3;
+            if (rrfScore >= RRF_THRESHOLD &&
+                (hasSemanticSignal || hasKeywordSignal)) {
+                let severity;
+                if (scored.constraint.scope === "session" && rrfScore > 0.025) {
+                    severity = "high";
+                }
+                else if (scored.constraint.scope === "session" || rrfScore > 0.025) {
+                    severity = "medium";
+                }
+                else {
+                    severity = "low";
+                }
+                const reasons = [];
+                if (hasSemanticSignal) {
+                    reasons.push(`semantic: ${(scored.semanticScore * 100).toFixed(0)}%`);
+                }
+                if (hasKeywordSignal) {
+                    reasons.push(`keywords: [${scored.constraint.keywords.slice(0, 3).join(", ")}]`);
+                }
+                violations.push({
+                    constraint: scored.constraint,
+                    severity,
+                    reason: `RRF hybrid match (${reasons.join(", ")})`,
+                    scores: {
+                        semantic: scored.semanticScore,
+                        keyword: scored.keywordScore,
+                        rrf: rrfScore,
+                    },
+                });
+            }
+        }
+        violations.sort((a, b) => b.scores.rrf - a.scores.rrf);
+        return {
+            violated: violations.length > 0,
+            violations,
+        };
+    }
+    extractKeywords(text) {
+        const keywords = [];
+        const lowerText = text.toLowerCase();
+        const stopwords = new Set([
+            "no",
+            "not",
+            "don't",
+            "doesn't",
+            "never",
+            "must",
+            "always",
+            "require",
+            "should",
+            "avoid",
+            "prevent",
+            "prohibit",
+            "forbidden",
+            "the",
+            "a",
+            "an",
+            "and",
+            "or",
+            "but",
+            "in",
+            "on",
+            "at",
+            "to",
+            "for",
+            "of",
+            "with",
+            "by",
+            "from",
+            "as",
+            "is",
+            "was",
+            "are",
+            "were",
+            "been",
+            "be",
+            "have",
+            "has",
+            "had",
+            "do",
+            "does",
+            "did",
+            "will",
+            "would",
+            "could",
+            "should",
+            "may",
+            "might",
+            "can",
+            "this",
+            "that",
+            "these",
+            "those",
+            "it",
+            "its",
+            "if",
+            "then",
+            "else",
+            "when",
+            "where",
+            "which",
+            "while",
+            "during",
+            "before",
+            "after",
+            "above",
+            "below",
+            "between",
+            "into",
+            "through",
+            "about",
+            "against",
+            "without",
+            "within",
+        ]);
+        const indicators = [
+            "no ",
+            "not ",
+            "don't ",
+            "doesn't ",
+            "never ",
+            "must ",
+            "always ",
+            "require ",
+            "should ",
+            "avoid ",
+            "prevent ",
+            "prohibit ",
+            "forbidden ",
+        ];
+        for (const indicator of indicators) {
+            const index = lowerText.indexOf(indicator);
+            if (index !== -1) {
+                const afterIndicator = lowerText.slice(index + indicator.length);
+                const words = afterIndicator.split(/\s+/).slice(0, 5);
+                const domainWords = words.filter((w) => w.length > 2 && !stopwords.has(w));
+                keywords.push(...domainWords);
+            }
+        }
+        return [...new Set(keywords)];
+    }
+    calculateKeywordScore(text, keywords) {
+        if (keywords.length === 0)
+            return 0;
+        const lowerText = text.toLowerCase();
+        let matchCount = 0;
+        let weightedScore = 0;
+        const priorityKeywords = [
+            "no",
+            "not",
+            "don't",
+            "never",
+            "must",
+            "always",
+            "require",
+            "avoid",
+            "prevent",
+            "prohibit",
+        ];
+        for (const keyword of keywords) {
+            const lowerKeyword = keyword.toLowerCase();
+            if (lowerText.includes(lowerKeyword)) {
+                matchCount++;
+                const weight = priorityKeywords.includes(lowerKeyword) ? 2.0 : 1.0;
+                const position = lowerText.indexOf(lowerKeyword);
+                const positionBonus = 1 - (position / lowerText.length) * 0.3;
+                weightedScore += weight * positionBonus;
+            }
+        }
+        const matchRatio = matchCount / keywords.length;
+        const avgWeight = matchCount > 0 ? weightedScore / matchCount : 0;
+        return Math.min(1.0, matchRatio * avgWeight);
+    }
+    calculateRRFScore(ranks, k = 60) {
+        return ranks.reduce((sum, rank) => sum + 1 / (k + rank), 0);
+    }
+    rankByScore(items, scoreGetter) {
+        const sorted = [...items].sort((a, b) => scoreGetter(b) - scoreGetter(a));
+        const ranks = new Map();
+        sorted.forEach((item, index) => ranks.set(item, index + 1));
+        return ranks;
+    }
+    cosineSimilarity(a, b) {
+        if (a.length !== b.length)
+            return 0;
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+            const aVal = a[i] ?? 0;
+            const bVal = b[i] ?? 0;
+            dotProduct += aVal * bVal;
+            normA += aVal * aVal;
+            normB += bVal * bVal;
+        }
+        return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+    }
+    async saveNoteWithId(note, relationships) {
+        try {
+            const embedding = await this.generateEmbedding(note.content);
+            const pointId = Date.now() * 1000 + Math.floor(Math.random() * 1000);
+            const payload = {
+                type: note.type,
+                content: note.content,
+                timestamp: new Date().toISOString(),
+                session_id: this.sessionId,
+                project_path: this.projectPath,
+                point_id: pointId,
+                ...note.metadata,
+            };
+            if (relationships) {
+                payload.relationships = relationships;
+            }
+            await this.qdrant.upsert(this.collectionName, {
+                points: [
+                    {
+                        id: pointId,
+                        vector: embedding,
+                        payload,
+                    },
+                ],
+            });
+            console.error(`📝 Saved ${note.type} (id: ${pointId}): ${note.content.slice(0, 60)}${note.content.length > 60 ? "..." : ""}`);
+            return pointId;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            console.error(`❌ Failed to save note: ${errorMessage}`);
+            throw error;
+        }
+    }
+    async addRelationship(sourceNoteId, targetNoteId, relationshipType) {
+        try {
+            const sourceNotes = await this.qdrant.retrieve(this.collectionName, {
+                ids: [sourceNoteId],
+                with_payload: true,
+            });
+            if (sourceNotes.length === 0) {
+                throw new Error(`Source note not found: ${sourceNoteId}`);
+            }
+            const targetNotes = await this.qdrant.retrieve(this.collectionName, {
+                ids: [targetNoteId],
+                with_payload: true,
+            });
+            if (targetNotes.length === 0) {
+                throw new Error(`Target note not found: ${targetNoteId}`);
+            }
+            const sourcePayload = sourceNotes[0]?.payload || {};
+            const existingRelationships = sourcePayload.relationships || {};
+            if (relationshipType === "superseded_by") {
+                existingRelationships[relationshipType] = targetNoteId;
+            }
+            else {
+                const existingArray = existingRelationships[relationshipType] || [];
+                if (!existingArray.includes(targetNoteId)) {
+                    existingArray.push(targetNoteId);
+                }
+                existingRelationships[relationshipType] = existingArray;
+            }
+            await this.qdrant.setPayload(this.collectionName, {
+                points: [sourceNoteId],
+                payload: {
+                    relationships: existingRelationships,
+                },
+            });
+            console.error(`🔗 Added relationship: ${sourceNoteId} --[${relationshipType}]--> ${targetNoteId}`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            console.error(`❌ Failed to add relationship: ${errorMessage}`);
+            throw error;
+        }
+    }
+    async getNoteById(pointId) {
+        try {
+            const notes = await this.qdrant.retrieve(this.collectionName, {
+                ids: [pointId],
+                with_payload: true,
+            });
+            if (notes.length === 0) {
+                return null;
+            }
+            const note = notes[0];
+            return {
+                score: 1.0,
+                type: note?.payload?.type || "unknown",
+                content: note?.payload?.content || "",
+                timestamp: note?.payload?.timestamp || "",
+                metadata: note?.payload,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            console.error(`❌ Failed to get note by ID: ${errorMessage}`);
+            return null;
+        }
+    }
+    async getRelatedNotes(pointId, relationshipType) {
+        try {
+            const sourceNote = await this.getNoteById(pointId);
+            if (!sourceNote) {
+                throw new Error(`Note not found: ${pointId}`);
+            }
+            const relationships = sourceNote.metadata?.relationships || {};
+            const relatedNotes = [];
+            const typesToQuery = relationshipType
+                ? [relationshipType]
+                : [
+                    "preceded_by",
+                    "caused_by",
+                    "validated_by",
+                    "superseded_by",
+                    "related_to",
+                ];
+            for (const relType of typesToQuery) {
+                const relatedIds = relationships[relType];
+                if (!relatedIds)
+                    continue;
+                const idsArray = Array.isArray(relatedIds) ? relatedIds : [relatedIds];
+                if (idsArray.length > 0) {
+                    const notes = await this.qdrant.retrieve(this.collectionName, {
+                        ids: idsArray,
+                        with_payload: true,
+                    });
+                    for (const note of notes) {
+                        relatedNotes.push({
+                            score: 1.0,
+                            type: note?.payload?.type || "unknown",
+                            content: note?.payload?.content || "",
+                            timestamp: note?.payload?.timestamp || "",
+                            metadata: note?.payload,
+                            relationship: relType,
+                        });
+                    }
+                }
+            }
+            return relatedNotes;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            console.error(`❌ Failed to get related notes: ${errorMessage}`);
+            return [];
+        }
+    }
+    async searchWithRelationships(query, limit = 5, includeRelationships = false) {
+        const results = await this.search(query, limit);
+        if (!includeRelationships) {
+            return results;
+        }
+        const enrichedResults = [];
+        for (const result of results) {
+            const pointId = result.metadata?.point_id;
+            let relatedNotes = [];
+            if (pointId) {
+                relatedNotes = await this.getRelatedNotes(pointId);
+            }
+            enrichedResults.push({
+                ...result,
+                relatedNotes: relatedNotes.length > 0 ? relatedNotes : undefined,
+            });
+        }
+        return enrichedResults;
+    }
+    async getCausalChain(startPointId, maxDepth = 5) {
+        const chain = [];
+        const visited = new Set();
+        const traverse = async (pointId, depth) => {
+            if (depth > maxDepth || visited.has(pointId))
+                return;
+            visited.add(pointId);
+            const note = await this.getNoteById(pointId);
+            if (!note)
+                return;
+            if (depth > 0) {
+                chain.push({
+                    ...note,
+                    depth,
+                    relationship: "caused_by",
+                });
+            }
+            const relationships = note.metadata?.relationships || {};
+            const causedBy = relationships.caused_by || [];
+            const precededBy = relationships.preceded_by || [];
+            for (const relatedId of [...causedBy, ...precededBy]) {
+                await traverse(relatedId, depth + 1);
+            }
+        };
+        const startNote = await this.getNoteById(startPointId);
+        if (startNote) {
+            chain.push({
+                ...startNote,
+                depth: 0,
+                relationship: "start",
+            });
+            await traverse(startPointId, 0);
+        }
+        chain.sort((a, b) => b.depth - a.depth);
+        return chain;
+    }
+    async getValidatingNotes(decisionId, maxResults = 20) {
+        try {
+            const validatingNotes = [];
+            let offset = null;
+            let found = 0;
+            while (found < maxResults) {
+                const scrollResult = await this.qdrant.scroll(this.collectionName, {
+                    with_payload: true,
+                    limit: 100,
+                    offset: offset ?? undefined,
+                });
+                if (!scrollResult.points || scrollResult.points.length === 0) {
+                    break;
+                }
+                for (const point of scrollResult.points) {
+                    if (found >= maxResults)
+                        break;
+                    const relationships = point.payload?.relationships;
+                    if (!relationships)
+                        continue;
+                    const validatedBy = relationships.validated_by;
+                    const relatedTo = relationships.related_to;
+                    const hasValidatedBy = validatedBy && validatedBy.includes(decisionId);
+                    const hasRelatedTo = relatedTo && relatedTo.includes(decisionId);
+                    if (hasValidatedBy || hasRelatedTo) {
+                        validatingNotes.push({
+                            score: 1.0,
+                            type: point.payload?.type || "unknown",
+                            content: point.payload?.content || "",
+                            timestamp: point.payload?.timestamp || "",
+                            metadata: {
+                                point_id: point.id,
+                                session_id: point.payload?.session_id,
+                                relationships,
+                            },
+                            relationship: hasValidatedBy ? "validated_by" : "related_to",
+                        });
+                        found++;
+                    }
+                }
+                const nextOffset = scrollResult.next_page_offset;
+                if (typeof nextOffset === "string" || typeof nextOffset === "number") {
+                    offset = nextOffset;
+                }
+                else {
+                    offset = null;
+                }
+                if (!offset)
+                    break;
+            }
+            validatingNotes.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+            return validatingNotes;
+        }
+        catch (error) {
+            console.error("Failed to get validating notes:", error);
+            return [];
+        }
+    }
+}
+//# sourceMappingURL=SessionCoordinator.js.map