shiva-code 0.8.11 → 0.8.13

package/dist/analytics-6WNUPA56.js

@@ -0,0 +1,337 @@
+import {
+  colors,
+  log
+} from "./chunk-5RLMQDLT.js";
+import {
+  getAnalyticsConfig,
+  getAnalyticsFilePath,
+  getAnalyticsSummaryPath,
+  hasShivaDir,
+  initShivaDir
+} from "./chunk-PMA6MGQW.js";
+import "./chunk-3RG5ZIWI.js";
+
+// src/services/project/analytics.ts
+import * as fs from "fs";
+import * as path from "path";
+function getMonthlyData(projectPath, yearMonth) {
+  const filePath = getAnalyticsFilePath(projectPath, yearMonth);
+  if (!fs.existsSync(filePath)) {
+    const month = yearMonth || (/* @__PURE__ */ new Date()).toISOString().slice(0, 7);
+    return {
+      month,
+      sessions: [],
+      totalDuration: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      toolUsage: {}
+    };
+  }
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    const month = yearMonth || (/* @__PURE__ */ new Date()).toISOString().slice(0, 7);
+    return {
+      month,
+      sessions: [],
+      totalDuration: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      toolUsage: {}
+    };
+  }
+}
+function saveMonthlyData(projectPath, data) {
+  if (!hasShivaDir(projectPath)) {
+    initShivaDir(projectPath);
+  }
+  const filePath = getAnalyticsFilePath(projectPath, data.month);
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
+}
+function getSummary(projectPath) {
+  const filePath = getAnalyticsSummaryPath(projectPath);
+  if (!fs.existsSync(filePath)) {
+    return {
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      allTimeSessions: 0,
+      allTimeDuration: 0,
+      allTimeInputTokens: 0,
+      allTimeOutputTokens: 0,
+      topTools: []
+    };
+  }
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      allTimeSessions: 0,
+      allTimeDuration: 0,
+      allTimeInputTokens: 0,
+      allTimeOutputTokens: 0,
+      topTools: []
+    };
+  }
+}
+function saveSummary(projectPath, summary) {
+  if (!hasShivaDir(projectPath)) {
+    initShivaDir(projectPath);
+  }
+  const filePath = getAnalyticsSummaryPath(projectPath);
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(filePath, JSON.stringify(summary, null, 2), "utf-8");
+}
+var ProjectAnalyticsService = class {
+  projectPath;
+  config;
+  constructor(projectPath, config) {
+    this.projectPath = projectPath;
+    this.config = config;
+  }
+  /**
+   * Check if analytics is enabled
+   */
+  isEnabled() {
+    return this.config.enabled;
+  }
+  /**
+   * Record a session
+   */
+  recordSession(session) {
+    if (!this.config.enabled) {
+      return;
+    }
+    const yearMonth = session.date.slice(0, 7);
+    const monthly = getMonthlyData(this.projectPath, yearMonth);
+    monthly.sessions.push(session);
+    monthly.totalDuration += session.duration;
+    monthly.totalInputTokens += session.inputTokens;
+    monthly.totalOutputTokens += session.outputTokens;
+    for (const [tool, count] of Object.entries(session.toolsUsed)) {
+      monthly.toolUsage[tool] = (monthly.toolUsage[tool] || 0) + count;
+    }
+    saveMonthlyData(this.projectPath, monthly);
+    this.updateSummary(session);
+  }
+  /**
+   * Update summary with new session data
+   */
+  updateSummary(session) {
+    const summary = getSummary(this.projectPath);
+    summary.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+    summary.allTimeSessions += 1;
+    summary.allTimeDuration += session.duration;
+    summary.allTimeInputTokens += session.inputTokens;
+    summary.allTimeOutputTokens += session.outputTokens;
+    const allToolUsage = {};
+    for (const [tool, count] of Object.entries(session.toolsUsed)) {
+      allToolUsage[tool] = (allToolUsage[tool] || 0) + count;
+    }
+    for (const { name, count } of summary.topTools) {
+      allToolUsage[name] = (allToolUsage[name] || 0) + count;
+    }
+    summary.topTools = Object.entries(allToolUsage).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([name, count]) => ({ name, count }));
+    saveSummary(this.projectPath, summary);
+  }
+  /**
+   * Get analytics for a period
+   */
+  getAnalytics(days = 30) {
+    const summary = getSummary(this.projectPath);
+    const cutoffDate = /* @__PURE__ */ new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - days);
+    const cutoff = cutoffDate.toISOString().split("T")[0];
+    const allSessions = [];
+    const toolUsage = {};
+    const sessionsPerDay = {};
+    const months = this.getMonthsInRange(cutoffDate, /* @__PURE__ */ new Date());
+    for (const month of months) {
+      const monthly = getMonthlyData(this.projectPath, month);
+      for (const session of monthly.sessions) {
+        if (session.date >= cutoff) {
+          allSessions.push(session);
+          sessionsPerDay[session.date] = (sessionsPerDay[session.date] || 0) + 1;
+          for (const [tool, count] of Object.entries(session.toolsUsed)) {
+            toolUsage[tool] = (toolUsage[tool] || 0) + count;
+          }
+        }
+      }
+    }
+    const totalDuration = allSessions.reduce((sum, s) => sum + s.duration, 0);
+    const totalInputTokens = allSessions.reduce((sum, s) => sum + s.inputTokens, 0);
+    const totalOutputTokens = allSessions.reduce((sum, s) => sum + s.outputTokens, 0);
+    const topTools = Object.entries(toolUsage).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([name, count]) => ({ name, count }));
+    const sessionsPerDayArray = Object.entries(sessionsPerDay).sort((a, b) => a[0].localeCompare(b[0])).map(([date, count]) => ({ date, count }));
+    return {
+      totalSessions: allSessions.length,
+      totalDuration,
+      totalInputTokens,
+      totalOutputTokens,
+      averageSessionDuration: allSessions.length > 0 ? Math.round(totalDuration / allSessions.length) : 0,
+      topTools,
+      sessionsPerDay: sessionsPerDayArray
+    };
+  }
+  /**
+   * Get list of months between two dates
+   */
+  getMonthsInRange(start, end) {
+    const months = [];
+    const current = new Date(start);
+    current.setDate(1);
+    while (current <= end) {
+      months.push(current.toISOString().slice(0, 7));
+      current.setMonth(current.getMonth() + 1);
+    }
+    return months;
+  }
+  /**
+   * Get all-time summary
+   */
+  getAllTimeSummary() {
+    return getSummary(this.projectPath);
+  }
+  /**
+   * Get analytics for a specific session by ID
+   * Searches through monthly files to find the session
+   */
+  getSessionAnalytics(sessionId) {
+    const endDate = /* @__PURE__ */ new Date();
+    const startDate = /* @__PURE__ */ new Date();
+    startDate.setFullYear(startDate.getFullYear() - 1);
+    const months = this.getMonthsInRange(startDate, endDate);
+    for (const month of months) {
+      const monthly = getMonthlyData(this.projectPath, month);
+      const session = monthly.sessions.find((s) => s.sessionId === sessionId);
+      if (session) {
+        return session;
+      }
+    }
+    return null;
+  }
+  /**
+   * Get aggregated analytics for sync (last session or summary)
+   */
+  getAnalyticsForSync() {
+    const summary = this.getAllTimeSummary();
+    return {
+      totalTokens: summary.allTimeInputTokens + summary.allTimeOutputTokens,
+      inputTokens: summary.allTimeInputTokens,
+      outputTokens: summary.allTimeOutputTokens,
+      durationMinutes: summary.allTimeDuration,
+      toolUsage: Object.fromEntries(summary.topTools.map((t) => [t.name, t.count]))
+    };
+  }
+  /**
+   * Clear old data based on retention policy
+   */
+  cleanupOldData() {
+    const config = getAnalyticsConfig(this.projectPath);
+    const cutoffDate = /* @__PURE__ */ new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - config.retentionDays);
+    const cutoffMonth = cutoffDate.toISOString().slice(0, 7);
+    const analyticsDir = path.dirname(getAnalyticsFilePath(this.projectPath));
+    if (!fs.existsSync(analyticsDir)) {
+      return 0;
+    }
+    const files = fs.readdirSync(analyticsDir);
+    let deletedCount = 0;
+    for (const file of files) {
+      if (file === "summary.json" || !file.endsWith(".json")) {
+        continue;
+      }
+      const month = file.replace(".json", "");
+      if (month < cutoffMonth) {
+        fs.unlinkSync(path.join(analyticsDir, file));
+        deletedCount++;
+      }
+    }
+    return deletedCount;
+  }
+  /**
+   * Export analytics data
+   */
+  exportData(format = "json") {
+    const analytics = this.getAnalytics(365);
+    const summary = this.getAllTimeSummary();
+    if (format === "json") {
+      return JSON.stringify({
+        summary,
+        periodAnalytics: analytics,
+        exportedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }, null, 2);
+    }
+    const lines = [];
+    lines.push("Type,Metric,Value");
+    lines.push(`Summary,Total Sessions,${summary.allTimeSessions}`);
+    lines.push(`Summary,Total Duration (min),${summary.allTimeDuration}`);
+    lines.push(`Summary,Total Input Tokens,${summary.allTimeInputTokens}`);
+    lines.push(`Summary,Total Output Tokens,${summary.allTimeOutputTokens}`);
+    for (const tool of summary.topTools) {
+      lines.push(`Tool,${tool.name},${tool.count}`);
+    }
+    for (const day of analytics.sessionsPerDay) {
+      lines.push(`Daily,${day.date},${day.count}`);
+    }
+    return lines.join("\n");
+  }
+};
+function createAnalyticsService(projectPath, config) {
+  return new ProjectAnalyticsService(projectPath, config);
+}
+function formatAnalytics(analytics) {
+  const lines = [];
+  lines.push(colors.orange.bold("Projekt-Analytics"));
+  lines.push(colors.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  lines.push("");
+  lines.push(`Sessions: ${analytics.totalSessions}`);
+  lines.push(`Gesamtdauer: ${formatDuration(analytics.totalDuration)}`);
+  lines.push(`Durchschnittl. Dauer: ${formatDuration(analytics.averageSessionDuration)}`);
+  lines.push("");
+  lines.push(`Input Tokens: ${analytics.totalInputTokens.toLocaleString()}`);
+  lines.push(`Output Tokens: ${analytics.totalOutputTokens.toLocaleString()}`);
+  lines.push("");
+  if (analytics.topTools.length > 0) {
+    lines.push("Top Tools:");
+    for (const tool of analytics.topTools.slice(0, 5)) {
+      lines.push(`  ${tool.name}: ${tool.count}`);
+    }
+  }
+  return lines;
+}
+function formatDuration(minutes) {
+  if (minutes < 60) {
+    return `${minutes} min`;
+  }
+  const hours = Math.floor(minutes / 60);
+  const mins = minutes % 60;
+  if (hours < 24) {
+    return mins > 0 ? `${hours}h ${mins}m` : `${hours}h`;
+  }
+  const days = Math.floor(hours / 24);
+  const remainingHours = hours % 24;
+  return `${days}d ${remainingHours}h`;
+}
+function displayAnalytics(analytics) {
+  const lines = formatAnalytics(analytics);
+  log.newline();
+  for (const line of lines) {
+    console.log(line);
+  }
+  log.newline();
+}
+export {
+  ProjectAnalyticsService,
+  createAnalyticsService,
+  displayAnalytics,
+  formatAnalytics
+};