@autumnsgrove/groveengine 0.6.2 → 0.6.3

package/dist/server/logger.js

@@ -2,251 +2,200 @@
  * Server-side logging utility with in-memory circular buffers
  * Supports real-time log streaming to admin console
  */
-
 // Circular buffer implementation
 class CircularBuffer {
-  constructor(maxSize = 1000) {
-    this.maxSize = maxSize;
-    this.buffer = [];
-  }
-
-  push(item) {
-    this.buffer.push(item);
-    if (this.buffer.length > this.maxSize) {
-      this.buffer.shift(); // Remove oldest item
+    maxSize;
+    buffer;
+    constructor(maxSize = 1000) {
+        this.maxSize = maxSize;
+        this.buffer = [];
+    }
+    push(item) {
+        this.buffer.push(item);
+        if (this.buffer.length > this.maxSize) {
+            this.buffer.shift(); // Remove oldest item
+        }
+    }
+    getAll() {
+        return [...this.buffer]; // Return copy to prevent external mutations
+    }
+    getSince(timestamp) {
+        return this.buffer.filter((log) => new Date(log.timestamp) > new Date(timestamp));
+    }
+    clear() {
+        this.buffer = [];
+    }
+    get length() {
+        return this.buffer.length;
     }
-  }
-
-  getAll() {
-    return [...this.buffer]; // Return copy to prevent external mutations
-  }
-
-  getSince(timestamp) {
-    return this.buffer.filter(
-      (log) => new Date(log.timestamp) > new Date(timestamp),
-    );
-  }
-
-  clear() {
-    this.buffer = [];
-  }
-
-  get length() {
-    return this.buffer.length;
-  }
 }
-
 // Log buffers for each category (module-level, persists across requests in same worker)
 const logBuffers = {
-  api: new CircularBuffer(1000),
-  github: new CircularBuffer(500),
-  errors: new CircularBuffer(500),
-  cache: new CircularBuffer(1000),
+    api: new CircularBuffer(1000),
+    github: new CircularBuffer(500),
+    errors: new CircularBuffer(500),
+    cache: new CircularBuffer(1000),
 };
-
 // Subscribers for SSE streaming
 const subscribers = new Set();
-
 /**
  * Create a log entry with consistent format
  */
 function createLogEntry(level, category, message, metadata = {}) {
-  return {
-    id: `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-    timestamp: new Date().toISOString(),
-    level, // 'info' | 'warn' | 'error' | 'success'
-    category, // 'api' | 'github' | 'errors' | 'cache'
-    message,
-    metadata,
-  };
+    return {
+        id: `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+        timestamp: new Date().toISOString(),
+        level,
+        category,
+        message,
+        metadata,
+    };
 }
-
 /**
  * Broadcast log to all SSE subscribers
  */
 function broadcast(log) {
-  subscribers.forEach((subscriber) => {
-    try {
-      subscriber(log);
-    } catch (error) {
-      console.error("[Logger] Failed to broadcast to subscriber:", error);
-    }
-  });
+    subscribers.forEach((subscriber) => {
+        try {
+            subscriber(log);
+        }
+        catch (error) {
+            console.error("[Logger] Failed to broadcast to subscriber:", error);
+        }
+    });
 }
-
 /**
  * Log API activity (requests, responses, timing)
  */
 export function logAPI(endpoint, method, status, metadata = {}) {
-  const level =
-    status >= 500
-      ? "error"
-      : status >= 400
-        ? "warn"
-        : status >= 200
-          ? "success"
-          : "info";
-  const log = createLogEntry(
-    level,
-    "api",
-    `${method} ${endpoint} → ${status}`,
-    {
-      endpoint,
-      method,
-      status,
-      ...metadata,
-    },
-  );
-
-  logBuffers.api.push(log);
-  broadcast(log);
-
-  // Also log to console in development
-  if (metadata.duration) {
-    console.log(
-      `[API] ${method} ${endpoint} ${status} (${metadata.duration}ms)`,
-    );
-  }
+    const level = status >= 500
+        ? "error"
+        : status >= 400
+            ? "warn"
+            : status >= 200
+                ? "success"
+                : "info";
+    const log = createLogEntry(level, "api", `${method} ${endpoint} → ${status}`, {
+        endpoint,
+        method,
+        status,
+        ...metadata,
+    });
+    logBuffers.api.push(log);
+    broadcast(log);
+    // Also log to console in development
+    if (metadata.duration) {
+        console.log(`[API] ${method} ${endpoint} ${status} (${metadata.duration}ms)`);
+    }
 }
-
 /**
  * Log GitHub API operations (rate limits, queries, errors)
  */
 export function logGitHub(operation, metadata = {}) {
-  const level = metadata.error ? "error" : metadata.warning ? "warn" : "info";
-  const log = createLogEntry(level, "github", operation, metadata);
-
-  logBuffers.github.push(log);
-  broadcast(log);
-
-  console.log(
-    `[GitHub] ${operation}`,
-    metadata.rateLimit
-      ? `(${metadata.rateLimit.remaining}/${metadata.rateLimit.limit} remaining)`
-      : "",
-  );
+    const level = metadata.error ? "error" : metadata.warning ? "warn" : "info";
+    const log = createLogEntry(level, "github", operation, metadata);
+    logBuffers.github.push(log);
+    broadcast(log);
+    console.log(`[GitHub] ${operation}`, metadata.rateLimit
+        ? `(${metadata.rateLimit.remaining}/${metadata.rateLimit.limit} remaining)`
+        : "");
 }
-
 /**
  * Log errors (exceptions, failed operations, validation errors)
  */
 export function logError(message, error = null, metadata = {}) {
-  const log = createLogEntry("error", "errors", message, {
-    error: error
-      ? {
-          message: error.message,
-          stack: error.stack,
-          name: error.name,
-        }
-      : null,
-    ...metadata,
-  });
-
-  logBuffers.errors.push(log);
-  broadcast(log);
-
-  console.error(`[Error] ${message}`, error || "");
+    const log = createLogEntry("error", "errors", message, {
+        error: error
+            ? {
+                message: error.message,
+                stack: error.stack,
+                name: error.name,
+            }
+            : null,
+        ...metadata,
+    });
+    logBuffers.errors.push(log);
+    broadcast(log);
+    console.error(`[Error] ${message}`, error || "");
 }
-
 /**
  * Log cache operations (KV get/set, hits/misses)
  */
 export function logCache(operation, key, metadata = {}) {
-  const level = metadata.error ? "error" : "info";
-  const log = createLogEntry(
-    level,
-    "cache",
-    `${operation.toUpperCase()} ${key}`,
-    {
-      operation, // 'get', 'set', 'delete'
-      key,
-      ...metadata,
-    },
-  );
-
-  logBuffers.cache.push(log);
-  broadcast(log);
+    const level = metadata.error ? "error" : "info";
+    const log = createLogEntry(level, "cache", `${operation.toUpperCase()} ${key}`, {
+        operation,
+        key,
+        ...metadata,
+    });
+    logBuffers.cache.push(log);
+    broadcast(log);
 }
-
 /**
  * Get logs from a specific category
  */
 export function getLogs(category, since = null) {
-  if (!logBuffers[category]) {
-    return [];
-  }
-
-  if (since) {
-    return logBuffers[category].getSince(since);
-  }
-
-  return logBuffers[category].getAll();
+    if (!logBuffers[category]) {
+        return [];
+    }
+    if (since) {
+        return logBuffers[category].getSince(since);
+    }
+    return logBuffers[category].getAll();
 }
-
 /**
  * Get all logs across all categories
  */
 export function getAllLogs(since = null) {
-  const allLogs = [];
-
-  for (const category of Object.keys(logBuffers)) {
-    const logs = since
-      ? logBuffers[category].getSince(since)
-      : logBuffers[category].getAll();
-    allLogs.push(...logs);
-  }
-
-  // Sort by timestamp (newest first)
-  return allLogs.sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
+    const allLogs = [];
+    for (const category of Object.keys(logBuffers)) {
+        const logs = since
+            ? logBuffers[category].getSince(since)
+            : logBuffers[category].getAll();
+        allLogs.push(...logs);
+    }
+    // Sort by timestamp (newest first)
+    return allLogs.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
 }
-
 /**
  * Get log statistics
  */
 export function getLogStats() {
-  return {
-    api: {
-      total: logBuffers.api.length,
-      recent: logBuffers.api.getSince(
-        new Date(Date.now() - 60000).toISOString(),
-      ).length, // Last minute
-    },
-    github: {
-      total: logBuffers.github.length,
-      recent: logBuffers.github.getSince(
-        new Date(Date.now() - 60000).toISOString(),
-      ).length,
-    },
-    errors: {
-      total: logBuffers.errors.length,
-      recent: logBuffers.errors.getSince(
-        new Date(Date.now() - 60000).toISOString(),
-      ).length,
-    },
-    cache: {
-      total: logBuffers.cache.length,
-      recent: logBuffers.cache.getSince(
-        new Date(Date.now() - 60000).toISOString(),
-      ).length,
-    },
-  };
+    const oneMinuteAgo = new Date(Date.now() - 60000).toISOString();
+    return {
+        api: {
+            total: logBuffers.api.length,
+            recent: logBuffers.api.getSince(oneMinuteAgo).length,
+        },
+        github: {
+            total: logBuffers.github.length,
+            recent: logBuffers.github.getSince(oneMinuteAgo).length,
+        },
+        errors: {
+            total: logBuffers.errors.length,
+            recent: logBuffers.errors.getSince(oneMinuteAgo).length,
+        },
+        cache: {
+            total: logBuffers.cache.length,
+            recent: logBuffers.cache.getSince(oneMinuteAgo).length,
+        },
+    };
 }
-
 /**
  * Subscribe to log events (for SSE streaming)
  */
 export function subscribe(callback) {
-  subscribers.add(callback);
-  return () => subscribers.delete(callback);
+    subscribers.add(callback);
+    return () => subscribers.delete(callback);
 }
-
 /**
  * Clear logs for a specific category or all categories
  */
 export function clearLogs(category = null) {
-  if (category && logBuffers[category]) {
-    logBuffers[category].clear();
-  } else if (!category) {
-    Object.values(logBuffers).forEach((buffer) => buffer.clear());
-  }
+    if (category && logBuffers[category]) {
+        logBuffers[category].clear();
+    }
+    else if (!category) {
+        Object.values(logBuffers).forEach((buffer) => buffer.clear());
+    }
 }

package/dist/server/services/cache.js

@@ -1,13 +1,4 @@
-/**
- * Cache Service - KV Key-Value Store Abstraction
- *
- * Provides typed caching operations with:
- * - Automatic JSON serialization/deserialization
- * - TTL management with sensible defaults
- * - Namespace prefixing to avoid key collisions
- * - Compute-if-missing pattern (getOrSet)
- * - Specific error types for debugging
- */
+/// <reference types="@cloudflare/workers-types" />
 // ============================================================================
 // Errors
 // ============================================================================

package/dist/ui/components/charts/ActivityOverview.svelte

@@ -9,16 +9,26 @@
   import Sparkline from './Sparkline.svelte';
 
   /**
-   * @type {{ activity_date: string, commit_count: number }[]}
+   * @typedef {Object} ActivityData
+   * @property {string} activity_date
+   * @property {number} commit_count
    */
+
+  /**
+   * @typedef {Object} LocData
+   * @property {number} additions
+   * @property {number} deletions
+   */
+
   let {
-    data = [],
-    locData = { additions: 0, deletions: 0 },  // LOC from separate DB fetch
+    data = /** @type {ActivityData[]} */ ([]),
+    locData = /** @type {LocData} */ ({ additions: 0, deletions: 0 }),
     days = 14
   } = $props();
 
   // Format date as YYYY-MM-DD in local timezone (not UTC!)
   // This matches how GitHub attributes contributions to user's timezone
+  /** @param {Date} date */
   function formatDateKey(date) {
     const year = date.getFullYear();
     const month = String(date.getMonth() + 1).padStart(2, '0');
@@ -61,6 +71,7 @@
   const peakCommits = $derived(Math.max(...filledData().map(d => d.commits), 0));
 
   // Get intensity level for heatmap (0-4)
+  /** @param {number} commits */
   function getIntensity(commits) {
     if (commits === 0) return 0;
     if (commits <= 2) return 1;

package/dist/ui/components/charts/ActivityOverview.svelte.d.ts

@@ -1,12 +1,15 @@
 export default ActivityOverview;
 type ActivityOverview = {
     $on?(type: string, callback: (e: any) => void): () => void;
-    $set?(props: ({
-        activity_date: string;
-        commit_count: number;
-    } | undefined)[]): void;
+    $set?(props: Partial<$$ComponentProps>): void;
 };
 declare const ActivityOverview: import("svelte").Component<{
-    activity_date: string;
-    commit_count: number;
-}[], {}, "">;
+    data?: any;
+    locData?: any;
+    days?: number;
+}, {}, "">;
+type $$ComponentProps = {
+    data?: any;
+    locData?: any;
+    days?: number;
+};

package/dist/ui/components/charts/RepoBreakdown.svelte

@@ -5,11 +5,16 @@
    */
 
   /**
-   * @type {{ name: string, commits?: number, additions?: number, deletions?: number }[]}
+   * @typedef {Object} RepoData
+   * @property {string} name
+   * @property {number} [commits]
+   * @property {number} [additions]
+   * @property {number} [deletions]
    */
+
   let {
-    repos = [],
-    mode = 'commits', // 'commits' or 'loc'
+    repos = /** @type {RepoData[]} */ ([]),
+    mode = /** @type {'commits' | 'loc'} */ ('commits'),
     maxWidth = 150,
     showLegend = true
   } = $props();
@@ -33,6 +38,7 @@
     return repos.reduce((sum, r) => sum + (r.additions || 0) + (r.deletions || 0), 0) || 1;
   }
 
+  /** @param {RepoData} repo */
   function getValue(repo) {
     if (mode === 'commits') {
       return repo.commits || 1;

package/dist/ui/components/charts/RepoBreakdown.svelte.d.ts

@@ -1,16 +1,17 @@
 export default RepoBreakdown;
 type RepoBreakdown = {
     $on?(type: string, callback: (e: any) => void): () => void;
-    $set?(props: ({
-        name: string;
-        commits?: number | undefined;
-        additions?: number | undefined;
-        deletions?: number | undefined;
-    } | undefined)[]): void;
+    $set?(props: Partial<$$ComponentProps>): void;
 };
 declare const RepoBreakdown: import("svelte").Component<{
-    name: string;
-    commits?: number;
-    additions?: number;
-    deletions?: number;
-}[], {}, "">;
+    repos?: any;
+    mode?: any;
+    maxWidth?: number;
+    showLegend?: boolean;
+}, {}, "">;
+type $$ComponentProps = {
+    repos?: any;
+    mode?: any;
+    maxWidth?: number;
+    showLegend?: boolean;
+};

package/dist/ui/components/charts/Sparkline.svelte

@@ -4,9 +4,20 @@
    * Shows activity trend over time (commits, LOC, etc.)
    */
 
-  /** @type {number[]} */
+  /**
+   * @typedef {Object} SparklineProps
+   * @property {number[]} [data] - Data points for the sparkline
+   * @property {number} [width] - Width of the chart
+   * @property {number} [height] - Height of the chart
+   * @property {string} [strokeColor] - Line color
+   * @property {string} [fillColor] - Fill color for area
+   * @property {number} [strokeWidth] - Line thickness
+   * @property {boolean} [showDots] - Show data point dots
+   * @property {boolean} [showArea] - Show filled area
+   */
+
   let {
-    data = [],
+    data = /** @type {number[]} */ ([]),
     width = 120,
     height = 24,
     strokeColor = '#5cb85f',
@@ -24,14 +35,14 @@
     const min = Math.min(...data, 0);
     const range = max - min || 1;
 
-    const points = data.map((value, i) => {
+    const points = data.map((/** @type {number} */ value, /** @type {number} */ i) => {
       const x = (i / (data.length - 1)) * width;
       const y = height - ((value - min) / range) * (height - 4) - 2; // 2px padding
       return { x, y };
     });
 
     // Create line path
-    const linePath = points.map((p, i) =>
+    const linePath = points.map((/** @type {{ x: number, y: number }} */ p, /** @type {number} */ i) =>
       `${i === 0 ? 'M' : 'L'} ${p.x.toFixed(1)} ${p.y.toFixed(1)}`
     ).join(' ');
 
@@ -45,14 +56,14 @@
     const min = Math.min(...data, 0);
     const range = max - min || 1;
 
-    const points = data.map((value, i) => {
+    const points = data.map((/** @type {number} */ value, /** @type {number} */ i) => {
       const x = (i / (data.length - 1)) * width;
       const y = height - ((value - min) / range) * (height - 4) - 2;
       return { x, y };
     });
 
     // Create closed area path
-    const linePath = points.map((p, i) =>
+    const linePath = points.map((/** @type {{ x: number, y: number }} */ p, /** @type {number} */ i) =>
       `${i === 0 ? 'M' : 'L'} ${p.x.toFixed(1)} ${p.y.toFixed(1)}`
     ).join(' ');
 
@@ -66,7 +77,7 @@
     const min = Math.min(...data, 0);
     const range = max - min || 1;
 
-    return data.map((value, i) => ({
+    return data.map((/** @type {number} */ value, /** @type {number} */ i) => ({
       x: (i / (data.length - 1)) * width,
       y: height - ((value - min) / range) * (height - 4) - 2,
       value

package/dist/ui/components/charts/Sparkline.svelte.d.ts

@@ -1,6 +1,25 @@
 export default Sparkline;
 type Sparkline = {
     $on?(type: string, callback: (e: any) => void): () => void;
-    $set?(props: (number | undefined)[]): void;
+    $set?(props: Partial<$$ComponentProps>): void;
+};
+declare const Sparkline: import("svelte").Component<{
+    data?: any;
+    width?: number;
+    height?: number;
+    strokeColor?: string;
+    fillColor?: string;
+    strokeWidth?: number;
+    showDots?: boolean;
+    showArea?: boolean;
+}, {}, "">;
+type $$ComponentProps = {
+    data?: any;
+    width?: number;
+    height?: number;
+    strokeColor?: string;
+    fillColor?: string;
+    strokeWidth?: number;
+    showDots?: boolean;
+    showArea?: boolean;
 };
-declare const Sparkline: import("svelte").Component<number[], {}, "">;