@devflow-tools/server 0.12.5 → 0.12.6

package/dist/telemetry/telemetry.service.js

@@ -1,663 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-import { Inject, Injectable, NotFoundException, Optional } from "@nestjs/common";
-import { TelemetryEngine } from "@devflow-tools/telemetry";
-import { DevFlowDatabase } from "@devflow-tools/database";
-import { ErrorCode } from "../common/error-codes.js";
-import { AutoChecker } from './auto-checker.js';
-let TelemetryService = class TelemetryService {
-    constructor(database) {
-        this.engine = new TelemetryEngine(); // Legacy in-memory store — real data goes through this.db
-        this.db = database ?? null;
-    }
-    async recordEvent(event) {
-        if (!this.db)
-            return;
-        this.db.insertEvent?.({
-            runId: event.runId,
-            kind: event.kind,
-            timestamp: event.timestamp,
-            duration: event.duration,
-            toolName: event.data?.toolName,
-            pluginName: event.data?.mcpToolName,
-            metadata: event.data,
-        });
-    }
-    // ---- Sessions ----
-    async createSession(params) {
-        if (!this.db)
-            return;
-        this.db.insertSession({
-            id: params.id,
-            projectRoot: params.projectRoot,
-            label: params.label,
-            startedAt: params.startedAt,
-        });
-    }
-    async getSession(id) {
-        if (!this.db)
-            throw new NotFoundException({ error: { code: ErrorCode.RUN_NOT_FOUND, message: `Session "${id}" not found`, details: {} } });
-        const session = this.db.getSession(id);
-        if (!session)
-            throw new NotFoundException({ error: { code: ErrorCode.RUN_NOT_FOUND, message: `Session "${id}" not found`, details: {} } });
-        return session;
-    }
-    async listSessions(limit, offset, projectRoot) {
-        if (!this.db)
-            return [];
-        return this.db.listSessions(limit, offset, projectRoot);
-    }
-    async getSessionEvents(sessionId) {
-        if (!this.db)
-            return [];
-        return this.db.listToolCallEventsBySession?.(sessionId) ?? [];
-    }
-    async closeSession(id, finishedAt) {
-        if (!this.db)
-            return;
-        this.db.closeSession(id, finishedAt);
-    }
-    async createSkillExecution(params) {
-        if (!this.db)
-            return;
-        this.db.insertSkillExecution({
-            executionId: params.executionId,
-            sessionId: params.sessionId,
-            skillName: params.skillName,
-            startedAt: params.startedAt,
-            status: 'running',
-        });
-    }
-    // ---- Runs (now backed by sessions) ----
-    async listRuns(limit, offset, source) {
-        if (this.db) {
-            try {
-                const sessions = this.db.listSessions(limit, offset);
-                return sessions.map((s) => ({
-                    id: s.id,
-                    agent: "claude-code",
-                    mode: "hook",
-                    source: "hook",
-                    status: s.status,
-                    startedAt: s.startedAt,
-                    totalToolCalls: s.totalToolCalls,
-                    mcpToolCalls: s.mcpToolCalls,
-                    mcpComplianceRate: s.mcpToolCalls > 0 ? Math.round(s.mcpToolCalls / s.totalToolCalls * 100) / 100 : 0,
-                }));
-            }
-            catch { }
-        }
-        return [];
-    }
-    async getRun(id) {
-        // Try session first, then skill execution, then engine
-        if (this.db) {
-            try {
-                const s = this.db.getSession(id);
-                if (s) {
-                    return {
-                        meta: { runId: s.id, agent: "claude-code", mode: "hook", source: "hook" },
-                        status: s.status,
-                        startedAt: s.startedAt,
-                        finishedAt: s.finishedAt,
-                        totalToolCalls: s.totalToolCalls,
-                        mcpToolCalls: s.mcpToolCalls,
-                        steps: [],
-                    };
-                }
-                const exec = this.db.getSkillExecution(id);
-                if (exec) {
-                    return {
-                        meta: { runId: exec.executionId, agent: "claude-code", mode: "hook", source: "hook" },
-                        status: exec.status,
-                        startedAt: exec.startedAt,
-                        finishedAt: exec.finishedAt,
-                        skillName: exec.skillName,
-                        totalToolCalls: exec.totalToolCalls,
-                        mcpToolCalls: exec.mcpToolCalls,
-                        mcpComplianceRate: exec.mcpComplianceRate,
-                        steps: [],
-                    };
-                }
-            }
-            catch { }
-        }
-        const run = this.engine.runs.get(id);
-        if (run)
-            return run;
-        throw new NotFoundException({ error: { code: ErrorCode.RUN_NOT_FOUND, message: `Run "${id}" not found`, details: {} } });
-    }
-    async getTimeline(from, to) {
-        if (!this.db)
-            return [];
-        try {
-            const sessions = this.db.listSessions(500, 0);
-            return sessions
-                .filter((s) => {
-                if (from && s.startedAt < Number(from))
-                    return false;
-                if (to && s.startedAt > Number(to))
-                    return false;
-                return true;
-            })
-                .map((s) => ({
-                runId: s.id,
-                stepId: s.id,
-                type: "session",
-                duration: s.durationMs,
-                timestamp: s.startedAt,
-            }));
-        }
-        catch {
-            return [];
-        }
-    }
-    async getRunEvents(runId) {
-        // Try session events first
-        if (this.db) {
-            try {
-                const events = this.db.listToolCallEventsBySession(runId);
-                if (events && events.length > 0)
-                    return events;
-                const execEvents = this.db.listToolCallEvents(runId);
-                if (execEvents && execEvents.length > 0)
-                    return execEvents;
-            }
-            catch { }
-        }
-        const engineEvents = await this.engine.listEvents(runId);
-        return engineEvents ?? [];
-    }
-    async getRunStats(runId) {
-        if (this.db) {
-            try {
-                const events = this.db.listToolCallEventsBySession(runId) ?? this.db.listToolCallEvents(runId) ?? [];
-                if (events.length > 0) {
-                    return {
-                        totalEvents: events.length,
-                        llmCalls: 0,
-                        totalTokens: 0,
-                        toolUses: events.length,
-                        fileReads: 0,
-                        fileWrites: 0,
-                        bashCommands: 0,
-                        errors: events.filter((e) => e.error).length,
-                        totalDuration: 0,
-                        mcpToolCalls: events.filter((e) => e.isMcpTool).length,
-                        directToolCalls: events.filter((e) => !e.isMcpTool).length,
-                        mcpComplianceRate: events.length > 0
-                            ? events.filter((e) => e.isMcpTool).length / events.length : 0,
-                    };
-                }
-            }
-            catch { }
-        }
-        return this.engine.getRunStats(runId);
-    }
-    async endRun(runId, result) {
-        await this.engine.endRun(runId, result);
-    }
-    // ---- Telemetry Stats (from sessions + tool_call_events) ----
-    async getStats(periodDays = 7) {
-        if (!this.db)
-            return this.emptyStats();
-        const now = Date.now();
-        const cutoff = now - periodDays * 24 * 60 * 60 * 1000;
-        try {
-            const sessions = this.db.listSessions(1000, 0);
-            const periodSessions = sessions.filter((s) => s.startedAt >= cutoff);
-            const days = {};
-            let totalToolCalls = 0;
-            for (const s of periodSessions) {
-                const day = new Date(s.startedAt).toISOString().slice(0, 10);
-                if (!days[day])
-                    days[day] = { runs: 0 };
-                days[day].runs++;
-                totalToolCalls += s.totalToolCalls ?? 0;
-            }
-            // Aggregate from tool_call_events for period sessions
-            const sessionIds = periodSessions.map((s) => s.id);
-            const eventsBySession = this.db.listToolCallEventsBySessions?.(sessionIds) ?? {};
-            let totalTokens = 0;
-            let totalLlmCalls = 0;
-            const workflowCounts = {};
-            const pluginCounts = {};
-            for (const [, events] of Object.entries(eventsBySession)) {
-                for (const e of events) {
-                    totalTokens += e.tokensUsed ?? 0;
-                    if (e.kind === 'llm_call')
-                        totalLlmCalls++;
-                    // Derive workflow from tool name (e.g., react_diagnose_bug → react)
-                    const wf = e.toolName?.split('_')?.[1];
-                    if (wf) {
-                        workflowCounts[wf] = (workflowCounts[wf] ?? 0) + 1;
-                    }
-                    // Derive plugin from mcpToolName prefix
-                    const plugin = e.mcpToolName?.split('_')?.[0];
-                    if (plugin) {
-                        pluginCounts[plugin] = (pluginCounts[plugin] ?? 0) + 1;
-                    }
-                }
-            }
-            return {
-                period: {
-                    from: new Date(cutoff).toISOString().slice(0, 10),
-                    to: new Date(now).toISOString().slice(0, 10),
-                },
-                summary: {
-                    totalRuns: periodSessions.length,
-                    completedRuns: periodSessions.filter((s) => s.status === 'completed').length,
-                    failedRuns: periodSessions.filter((s) => s.status === 'failed').length,
-                    totalTokens,
-                    totalLlmCalls,
-                    totalToolUses: totalToolCalls,
-                    avgRunDuration: periodSessions.length > 0
-                        ? Math.round(periodSessions.reduce((sum, s) => sum + (s.durationMs ?? 0), 0) / periodSessions.length)
-                        : 0,
-                },
-                byDay: Object.entries(days)
-                    .map(([date, d]) => ({ date, tokens: 0, ...d }))
-                    .sort((a, b) => a.date.localeCompare(b.date)),
-                byWorkflow: Object.entries(workflowCounts)
-                    .map(([name, count]) => ({ workflow: name, count }))
-                    .sort((a, b) => b.count - a.count),
-                byPlugin: Object.entries(pluginCounts)
-                    .map(([name, count]) => ({ plugin: name, count }))
-                    .sort((a, b) => b.count - a.count),
-            };
-        }
-        catch {
-            return this.emptyStats();
-        }
-    }
-    emptyStats() {
-        return {
-            period: { from: '', to: '' },
-            summary: { totalRuns: 0, completedRuns: 0, failedRuns: 0, totalTokens: 0, totalLlmCalls: 0, totalToolUses: 0, avgRunDuration: 0 },
-            byDay: [],
-            byWorkflow: [],
-            byPlugin: [],
-        };
-    }
-    // ---- ROI Summary (from sessions + tool_call_events) ----
-    async getRoiSummary(periodDays = 7) {
-        if (!this.db)
-            return this.emptyRoiSummary();
-        const now = Date.now();
-        const cutoff = now - periodDays * 24 * 60 * 60 * 1000;
-        try {
-            const sessions = this.db.listSessions(1000, 0);
-            const periodSessions = sessions.filter((s) => s.startedAt >= cutoff);
-            const totalRuns = periodSessions.length;
-            const completedRuns = periodSessions.filter((s) => s.status === 'completed').length;
-            const failedRuns = periodSessions.filter((s) => s.status === 'failed').length;
-            const avgDuration = totalRuns > 0
-                ? Math.round(periodSessions.reduce((sum, s) => sum + (s.durationMs ?? 0), 0) / totalRuns)
-                : 0;
-            // Daily breakdown
-            const days = {};
-            for (const s of periodSessions) {
-                const day = new Date(s.startedAt).toISOString().slice(0, 10);
-                if (!days[day])
-                    days[day] = { runs: 0, failures: 0 };
-                days[day].runs++;
-                if (s.status === 'failed')
-                    days[day].failures++;
-            }
-            // Batch fetch all events for all period sessions
-            const allEventGroups = this.db.listToolCallEventsBySessions(periodSessions.map((s) => s.id));
-            // Failure breakdown from tool_call_events errors
-            const failureBreakdown = {
-                tool_error: 0,
-                mcp_unavailable: 0,
-                unknown: 0,
-            };
-            const byPlugin = {};
-            for (const s of periodSessions) {
-                const events = (allEventGroups[s.id] ?? []);
-                for (const e of events) {
-                    if (e.error) {
-                        const err = e.error.toLowerCase();
-                        if (err.includes('mcp') || err.includes('unavailable') || err.includes('not found'))
-                            failureBreakdown.mcp_unavailable++;
-                        else if (err.includes('tool') || err.includes('command') || err.includes('error'))
-                            failureBreakdown.tool_error++;
-                        else
-                            failureBreakdown.unknown++;
-                    }
-                    if (e.mcpToolName) {
-                        const prefix = e.mcpToolName.split('_')[0];
-                        if (prefix)
-                            byPlugin[prefix] = (byPlugin[prefix] ?? 0) + 1;
-                    }
-                }
-            }
-            return {
-                period: {
-                    from: new Date(cutoff).toISOString().slice(0, 10),
-                    to: new Date(now).toISOString().slice(0, 10),
-                },
-                overview: {
-                    totalRuns,
-                    completedRuns,
-                    failedRuns,
-                    avgDuration,
-                    firstPassSuccessRate: totalRuns > 0 ? Math.round((completedRuns / totalRuns) * 10000) / 100 : 0,
-                },
-                efficiency: {
-                    avgTimePerTask: avgDuration,
-                },
-                failures: {
-                    total: failedRuns,
-                    breakdown: failureBreakdown,
-                },
-                workflows: [],
-                plugins: Object.entries(byPlugin).map(([name, runs]) => {
-                    const pluginSessions = periodSessions.filter((s) => {
-                        const evts = (allEventGroups[s.id] ?? []);
-                        return evts.some((e) => e.mcpToolName?.startsWith(name + '_'));
-                    });
-                    const completed = pluginSessions.filter((s) => s.status === 'completed').length;
-                    const successRate = pluginSessions.length > 0
-                        ? Math.round((completed / pluginSessions.length) * 10000) / 100
-                        : 0;
-                    return { name, runs, successRate };
-                }),
-                byDay: Object.entries(days)
-                    .map(([date, d]) => ({ date, ...d, tokens: 0 }))
-                    .sort((a, b) => a.date.localeCompare(b.date)),
-            };
-        }
-        catch {
-            return this.emptyRoiSummary();
-        }
-    }
-    emptyRoiSummary() {
-        return {
-            period: { from: '', to: '' },
-            overview: { totalRuns: 0, completedRuns: 0, failedRuns: 0, avgDuration: 0, firstPassSuccessRate: 0 },
-            efficiency: { avgTimePerTask: 0 },
-            failures: { total: 0, breakdown: { tool_error: 0, mcp_unavailable: 0, unknown: 0 } },
-            workflows: [],
-            plugins: [],
-            byDay: [],
-        };
-    }
-    // ---- Skill Execution Tracking ----
-    async recordExecutionStart(params) {
-        if (!this.db)
-            return;
-        this.db.insertSkillExecution({
-            executionId: params.executionId,
-            sessionId: params.sessionId,
-            skillName: params.skillName,
-            startedAt: params.startedAt,
-            status: 'running',
-        });
-    }
-    async recordToolCall(event) {
-        if (!this.db)
-            return;
-        try {
-            this.db.insertToolCallEvent({
-                eventId: event.eventId,
-                executionId: event.executionId,
-                sessionId: event.sessionId,
-                timestamp: event.timestamp,
-                toolName: event.toolName,
-                toolType: event.toolType,
-                isMcpTool: event.isMcpTool,
-                mcpToolName: event.mcpToolName,
-                mcpEnforced: event.mcpEnforced,
-                mcpFallback: event.mcpFallback,
-                kind: event.kind ?? 'tool_use',
-                input: event.input,
-                duration: event.duration,
-                parentToolCallId: event.parentToolCallId,
-                subagentId: event.subagentId,
-                error: event.error,
-                blocked: event.blocked,
-                blockReason: event.blockReason,
-            });
-        }
-        catch { }
-    }
-    async updateToolCallOutput(eventId, output, completedAt, duration) {
-        if (!this.db)
-            return;
-        try {
-            this.db.updateToolCallEvent(eventId, { output: JSON.stringify(output), duration });
-        }
-        catch { }
-    }
-    async recordExecutionComplete(params) {
-        if (!this.db)
-            return;
-        this.db.updateSkillExecution(params.executionId, {
-            status: params.status,
-            finishedAt: params.finishedAt,
-            totalDuration: params.summary.totalDuration,
-            mcpComplianceRate: params.summary.mcpComplianceRate,
-            totalToolCalls: params.summary.totalToolCalls,
-            mcpToolCalls: params.summary.mcpToolCalls,
-            directToolCalls: params.summary.directToolCalls,
-            subagentCount: params.summary.subagentCount,
-        });
-    }
-    async getExecutions(limit, skillName) {
-        if (!this.db)
-            return [];
-        return this.db.listSkillExecutions(limit, skillName);
-    }
-    async getExecutionEvents(executionId) {
-        if (!this.db)
-            return [];
-        return this.db.listToolCallEvents(executionId);
-    }
-    async getMcpCompliance() {
-        if (!this.db)
-            return { overall: 0, bySkill: {}, missedTools: [] };
-        return this.db.getMcpCompliance();
-    }
-    // ---- Failure classification (unchanged) ----
-    async classifyFailure(runId) {
-        const run = await this.getRun(runId).catch(() => null);
-        if (!run || run.status !== "failed")
-            return {};
-        const failedStep = run.steps?.find((s) => s.status === "failed");
-        if (!failedStep)
-            return {};
-        const error = failedStep.error?.toLowerCase() ?? "";
-        if (error.includes("context") || error.includes("insufficient")) {
-            return {
-                failureCategory: "context_insufficient",
-                failureReason: "Context provided was insufficient for the task",
-                suggestedActions: [
-                    { action: "Supplement task context", priority: "high" },
-                    { action: "View graph roots", priority: "medium" },
-                    { action: "Add related memory", priority: "medium" },
-                ],
-            };
-        }
-        if (error.includes("knowledge") || error.includes("docs")) {
-            return {
-                failureCategory: "knowledge_missing",
-                failureReason: "Required knowledge was not available",
-                suggestedActions: [
-                    { action: "Sync knowledge source", priority: "high" },
-                    { action: "Add docs source", priority: "medium" },
-                ],
-            };
-        }
-        if (error.includes("workflow") || error.includes("step")) {
-            return {
-                failureCategory: "workflow_design_issue",
-                failureReason: "Workflow design issue detected",
-                suggestedActions: [
-                    { action: "Adjust specific step", priority: "high" },
-                    { action: "Split workflow", priority: "medium" },
-                ],
-            };
-        }
-        if (error.includes("tool") || error.includes("connection")) {
-            return {
-                failureCategory: "tool_error",
-                failureReason: "Tool execution error",
-                suggestedActions: [
-                    { action: "Check tool connectivity", priority: "high" },
-                    { action: "Retry or fallback", priority: "medium" },
-                ],
-            };
-        }
-        return {
-            failureCategory: "agent_override",
-            failureReason: "Agent override detected",
-            suggestedActions: [
-                { action: "Enable/strengthen enforcer", priority: "high" },
-            ],
-        };
-    }
-    async cleanup(olderThanDays) {
-        if (!this.db)
-            return 0;
-        try {
-            this.db.cleanupStaleRecords?.();
-        }
-        catch { }
-        // Also clean up legacy engine runs
-        const runs = this.engine.runs;
-        const cutoff = Date.now() - olderThanDays * 24 * 60 * 60 * 1000;
-        let removed = 0;
-        for (const [id, run] of runs) {
-            if (run.startedAt && run.startedAt < cutoff) {
-                runs.delete(id);
-                removed++;
-            }
-        }
-        return removed;
-    }
-    // @Interval(5 * 60 * 1000) — uncomment when @nestjs/schedule is available
-    async cleanupStaleRecords() {
-        if (!this.db)
-            return;
-        try {
-            this.db.cleanupStaleRecords?.();
-        }
-        catch { /* best-effort */ }
-    }
-    // ---- Stub methods for external callers that reference old API ----
-    // ---- Tool Metrics ----
-    async recordToolMetric(metric) {
-        if (!this.db)
-            return;
-        this.db.insertToolMetric({ ...metric, createdAt: Date.now() });
-    }
-    async getToolMetrics(sessionId, toolName, limit = 100, offset = 0) {
-        if (!this.db)
-            return [];
-        return this.db.getToolMetrics(sessionId, toolName, limit, offset);
-    }
-    async getToolMetricsSummary(days = 7) {
-        if (!this.db)
-            return [];
-        return this.db.getToolMetricsSummary(days);
-    }
-    // ---- Accuracy Queries ----
-    async recordAccuracyQuery(params) {
-        if (!this.db)
-            return;
-        this.db.insertAccuracyQuery({ ...params, createdAt: Date.now() });
-    }
-    async getAccuracyQueries(options) {
-        if (!this.db)
-            return [];
-        return this.db.getAccuracyQueries(options);
-    }
-    async updateAccuracyFeedback(id, feedback) {
-        if (!this.db)
-            return;
-        this.db.updateAccuracyFeedback(id, feedback);
-    }
-    async getAccuracyStats(engine, since) {
-        if (!this.db)
-            return { totalQueries: 0, annotatedQueries: 0, hitRate: null };
-        return this.db.getAccuracyStats(engine, since);
-    }
-    // ---- Auto Checker ----
-    async runAutoCheck() {
-        if (!this.db)
-            return [];
-        const checker = new AutoChecker(this.db);
-        return checker.checkAll();
-    }
-    // ---- Stub methods ----
-    async getFeedbackStats(_projectRoot, _periodDays) {
-        return { total: 0, hits: 0, partials: 0, misses: 0, hitRate: 0, partialRate: 0, missRate: 0 };
-    }
-    async getOpsRoiSummary() {
-        return {
-            period: "all-time",
-            totalRuns: 0,
-            successfulRuns: 0,
-            successRate: 0,
-            avgDuration: 0,
-            trend: "stable",
-        };
-    }
-    async getExperimentalRoiSummary() {
-        return {
-            totalScenarios: 0,
-            avgTimeSavedRate: null,
-            avgTokenReductionRate: null,
-            avgFirstPassLift: null,
-            avgReworkReductionRate: null,
-            conclusion: "No experimental data available yet",
-        };
-    }
-    async getPluginEffectiveness(pluginName, _projectRoot) {
-        if (!this.db)
-            return { name: pluginName, totalRuns: 0, successRate: 0, lastUsedAt: null };
-        const sessions = this.db.listSessions(1000, 0);
-        let useCount = 0;
-        for (const s of sessions) {
-            const events = this.db.listToolCallEventsBySession(s.id);
-            for (const e of events) {
-                if (e.mcpToolName?.startsWith(pluginName + '_'))
-                    useCount++;
-            }
-        }
-        return {
-            name: pluginName,
-            totalRuns: useCount,
-            successRate: 0,
-            lastUsedAt: null,
-        };
-    }
-    async getPluginUsageStats(pluginName) {
-        const eff = await this.getPluginEffectiveness(pluginName);
-        return {
-            activeProjects: 0,
-            totalRuns: eff.totalRuns,
-            successfulRuns: 0,
-            lastUsedAt: eff.lastUsedAt ?? undefined,
-        };
-    }
-};
-TelemetryService = __decorate([
-    Injectable(),
-    __param(0, Optional()),
-    __param(0, Inject('DATABASE')),
-    __metadata("design:paramtypes", [DevFlowDatabase])
-], TelemetryService);
-export { TelemetryService };
-//# sourceMappingURL=telemetry.service.js.map