@trentapps/manager-protocol 1.3.0

package/dist/supervisor/ProjectTracker.js

@@ -0,0 +1,709 @@
+/**
+ * Project Tracker - Tracks agent activity across projects
+ *
+ * This system monitors:
+ * - Which agents are working in which projects
+ * - Real-time agent activity logs per project
+ * - Project metadata (git info, path, status)
+ * - Historical activity and statistics
+ */
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import path from 'path';
+import fs from 'fs';
+import { hashString } from '../utils/shared.js';
+const execAsync = promisify(exec);
+/**
+ * Simple in-memory cache with TTL
+ */
+class GitCache {
+    cache = new Map();
+    defaultTTL;
+    constructor(defaultTTLMs = 60000) {
+        this.defaultTTL = defaultTTLMs;
+    }
+    get(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return undefined;
+        if (Date.now() > entry.expiresAt) {
+            this.cache.delete(key);
+            return undefined;
+        }
+        return entry.value;
+    }
+    set(key, value, ttlMs) {
+        this.cache.set(key, {
+            value,
+            expiresAt: Date.now() + (ttlMs ?? this.defaultTTL)
+        });
+    }
+    delete(key) {
+        this.cache.delete(key);
+    }
+    clear() {
+        this.cache.clear();
+    }
+    /**
+     * Clean up expired entries
+     */
+    cleanup() {
+        const now = Date.now();
+        for (const [key, entry] of this.cache.entries()) {
+            if (now > entry.expiresAt) {
+                this.cache.delete(key);
+            }
+        }
+    }
+}
+class ProjectTracker {
+    projects = new Map();
+    agents = new Map();
+    activityLog = new Map(); // projectId -> activities
+    agentActivityIndex = new Map(); // agentId -> activities (performance index)
+    agentToProject = new Map(); // agentId -> projectId
+    // Git data cache with 60-second TTL to prevent repeated blocking calls
+    gitCache = new GitCache(60000);
+    // Track pending git operations to prevent duplicate concurrent calls
+    pendingGitOps = new Map();
+    // Configuration
+    maxActivitiesPerProject = 1000;
+    activityRetentionMs = 24 * 60 * 60 * 1000; // 24 hours
+    agentIdleTimeoutMs = 5 * 60 * 1000; // 5 minutes of inactivity = idle
+    agentDisconnectTimeoutMs = 30 * 60 * 1000; // 30 minutes = disconnected
+    gitCacheTTLMs = 60000; // 60 seconds cache for git data
+    /**
+     * Register or update a project
+     */
+    async registerProject(projectPath) {
+        const projectId = this.getProjectId(projectPath);
+        let project = this.projects.get(projectId);
+        if (!project) {
+            project = await this.createProjectInfo(projectPath);
+            this.projects.set(projectId, project);
+            this.activityLog.set(projectId, []);
+        }
+        else {
+            // Update git info
+            await this.updateGitInfo(project, projectPath);
+        }
+        return project;
+    }
+    /**
+     * Record agent activity in a project
+     * NO LONGER auto-creates agent entries - use registerSession() explicitly
+     */
+    recordActivity(projectPath, agentId, sessionId, activity) {
+        const projectId = this.getProjectId(projectPath);
+        // Ensure project exists
+        if (!this.projects.has(projectId)) {
+            // Auto-register project
+            this.registerProject(projectPath).catch(console.error);
+        }
+        // Record activity
+        const fullActivity = {
+            agentId,
+            sessionId,
+            timestamp: new Date().toISOString(),
+            ...activity
+        };
+        const activities = this.activityLog.get(projectId) || [];
+        activities.unshift(fullActivity); // Add to beginning
+        // Trim old activities
+        if (activities.length > this.maxActivitiesPerProject) {
+            activities.splice(this.maxActivitiesPerProject);
+        }
+        this.activityLog.set(projectId, activities);
+        // Update agent activity index for efficient agent-based queries
+        const agentActivities = this.agentActivityIndex.get(agentId) || [];
+        agentActivities.unshift(fullActivity);
+        if (agentActivities.length > this.maxActivitiesPerProject) {
+            agentActivities.splice(this.maxActivitiesPerProject);
+        }
+        this.agentActivityIndex.set(agentId, agentActivities);
+        // Update project stats
+        this.updateProjectStats(projectId);
+        // Only update agent if it's already registered
+        if (this.agents.has(agentId)) {
+            this.updateAgentInfo(agentId, sessionId, projectPath);
+            this.agentToProject.set(agentId, projectId);
+        }
+    }
+    /**
+     * Explicitly register a session/agent working on a project
+     * Must be called by services or Claude instances to appear in agent list
+     */
+    registerSession(params) {
+        const projectId = this.getProjectId(params.projectPath);
+        // Ensure project exists
+        if (!this.projects.has(projectId)) {
+            this.registerProject(params.projectPath).catch(console.error);
+        }
+        let agent = this.agents.get(params.agentId);
+        if (!agent) {
+            agent = {
+                agentId: params.agentId,
+                sessionId: params.sessionId,
+                currentProject: projectId,
+                startTime: new Date().toISOString(),
+                lastActivity: new Date().toISOString(),
+                actionsCount: 0,
+                status: 'active',
+                ...(params.agentType && { type: params.agentType }),
+                ...(params.metadata && { metadata: params.metadata })
+            };
+        }
+        else {
+            agent.currentProject = projectId;
+            agent.lastActivity = new Date().toISOString();
+            agent.status = 'active';
+            if (params.metadata) {
+                agent.metadata = { ...agent.metadata, ...params.metadata };
+            }
+        }
+        this.agents.set(params.agentId, agent);
+        this.agentToProject.set(params.agentId, projectId);
+        return agent;
+    }
+    /**
+     * Explicitly unregister/complete a session
+     */
+    completeSession(agentId, outcome) {
+        const agent = this.agents.get(agentId);
+        if (agent) {
+            agent.status = 'disconnected';
+            agent.completedAt = new Date().toISOString();
+            if (outcome) {
+                agent.outcome = outcome;
+            }
+            this.agents.set(agentId, agent);
+            // Will be cleaned up by cleanupStaleAgents after retention period
+        }
+    }
+    /**
+     * Get all projects
+     */
+    getProjects() {
+        return Array.from(this.projects.values())
+            .sort((a, b) => {
+            // Sort by last activity, most recent first
+            if (!a.lastActivity && !b.lastActivity)
+                return 0;
+            if (!a.lastActivity)
+                return 1;
+            if (!b.lastActivity)
+                return -1;
+            return new Date(b.lastActivity).getTime() - new Date(a.lastActivity).getTime();
+        });
+    }
+    /**
+     * Get project by ID or path
+     */
+    getProject(idOrPath) {
+        const projectId = idOrPath.startsWith('/') ? this.getProjectId(idOrPath) : idOrPath;
+        return this.projects.get(projectId);
+    }
+    /**
+     * Get project activities
+     */
+    getProjectActivities(projectId, limit = 100) {
+        const activities = this.activityLog.get(projectId) || [];
+        return activities.slice(0, limit);
+    }
+    /**
+     * Get agent activities efficiently (uses index, no N+1 queries)
+     */
+    getAgentActivities(agentId, limit = 100) {
+        const activities = this.agentActivityIndex.get(agentId) || [];
+        return activities.slice(0, limit);
+    }
+    /**
+     * Get recent activities across all projects efficiently
+     * Uses k-way merge for optimal performance (O(n log k) where n=limit, k=projects)
+     * Avoids fetching and sorting thousands of activities when only need a few
+     */
+    getAllRecentActivities(limit = 50) {
+        // Create iterators for each project's activity log
+        const projectIterators = [];
+        for (const [projectId, activities] of this.activityLog.entries()) {
+            if (activities.length > 0) {
+                const project = this.projects.get(projectId);
+                projectIterators.push({
+                    projectId,
+                    projectName: project?.name || projectId,
+                    activities,
+                    index: 0
+                });
+            }
+        }
+        // K-way merge using a simple approach
+        const result = [];
+        while (result.length < limit && projectIterators.length > 0) {
+            // Find the iterator with the most recent activity
+            let maxTimestamp = 0;
+            let maxIteratorIndex = -1;
+            for (let i = 0; i < projectIterators.length; i++) {
+                const iterator = projectIterators[i];
+                if (iterator.index < iterator.activities.length) {
+                    const activity = iterator.activities[iterator.index];
+                    const timestamp = new Date(activity.timestamp).getTime();
+                    if (timestamp > maxTimestamp) {
+                        maxTimestamp = timestamp;
+                        maxIteratorIndex = i;
+                    }
+                }
+            }
+            // If we found an activity, add it to results
+            if (maxIteratorIndex >= 0) {
+                const iterator = projectIterators[maxIteratorIndex];
+                const activity = iterator.activities[iterator.index];
+                result.push({
+                    ...activity,
+                    projectId: iterator.projectId,
+                    projectName: iterator.projectName
+                });
+                // Move iterator forward
+                iterator.index++;
+                // Remove iterator if exhausted
+                if (iterator.index >= iterator.activities.length) {
+                    projectIterators.splice(maxIteratorIndex, 1);
+                }
+            }
+            else {
+                // No more activities
+                break;
+            }
+        }
+        return result;
+    }
+    /**
+     * Clean up stale agents (remove disconnected agents older than retention period)
+     */
+    cleanupStaleAgents() {
+        const now = Date.now();
+        const disconnectedRetentionMs = 60 * 60 * 1000; // Keep disconnected for 1 hour
+        for (const [agentId, agent] of this.agents.entries()) {
+            const lastActivityTime = new Date(agent.lastActivity).getTime();
+            const inactiveDuration = now - lastActivityTime;
+            // Remove agents that have been disconnected for too long
+            if (agent.status === 'disconnected' && inactiveDuration > disconnectedRetentionMs) {
+                this.agents.delete(agentId);
+                this.agentToProject.delete(agentId);
+                continue;
+            }
+            // Mark idle agents as disconnected if inactive for 30+ minutes
+            if (inactiveDuration > this.agentDisconnectTimeoutMs) {
+                agent.status = 'disconnected';
+                this.agents.set(agentId, agent);
+            }
+            // Mark active agents as idle if inactive for 5+ minutes
+            else if (agent.status === 'active' && inactiveDuration > this.agentIdleTimeoutMs) {
+                agent.status = 'idle';
+                this.agents.set(agentId, agent);
+            }
+        }
+    }
+    /**
+     * Get all agents (automatically cleans up stale entries)
+     */
+    getAgents() {
+        this.cleanupStaleAgents();
+        return Array.from(this.agents.values())
+            .sort((a, b) => new Date(b.lastActivity).getTime() - new Date(a.lastActivity).getTime());
+    }
+    /**
+     * Get agents working in a specific project
+     */
+    getProjectAgents(projectId) {
+        const agents = [];
+        for (const [agentId, currentProjectId] of this.agentToProject.entries()) {
+            if (currentProjectId === projectId) {
+                const agent = this.agents.get(agentId);
+                if (agent) {
+                    agents.push(agent);
+                }
+            }
+        }
+        return agents.sort((a, b) => new Date(b.lastActivity).getTime() - new Date(a.lastActivity).getTime());
+    }
+    /**
+     * Get agent by ID
+     */
+    getAgent(agentId) {
+        return this.agents.get(agentId);
+    }
+    /**
+     * Get overall metrics summary
+     */
+    getMetrics() {
+        const now = Date.now();
+        const last24h = now - (24 * 60 * 60 * 1000);
+        let totalTokens = 0;
+        let totalCost = 0;
+        let totalLatency = 0;
+        let latencyCount = 0;
+        let requestCount = 0;
+        let errorCount = 0;
+        let tokens24h = 0;
+        let cost24h = 0;
+        let requests24h = 0;
+        let errors24h = 0;
+        // Aggregate from all project activities
+        for (const activities of this.activityLog.values()) {
+            for (const activity of activities) {
+                const activityTime = new Date(activity.timestamp).getTime();
+                const isRecent = activityTime > last24h;
+                requestCount++;
+                if (isRecent)
+                    requests24h++;
+                if (activity.tokensUsed) {
+                    totalTokens += activity.tokensUsed;
+                    if (isRecent)
+                        tokens24h += activity.tokensUsed;
+                }
+                if (activity.estimatedCost) {
+                    totalCost += activity.estimatedCost;
+                    if (isRecent)
+                        cost24h += activity.estimatedCost;
+                }
+                if (activity.latencyMs) {
+                    totalLatency += activity.latencyMs;
+                    latencyCount++;
+                }
+                if (activity.outcome === 'failure') {
+                    errorCount++;
+                    if (isRecent)
+                        errors24h++;
+                }
+            }
+        }
+        return {
+            totalTokens,
+            totalCost,
+            avgLatency: latencyCount > 0 ? totalLatency / latencyCount : 0,
+            errorRate: requestCount > 0 ? errorCount / requestCount : 0,
+            requestCount,
+            last24h: {
+                tokens: tokens24h,
+                cost: cost24h,
+                requests: requests24h,
+                errors: errors24h
+            }
+        };
+    }
+    /**
+     * Get metrics for a specific project
+     */
+    getProjectMetrics(projectId) {
+        const now = Date.now();
+        const last24h = now - (24 * 60 * 60 * 1000);
+        let totalTokens = 0;
+        let totalCost = 0;
+        let totalLatency = 0;
+        let latencyCount = 0;
+        let requestCount = 0;
+        let errorCount = 0;
+        let tokens24h = 0;
+        let cost24h = 0;
+        let requests24h = 0;
+        let errors24h = 0;
+        const activities = this.activityLog.get(projectId) || [];
+        for (const activity of activities) {
+            const activityTime = new Date(activity.timestamp).getTime();
+            const isRecent = activityTime > last24h;
+            requestCount++;
+            if (isRecent)
+                requests24h++;
+            if (activity.tokensUsed) {
+                totalTokens += activity.tokensUsed;
+                if (isRecent)
+                    tokens24h += activity.tokensUsed;
+            }
+            if (activity.estimatedCost) {
+                totalCost += activity.estimatedCost;
+                if (isRecent)
+                    cost24h += activity.estimatedCost;
+            }
+            if (activity.latencyMs) {
+                totalLatency += activity.latencyMs;
+                latencyCount++;
+            }
+            if (activity.outcome === 'failure') {
+                errorCount++;
+                if (isRecent)
+                    errors24h++;
+            }
+        }
+        return {
+            totalTokens,
+            totalCost,
+            avgLatency: latencyCount > 0 ? totalLatency / latencyCount : 0,
+            errorRate: requestCount > 0 ? errorCount / requestCount : 0,
+            requestCount,
+            last24h: {
+                tokens: tokens24h,
+                cost: cost24h,
+                requests: requests24h,
+                errors: errors24h
+            }
+        };
+    }
+    /**
+     * Mark agent as disconnected
+     */
+    markAgentDisconnected(agentId) {
+        const agent = this.agents.get(agentId);
+        if (agent) {
+            agent.status = 'disconnected';
+            this.agents.set(agentId, agent);
+        }
+        // Remove from project mapping
+        this.agentToProject.delete(agentId);
+        // Update project active agent count
+        for (const project of this.projects.values()) {
+            project.activeAgents = this.getProjectAgents(project.id).filter(a => a.status === 'active').length;
+        }
+    }
+    /**
+     * Clean up old data
+     */
+    cleanup() {
+        const now = Date.now();
+        const cutoff = now - this.activityRetentionMs;
+        // Clean up old activities
+        for (const [projectId, activities] of this.activityLog.entries()) {
+            const filtered = activities.filter(a => new Date(a.timestamp).getTime() > cutoff);
+            this.activityLog.set(projectId, filtered);
+        }
+        // Mark idle agents as disconnected
+        const idleThreshold = 5 * 60 * 1000; // 5 minutes
+        for (const agent of this.agents.values()) {
+            const lastActivity = new Date(agent.lastActivity).getTime();
+            if (now - lastActivity > idleThreshold && agent.status === 'active') {
+                agent.status = 'idle';
+            }
+        }
+        // Clean up expired git cache entries
+        this.gitCache.cleanup();
+    }
+    /**
+     * Get project ID from path
+     */
+    getProjectId(projectPath) {
+        // Use basename as ID, or full path hash if needed
+        const normalized = path.resolve(projectPath);
+        return path.basename(normalized) + '-' + this.hashStringId(normalized);
+    }
+    /**
+     * Create project info from path
+     */
+    async createProjectInfo(projectPath) {
+        const projectId = this.getProjectId(projectPath);
+        const name = path.basename(projectPath);
+        const info = {
+            id: projectId,
+            name,
+            path: projectPath,
+            type: 'directory',
+            activeAgents: 0,
+            totalActions: 0,
+            stats: {
+                totalEvents: 0,
+                successRate: 0,
+                avgRiskScore: 0,
+                topCategories: []
+            }
+        };
+        // Check if it's a git repo and get git info
+        try {
+            const gitDir = path.join(projectPath, '.git');
+            if (fs.existsSync(gitDir)) {
+                info.type = 'git';
+                await this.updateGitInfo(info, projectPath);
+            }
+        }
+        catch (err) {
+            // Not a git repo or error reading git info
+        }
+        return info;
+    }
+    /**
+     * Update git information for a project with caching and deduplication
+     * Uses in-memory cache with TTL to avoid repeated git calls
+     */
+    async updateGitInfo(project, projectPath) {
+        const cacheKey = `git:${projectPath}`;
+        // Check cache first
+        const cached = this.gitCache.get(cacheKey);
+        if (cached) {
+            this.applyGitInfo(project, cached);
+            return;
+        }
+        // Check if there's already a pending operation for this path
+        const pending = this.pendingGitOps.get(cacheKey);
+        if (pending) {
+            const gitInfo = await pending;
+            this.applyGitInfo(project, gitInfo);
+            return;
+        }
+        // Start new git fetch operation
+        const fetchPromise = this.fetchGitInfo(projectPath);
+        this.pendingGitOps.set(cacheKey, fetchPromise);
+        try {
+            const gitInfo = await fetchPromise;
+            // Cache the result
+            this.gitCache.set(cacheKey, gitInfo, this.gitCacheTTLMs);
+            // Apply to project
+            this.applyGitInfo(project, gitInfo);
+        }
+        finally {
+            // Clean up pending operation
+            this.pendingGitOps.delete(cacheKey);
+        }
+    }
+    /**
+     * Apply git info to a project
+     */
+    applyGitInfo(project, gitInfo) {
+        if (gitInfo.branch)
+            project.gitBranch = gitInfo.branch;
+        if (gitInfo.remote)
+            project.gitRemote = gitInfo.remote;
+        if (gitInfo.repo)
+            project.gitRepo = gitInfo.repo;
+        if (gitInfo.commit)
+            project.gitCommit = gitInfo.commit;
+    }
+    /**
+     * Fetch git information asynchronously with proper error handling
+     * Runs all git commands in parallel for better performance
+     */
+    async fetchGitInfo(projectPath) {
+        const timeout = 5000; // 5 second timeout for git commands
+        const gitInfo = {};
+        // Run all git commands in parallel
+        const [branchResult, remoteResult, commitResult] = await Promise.allSettled([
+            execAsync('git rev-parse --abbrev-ref HEAD', { cwd: projectPath, timeout }),
+            execAsync('git remote get-url origin', { cwd: projectPath, timeout }),
+            execAsync('git rev-parse --short HEAD', { cwd: projectPath, timeout })
+        ]);
+        // Process branch result
+        if (branchResult.status === 'fulfilled' && branchResult.value.stdout?.trim()) {
+            gitInfo.branch = branchResult.value.stdout.trim();
+        }
+        else if (branchResult.status === 'rejected') {
+            console.warn(`[ProjectTracker] Failed to get git branch for ${projectPath}:`, branchResult.reason.message);
+        }
+        // Process remote result
+        if (remoteResult.status === 'fulfilled' && remoteResult.value.stdout?.trim()) {
+            gitInfo.remote = remoteResult.value.stdout.trim();
+            // Extract repo name from remote URL
+            const match = gitInfo.remote.match(/([^/]+\/[^/]+?)(\.git)?$/);
+            if (match) {
+                gitInfo.repo = match[1].replace('.git', '');
+            }
+        }
+        else if (remoteResult.status === 'rejected') {
+            // Remote might not exist (not pushed yet) - this is normal, don't log unless unexpected error
+            const err = remoteResult.reason;
+            if (err.code !== 128) { // Git error code 128 = no remote
+                console.warn(`[ProjectTracker] Failed to get git remote for ${projectPath}:`, err.message);
+            }
+        }
+        // Process commit result
+        if (commitResult.status === 'fulfilled' && commitResult.value.stdout?.trim()) {
+            gitInfo.commit = commitResult.value.stdout.trim();
+        }
+        else if (commitResult.status === 'rejected') {
+            console.warn(`[ProjectTracker] Failed to get git commit for ${projectPath}:`, commitResult.reason.message);
+        }
+        return gitInfo;
+    }
+    /**
+     * Invalidate git cache for a specific project (useful after git operations)
+     */
+    invalidateGitCache(projectPath) {
+        const cacheKey = `git:${projectPath}`;
+        this.gitCache.delete(cacheKey);
+    }
+    /**
+     * Clear all git caches
+     */
+    clearGitCache() {
+        this.gitCache.clear();
+    }
+    /**
+     * Update project statistics
+     */
+    updateProjectStats(projectId) {
+        const project = this.projects.get(projectId);
+        if (!project)
+            return;
+        const activities = this.activityLog.get(projectId) || [];
+        project.stats.totalEvents = activities.length;
+        project.totalActions = activities.length;
+        if (activities.length > 0) {
+            // Last activity
+            project.lastActivity = activities[0].timestamp;
+            // Success rate
+            const successes = activities.filter(a => a.outcome === 'success').length;
+            project.stats.successRate = successes / activities.length;
+            // Average risk score
+            const withRisk = activities.filter(a => a.riskScore !== undefined);
+            if (withRisk.length > 0) {
+                const totalRisk = withRisk.reduce((sum, a) => sum + (a.riskScore || 0), 0);
+                project.stats.avgRiskScore = totalRisk / withRisk.length;
+            }
+            // Top categories
+            const categoryCounts = new Map();
+            for (const activity of activities) {
+                const count = categoryCounts.get(activity.category) || 0;
+                categoryCounts.set(activity.category, count + 1);
+            }
+            project.stats.topCategories = Array.from(categoryCounts.entries())
+                .map(([category, count]) => ({ category, count }))
+                .sort((a, b) => b.count - a.count)
+                .slice(0, 5);
+        }
+        // Update active agents count
+        project.activeAgents = this.getProjectAgents(projectId).filter(a => a.status === 'active').length;
+    }
+    /**
+     * Update agent information
+     */
+    updateAgentInfo(agentId, sessionId, projectPath) {
+        const projectId = this.getProjectId(projectPath);
+        let agent = this.agents.get(agentId);
+        if (!agent) {
+            agent = {
+                agentId,
+                sessionId,
+                currentProject: projectId,
+                startTime: new Date().toISOString(),
+                lastActivity: new Date().toISOString(),
+                actionsCount: 1,
+                status: 'active'
+            };
+        }
+        else {
+            agent.currentProject = projectId;
+            agent.lastActivity = new Date().toISOString();
+            agent.actionsCount++;
+            agent.status = 'active';
+        }
+        this.agents.set(agentId, agent);
+    }
+    /**
+     * Simple string hash for generating IDs
+     * Uses shared hashString utility with base36 encoding
+     */
+    hashStringId(str) {
+        return hashString(str, { base: 36, length: 8 });
+    }
+}
+export const projectTracker = new ProjectTracker();
+// Cleanup old data every hour
+setInterval(() => {
+    projectTracker.cleanup();
+}, 60 * 60 * 1000).unref();
+//# sourceMappingURL=ProjectTracker.js.map