@felkot/think-mcp 1.1.0

package/dist/services/insights.service.js

@@ -0,0 +1,216 @@
+/**
+ * InsightsService - Cross-session learning from winning paths
+ * Version 1.0.0
+ *
+ * Stores successful reasoning patterns for future recall.
+ * NO LLM, NO Vector DB - just JSON persistence + Fuse.js search.
+ */
+import { promises as fs } from 'fs';
+import { dirname } from 'path';
+import Fuse from 'fuse.js';
+import { getThinkStoragePaths } from '../utils/storage-paths.js';
+import { redactSensitiveContent } from '../utils/sensitive-data.js';
+// Constants
+const STORAGE_PATHS = getThinkStoragePaths(import.meta.url);
+const INSIGHTS_FILE = STORAGE_PATHS.insightsFile;
+const LEGACY_INSIGHTS_FILE = STORAGE_PATHS.legacyInsightsFile;
+const INSIGHTS_DIR = dirname(INSIGHTS_FILE);
+const MAX_INSIGHTS = 100; // FIFO limit to prevent bloat
+const INSIGHTS_SEARCH_THRESHOLD = 0.4;
+export class InsightsService {
+    data = null;
+    fuseIndex = null;
+    isDirty = false;
+    sanitizeText(value) {
+        if (!value)
+            return value;
+        return redactSensitiveContent(value).slice(0, 2000);
+    }
+    async loadFromFile(filePath) {
+        const content = await fs.readFile(filePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    /**
+     * Extract keywords from text for pattern tracking
+     */
+    extractKeywords(text) {
+        const stopWords = new Set([
+            'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
+            'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
+            'should', 'may', 'might', 'must', 'shall', 'can', 'need', 'dare',
+            'to', 'of', 'in', 'for', 'on', 'with', 'at', 'by', 'from', 'as',
+            'into', 'through', 'during', 'before', 'after', 'above', 'below',
+            'and', 'but', 'or', 'nor', 'so', 'yet', 'both', 'either', 'neither',
+            'this', 'that', 'these', 'those', 'it', 'its', 'i', 'we', 'you', 'they',
+        ]);
+        return text
+            .toLowerCase()
+            .replace(/[^a-z0-9\s-]/g, ' ')
+            .split(/\s+/)
+            .filter(word => word.length >= 3 && !stopWords.has(word))
+            .slice(0, 10); // Limit to 10 keywords per insight
+    }
+    /**
+     * Load insights from file
+     */
+    async load() {
+        try {
+            this.data = await this.loadFromFile(INSIGHTS_FILE);
+            this.rebuildIndex();
+            console.error(`📚 Loaded ${this.data.winningPaths.length} insights from ${this.data.totalSessions} sessions`);
+        }
+        catch {
+            try {
+                this.data = await this.loadFromFile(LEGACY_INSIGHTS_FILE);
+                this.rebuildIndex();
+                console.error(`📚 Loaded legacy insights from ${LEGACY_INSIGHTS_FILE}`);
+            }
+            catch {
+                // File doesn't exist - initialize empty
+                this.data = {
+                    winningPaths: [],
+                    patterns: {},
+                    totalSessions: 0,
+                    lastUpdated: new Date().toISOString(),
+                };
+                console.error('📚 No insights file found, starting fresh');
+            }
+        }
+    }
+    /**
+     * Rebuild Fuse.js index for search
+     */
+    rebuildIndex() {
+        if (!this.data)
+            return;
+        this.fuseIndex = new Fuse(this.data.winningPaths, {
+            keys: [
+                { name: 'summary', weight: 0.5 },
+                { name: 'goal', weight: 0.3 },
+                { name: 'keywords', weight: 0.2 },
+            ],
+            threshold: INSIGHTS_SEARCH_THRESHOLD,
+            includeScore: true,
+            ignoreLocation: true,
+        });
+    }
+    /**
+     * Save insights to file (atomic write)
+     */
+    async save() {
+        if (!this.data || !this.isDirty)
+            return;
+        this.data.lastUpdated = new Date().toISOString();
+        const tempFile = `${INSIGHTS_FILE}.tmp`;
+        try {
+            await fs.mkdir(INSIGHTS_DIR, { recursive: true });
+            await fs.writeFile(tempFile, JSON.stringify(this.data, null, 2), 'utf-8');
+            await fs.rename(tempFile, INSIGHTS_FILE);
+            this.isDirty = false;
+            console.error(`💾 Saved ${this.data.winningPaths.length} insights`);
+        }
+        catch (error) {
+            console.error('Failed to save insights:', error);
+            try {
+                await fs.unlink(tempFile);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    /**
+     * Save a winning path as an insight
+     */
+    async saveWinningPath(input) {
+        if (!this.data)
+            await this.load();
+        const { path, summary, goal, avgConfidence, sessionLength } = input;
+        const safeSummary = this.sanitizeText(summary) ?? '';
+        const safeGoal = this.sanitizeText(goal);
+        // Extract keywords from summary and goal
+        const keywords = [
+            ...this.extractKeywords(safeSummary),
+            ...(safeGoal ? this.extractKeywords(safeGoal) : []),
+        ];
+        // Create record
+        const record = {
+            path,
+            summary: safeSummary,
+            goal: safeGoal,
+            keywords: [...new Set(keywords)], // Dedupe
+            timestamp: new Date().toISOString(),
+            avgConfidence,
+            sessionLength,
+        };
+        // Add to winningPaths (FIFO)
+        this.data.winningPaths.push(record);
+        if (this.data.winningPaths.length > MAX_INSIGHTS) {
+            this.data.winningPaths.shift();
+        }
+        // Update pattern counts
+        for (const keyword of record.keywords) {
+            this.data.patterns[keyword] = (this.data.patterns[keyword] || 0) + 1;
+        }
+        this.data.totalSessions++;
+        this.isDirty = true;
+        // Rebuild index and save
+        this.rebuildIndex();
+        await this.save();
+        console.error(`📝 Saved insight: "${summary.substring(0, 50)}..." (${record.keywords.length} keywords)`);
+    }
+    /**
+     * Search insights by query
+     */
+    async search(query, limit = 3) {
+        if (!this.data)
+            await this.load();
+        if (!this.fuseIndex || this.data.winningPaths.length === 0) {
+            return {
+                matches: [],
+                totalInsights: 0,
+                topPatterns: [],
+            };
+        }
+        // Search using Fuse.js
+        const results = this.fuseIndex.search(query, { limit });
+        const matches = results.map(r => ({
+            insight: r.item,
+            relevance: r.score ?? 1,
+        }));
+        // Get top patterns
+        const topPatterns = Object.entries(this.data.patterns)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 5)
+            .map(([keyword, count]) => ({ keyword, count }));
+        return {
+            matches,
+            totalInsights: this.data.winningPaths.length,
+            topPatterns,
+        };
+    }
+    /**
+     * Get statistics about stored insights
+     */
+    async getStats() {
+        if (!this.data)
+            await this.load();
+        const paths = this.data.winningPaths;
+        const avgSessionLength = paths.length > 0
+            ? paths.reduce((sum, p) => sum + p.sessionLength, 0) / paths.length
+            : 0;
+        const withConfidence = paths.filter(p => p.avgConfidence !== undefined);
+        const avgConfidence = withConfidence.length > 0
+            ? withConfidence.reduce((sum, p) => sum + (p.avgConfidence ?? 0), 0) / withConfidence.length
+            : 0;
+        const topPatterns = Object.entries(this.data.patterns)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 10)
+            .map(([keyword, count]) => ({ keyword, count }));
+        return {
+            totalInsights: paths.length,
+            totalSessions: this.data.totalSessions,
+            topPatterns,
+            avgSessionLength: Math.round(avgSessionLength * 10) / 10,
+            avgConfidence: Math.round(avgConfidence * 10) / 10,
+        };
+    }
+}

package/dist/services/logic.service.d.ts

@@ -0,0 +1,28 @@
+/**
+ * LogicService - Pure Thinking Methodology Generator
+ * Version 5.0.0 - Methodology Edition
+ *
+ * PURPOSE: Teach AI HOW to think about code analysis, not WHAT to find.
+ * Output is a thinking ALGORITHM that AI applies to specific code.
+ *
+ * Philosophy: "Teach to fish, don't give fish"
+ * - Not: "Is there N+1 query?" (specific question)
+ * - But: "For each data access, ask: is this inside a loop?" (thinking pattern)
+ */
+import type { LogicAnalysisInput, LogicAnalysisResult } from '../types/thought.types.js';
+export declare class LogicService {
+    /**
+     * Generate thinking methodology for the target
+     */
+    analyze(input: LogicAnalysisInput): LogicAnalysisResult;
+    private buildMethodology;
+    private buildExecutionOrder;
+    private buildPriorityPlan;
+    private buildVerifyChecklist;
+    private buildPreMortem;
+    private errorResult;
+    /**
+     * Format as markdown for AI consumption
+     */
+    formatAsMarkdown(result: LogicAnalysisResult): string;
+}