@rpcajr/smart-graph-indexer 1.0.0

package/dist/stats.js

@@ -0,0 +1,146 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatsManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class StatsManager {
+    statsPath;
+    stats;
+    currentSessionId;
+    constructor(projectPath) {
+        const mcpDir = path.join(path.resolve(projectPath), '.graph-indexer');
+        this.statsPath = path.join(mcpDir, 'stats.json');
+        this.currentSessionId = new Date().toISOString();
+        this.stats = this.loadStats();
+    }
+    loadStats() {
+        if (fs.existsSync(this.statsPath)) {
+            try {
+                const raw = fs.readFileSync(this.statsPath, 'utf-8');
+                const parsed = JSON.parse(raw);
+                if (parsed && parsed.totalCalls !== undefined) {
+                    if (!parsed.history) {
+                        parsed.history = [];
+                    }
+                    parsed.efficiencyPercentage = parsed.totalTokensAlternative > 0
+                        ? Math.round((parsed.totalTokensSaved / parsed.totalTokensAlternative) * 100)
+                        : 0;
+                    return parsed;
+                }
+            }
+            catch (err) {
+                console.error('Failed to load stats, resetting...', err);
+            }
+        }
+        return {
+            totalCalls: 0,
+            totalTokensSaved: 0,
+            totalTokensActual: 0,
+            totalTokensAlternative: 0,
+            efficiencyPercentage: 0,
+            callsByType: {
+                search_symbols: { calls: 0, saved: 0, actual: 0, alternative: 0, totalTimeMs: 0 },
+                get_file_skeleton: { calls: 0, saved: 0, actual: 0, alternative: 0, totalTimeMs: 0 },
+                get_dependencies: { calls: 0, saved: 0, actual: 0, alternative: 0, totalTimeMs: 0 },
+                read_symbol_body: { calls: 0, saved: 0, actual: 0, alternative: 0, totalTimeMs: 0 }
+            },
+            history: []
+        };
+    }
+    saveStats() {
+        try {
+            const mcpDir = path.dirname(this.statsPath);
+            if (!fs.existsSync(mcpDir)) {
+                fs.mkdirSync(mcpDir, { recursive: true });
+            }
+            fs.writeFileSync(this.statsPath, JSON.stringify(this.stats, null, 2), 'utf-8');
+        }
+        catch (err) {
+            console.error('Failed to save stats:', err);
+        }
+    }
+    /**
+     * Estimates tokens based on character count (1 token approx 4 characters).
+     */
+    estimateTokens(text) {
+        return Math.ceil(text.length / 4);
+    }
+    /**
+     * Records a tool call and computes the token savings.
+     */
+    recordCall(toolName, actualPayload, alternativeText, target, execTimeMs = 0) {
+        const actualTokens = this.estimateTokens(actualPayload);
+        const alternativeTokens = this.estimateTokens(alternativeText);
+        const savedTokens = Math.max(0, alternativeTokens - actualTokens);
+        this.stats.totalCalls += 1;
+        this.stats.totalTokensActual += actualTokens;
+        this.stats.totalTokensAlternative += alternativeTokens;
+        this.stats.totalTokensSaved += savedTokens;
+        // Calculate overall efficiency percentage
+        this.stats.efficiencyPercentage = this.stats.totalTokensAlternative > 0
+            ? Math.round((this.stats.totalTokensSaved / this.stats.totalTokensAlternative) * 100)
+            : 0;
+        if (!this.stats.callsByType[toolName]) {
+            this.stats.callsByType[toolName] = { calls: 0, saved: 0, actual: 0, alternative: 0, totalTimeMs: 0 };
+        }
+        const toolStats = this.stats.callsByType[toolName];
+        toolStats.calls += 1;
+        toolStats.saved += savedTokens;
+        toolStats.actual += actualTokens;
+        toolStats.alternative += alternativeTokens;
+        toolStats.totalTimeMs += execTimeMs;
+        // Add entry to history
+        this.stats.history.unshift({
+            timestamp: new Date().toISOString(),
+            sessionId: this.currentSessionId,
+            toolName,
+            saved: savedTokens,
+            actual: actualTokens,
+            alternative: alternativeTokens,
+            target,
+            execTimeMs
+        });
+        // Cap history to 500 entries to avoid file bloat
+        if (this.stats.history.length > 500) {
+            this.stats.history = this.stats.history.slice(0, 500);
+        }
+        this.saveStats();
+    }
+    getStats() {
+        return this.stats;
+    }
+}
+exports.StatsManager = StatsManager;

package/dist/ui.d.ts

@@ -0,0 +1,2 @@
+import { IndexerEngine } from './mcp_server.js';
+export declare function generateGraphHtml(engine: IndexerEngine): string;