@alvinveroy/codecompass/dist/lib/state.js

AI-powered MCP server for codebase navigation and LLM prompt optimization

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.createSession = createSession;
exports.getOrCreateSession = getOrCreateSession;
exports.addQuery = addQuery;
exports.addSuggestion = addSuggestion;
exports.addFeedback = addFeedback;
exports.updateContext = updateContext;
exports.getSessionHistory = getSessionHistory;
exports.clearSession = clearSession;
exports.getRecentQueries = getRecentQueries;
exports.getRelevantResults = getRelevantResults;
exports.getAverageRelevanceScore = getAverageRelevanceScore;
exports.addAgentSteps = addAgentSteps;
exports.getRecentAgentSteps = getRecentAgentSteps;
const config_service_1 = require("./config-service");
// In-memory state storage
const sessions = new Map();
// Create a new session
function createSession(repoPath) {
    const sessionId = generateSessionId();
    const session = {
        id: sessionId,
        queries: [],
        suggestions: [],
        context: {
            repoPath,
            lastFiles: [],
            lastDiff: "",
        },
        agentSteps: [],
        createdAt: Date.now(),
        lastUpdated: Date.now(),
    };
    sessions.set(sessionId, session);
    config_service_1.logger.info(`Created new session: ${sessionId}`);
    return session;
}
// Get or create a session
function getOrCreateSession(sessionId, repoPath) {
    if (sessionId && sessions.has(sessionId)) {
        const session = sessions.get(sessionId);
        session.lastUpdated = Date.now();
        return session;
    }
    if (!repoPath) {
        throw new Error("Repository path is required to create a new session");
    }
    return createSession(repoPath);
}
// Add a query to session
function addQuery(sessionId, query, results = [], relevanceScore = 0) {
    const session = getOrCreateSession(sessionId);
    session.queries.push({
        timestamp: Date.now(),
        query,
        results,
        relevanceScore,
    });
    session.lastUpdated = Date.now();
    return session;
}
// Add a suggestion to session
function addSuggestion(sessionId, prompt, suggestion) {
    const session = getOrCreateSession(sessionId);
    session.suggestions.push({
        timestamp: Date.now(),
        prompt,
        suggestion,
    });
    session.lastUpdated = Date.now();
    return session;
}
// Add feedback to the latest suggestion
function addFeedback(sessionId, score, comments) {
    const session = getOrCreateSession(sessionId);
    if (session.suggestions.length === 0) {
        throw new Error("No suggestions found to add feedback to");
    }
    const latestSuggestion = session.suggestions[session.suggestions.length - 1];
    latestSuggestion.feedback = {
        score,
        comments,
    };
    session.lastUpdated = Date.now();
    return session;
}
// Update context in session
function updateContext(sessionId, repoPath, lastFiles, lastDiff) {
    const session = getOrCreateSession(sessionId);
    if (repoPath) {
        session.context.repoPath = repoPath;
    }
    if (lastFiles) {
        session.context.lastFiles = lastFiles;
    }
    if (lastDiff) {
        session.context.lastDiff = lastDiff;
    }
    session.lastUpdated = Date.now();
    return session;
}
// Get session history
function getSessionHistory(sessionId) {
    if (!sessions.has(sessionId)) {
        throw new Error(`Session not found: ${sessionId}`);
    }
    return sessions.get(sessionId);
}
// Clear session
function clearSession(sessionId) {
    if (sessions.has(sessionId)) {
        sessions.delete(sessionId);
        config_service_1.logger.info(`Cleared session: ${sessionId}`);
    }
}
// Generate a unique session ID
function generateSessionId() {
    return `session_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
}
// Get the most recent queries
function getRecentQueries(sessionId, limit = 5) {
    const session = getOrCreateSession(sessionId);
    return session.queries
        .slice(-limit)
        .map(q => q.query);
}
// Get the most relevant results from previous queries
function getRelevantResults(sessionId, limit = 3) {
    const session = getOrCreateSession(sessionId);
    return session.queries
        .sort((a, b) => b.relevanceScore - a.relevanceScore)
        .slice(0, limit)
        .flatMap(q => q.results);
}
// Calculate average relevance score for a session
function getAverageRelevanceScore(sessionId) {
    const session = getOrCreateSession(sessionId);
    if (session.queries.length === 0)
        return 0;
    const sum = session.queries.reduce((acc, q) => acc + q.relevanceScore, 0);
    return sum / session.queries.length;
}
// Add agent steps to session
function addAgentSteps(sessionId, query, steps, finalResponse) {
    const session = getOrCreateSession(sessionId);
    if (!session.agentSteps) {
        session.agentSteps = [];
    }
    session.agentSteps.push({
        timestamp: Date.now(),
        query,
        steps,
        finalResponse
    });
    session.lastUpdated = Date.now();
    return session;
}
// Get the most recent agent steps
function getRecentAgentSteps(sessionId, limit = 3) {
    const session = getOrCreateSession(sessionId);
    if (!session.agentSteps) {
        return [];
    }
    return session.agentSteps
        .slice(-limit)
        .map(step => ({
        query: step.query,
        tools: step.steps.map(s => s.tool),
        timestamp: step.timestamp
    }));
}