@littlebearapps/platform-admin-sdk 2.1.0 → 2.3.0

package/templates/full/dashboard/src/pages/api/patterns/[id]/reject.ts

@@ -0,0 +1,50 @@
+/**
+ * POST /api/patterns/:id/reject - Proxy to pattern-discovery /suggestions/:id?action=reject
+ * Rejects a pending pattern suggestion
+ */
+import type { APIRoute } from 'astro';
+
+interface Env {
+  PATTERN_DISCOVERY_API?: Fetcher;
+}
+
+export const POST: APIRoute = async ({ locals, params, url }) => {
+  const api = (locals.runtime?.env as Env)?.PATTERN_DISCOVERY_API;
+
+  if (!api) {
+    return new Response(JSON.stringify({ error: 'Pattern Discovery API not configured' }), {
+      status: 503,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  const { id } = params;
+  if (!id) {
+    return new Response(JSON.stringify({ error: 'Missing suggestion ID' }), {
+      status: 400,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  try {
+    const by = url.searchParams.get('by') || 'dashboard';
+    const reason = url.searchParams.get('reason') || 'Rejected via dashboard';
+
+    const response = await api.fetch(
+      `https://pattern-discovery.littlebearapps.workers.dev/suggestions/${id}?action=reject&by=${by}&reason=${encodeURIComponent(reason)}`,
+      { method: 'POST' }
+    );
+
+    const data = await response.json();
+    return new Response(JSON.stringify(data), {
+      status: response.status,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  } catch (error) {
+    console.error('Error rejecting suggestion:', error);
+    return new Response(JSON.stringify({ error: 'Failed to reject suggestion' }), {
+      status: 500,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+};

package/templates/full/dashboard/src/pages/api/reports/digests/stats.ts

@@ -0,0 +1,38 @@
+/**
+ * GET /api/reports/digests/stats - Proxy to error-collector /digests/stats
+ */
+import type { APIRoute } from 'astro';
+
+interface Env {
+  ERROR_COLLECTOR_API?: Fetcher;
+}
+
+export const GET: APIRoute = async ({ locals }) => {
+  const api = (locals.runtime?.env as Env)?.ERROR_COLLECTOR_API;
+
+  if (!api) {
+    return new Response(JSON.stringify({ error: 'Error Collector API not configured' }), {
+      status: 503,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  try {
+    const response = await api.fetch(
+      'https://error-collector.littlebearapps.workers.dev/digests/stats',
+      { method: 'GET' }
+    );
+
+    const data = await response.json();
+    return new Response(JSON.stringify(data), {
+      status: response.status,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  } catch (error) {
+    console.error('Error fetching digest stats:', error);
+    return new Response(JSON.stringify({ error: 'Failed to fetch digest stats' }), {
+      status: 500,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+};

package/templates/full/dashboard/src/pages/api/reports/digests.ts

@@ -0,0 +1,39 @@
+/**
+ * GET /api/reports/digests - Proxy to error-collector /digests
+ */
+import type { APIRoute } from 'astro';
+
+interface Env {
+  ERROR_COLLECTOR_API?: Fetcher;
+}
+
+export const GET: APIRoute = async ({ request, locals }) => {
+  const api = (locals.runtime?.env as Env)?.ERROR_COLLECTOR_API;
+
+  if (!api) {
+    return new Response(JSON.stringify({ error: 'Error Collector API not configured' }), {
+      status: 503,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  try {
+    const url = new URL(request.url);
+    const response = await api.fetch(
+      `https://error-collector.littlebearapps.workers.dev/digests${url.search}`,
+      { method: 'GET' }
+    );
+
+    const data = await response.json();
+    return new Response(JSON.stringify(data), {
+      status: response.status,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  } catch (error) {
+    console.error('Error fetching digests:', error);
+    return new Response(JSON.stringify({ error: 'Failed to fetch digests' }), {
+      status: 500,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+};

package/templates/full/dashboard/src/pages/api/search/reindex/[type].ts

@@ -0,0 +1,56 @@
+/**
+ * Reindex API Proxy
+ *
+ * Proxies reindex requests to platform-search worker.
+ *
+ * @module dashboard/pages/api/search/reindex
+ * @created 2026-02-03
+ * @task task-303.3
+ */
+
+import type { APIRoute } from 'astro';
+
+/**
+ * POST /api/search/reindex/:type - Reindex all documents of a content type
+ */
+export const POST: APIRoute = async ({ params, locals }) => {
+  const api = (locals.runtime?.env as { SEARCH_API?: Fetcher })?.SEARCH_API;
+  const { type } = params;
+
+  if (!api) {
+    return new Response(JSON.stringify({ error: 'Search API not available' }), {
+      status: 503,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  if (!type) {
+    return new Response(JSON.stringify({ error: 'Content type required' }), {
+      status: 400,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  try {
+    const response = await api.fetch(
+      new Request(
+        `https://platform-search.littlebearapps.workers.dev/search/reindex/${encodeURIComponent(type)}`,
+        {
+          method: 'POST',
+        }
+      )
+    );
+
+    const data = await response.json();
+    return new Response(JSON.stringify(data), {
+      status: response.status,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  } catch (error) {
+    console.error('Reindex error:', error);
+    return new Response(JSON.stringify({ error: 'Failed to reindex content type' }), {
+      status: 500,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+};

package/templates/full/dashboard/src/pages/api/test-reports/[id].ts

@@ -0,0 +1,102 @@
+/**
+ * Test Reports API Endpoint
+ *
+ * Serves HTML test reports from KV storage
+ * Reports are stored by platform-ingest-tester worker
+ * TTL: 7 days (passes) or 90 days (failures)
+ */
+
+export const GET = async ({ params, locals }: any) => {
+  const { id: runId } = params;
+  const env = locals.runtime.env;
+
+  if (!runId) {
+    return new Response(
+      JSON.stringify({
+        error: 'Missing run ID',
+        message: 'Run ID is required',
+      }),
+      {
+        status: 400,
+        headers: { 'Content-Type': 'application/json' },
+      }
+    );
+  }
+
+  try {
+    // First, get the run from D1 to find the KV key
+    const run = await env.PLATFORM_DB.prepare(
+      `SELECT id, project, kv_report_key, timestamp, pass_rate
+       FROM runs
+       WHERE id = ?`
+    )
+      .bind(runId)
+      .first();
+
+    if (!run) {
+      return new Response(
+        JSON.stringify({
+          error: 'Run not found',
+          message: `No test run found with ID: ${runId}`,
+        }),
+        {
+          status: 404,
+          headers: { 'Content-Type': 'application/json' },
+        }
+      );
+    }
+
+    if (!run.kv_report_key) {
+      return new Response(
+        JSON.stringify({
+          error: 'Report not available',
+          message: 'HTML report was not uploaded for this run',
+        }),
+        {
+          status: 404,
+          headers: { 'Content-Type': 'application/json' },
+        }
+      );
+    }
+
+    // Fetch HTML report from KV
+    const htmlReport = await env.PLATFORM_CACHE.get(run.kv_report_key);
+
+    if (!htmlReport) {
+      return new Response(
+        JSON.stringify({
+          error: 'Report expired',
+          message: 'HTML report has expired or been deleted (TTL: 7d for passes, 90d for failures)',
+        }),
+        {
+          status: 410, // Gone
+          headers: { 'Content-Type': 'application/json' },
+        }
+      );
+    }
+
+    // Return HTML report
+    return new Response(htmlReport, {
+      headers: {
+        'Content-Type': 'text/html; charset=utf-8',
+        'Cache-Control': 'public, max-age=3600', // Cache for 1 hour
+        'X-Run-ID': runId,
+        'X-Project': run.project as string,
+        'X-Timestamp': run.timestamp as string,
+      },
+    });
+  } catch (error: any) {
+    console.error('Failed to fetch test report:', error);
+
+    return new Response(
+      JSON.stringify({
+        error: 'Internal server error',
+        message: error.message,
+      }),
+      {
+        status: 500,
+        headers: { 'Content-Type': 'application/json' },
+      }
+    );
+  }
+};

package/templates/full/dashboard/src/pages/feedback.astro

@@ -0,0 +1,365 @@
+---
+import DashboardLayout from '../layouts/DashboardLayout.astro';
+
+interface FeedbackEvent {
+  feedbackId: string;
+  repo: string;
+  issueNumber: number;
+  category: string;
+  sentiment: string | null;
+  relatedErrorCorrelation: string | null;
+  correlationConfidence: number;
+  correlationMethod: 'rule-based' | 'ml' | 'manual';
+  userContactEncrypted: string | null;
+  receivedAt: string;
+  updatedAt: string | null;
+}
+
+const runtime = (Astro.locals as App.Locals | undefined)?.runtime;
+const db = runtime?.env?.PLATFORM_DB;
+const kv = runtime?.env?.PLATFORM_CACHE;
+
+let recentFeedback: FeedbackEvent[] = [];
+let correlatedFeedback: FeedbackEvent[] = [];
+let feedbackByCategory: Record<string, number> = {
+  'feature-request': 0,
+  'bug-report': 0,
+  'ux-improvement': 0,
+  other: 0,
+};
+let totalFeedback = 0;
+
+if (db && kv) {
+  // Try KV cache first for recent feedback
+  const cachedRecent = await kv.get('feedback:recent:all');
+  if (cachedRecent) {
+    recentFeedback = JSON.parse(cachedRecent);
+  } else {
+    // Cache miss - query D1
+    const result = await db
+      .prepare(
+        `SELECT
+          feedback_id as feedbackId,
+          repo,
+          issue_number as issueNumber,
+          category,
+          sentiment,
+          related_error_correlation as relatedErrorCorrelation,
+          correlation_confidence as correlationConfidence,
+          correlation_method as correlationMethod,
+          user_contact_encrypted as userContactEncrypted,
+          received_at as receivedAt,
+          updated_at as updatedAt
+        FROM feedback_events
+        ORDER BY received_at DESC
+        LIMIT 20`
+      )
+      .all<FeedbackEvent>();
+
+    recentFeedback = result.results ?? [];
+
+    // Cache for 15 minutes
+    await kv.put('feedback:recent:all', JSON.stringify(recentFeedback), {
+      expirationTtl: 900,
+    });
+  }
+
+  // Get correlated feedback (linked to errors)
+  const cachedCorrelated = await kv.get('feedback:correlated:all');
+  if (cachedCorrelated) {
+    correlatedFeedback = JSON.parse(cachedCorrelated);
+  } else {
+    const result = await db
+      .prepare(
+        `SELECT
+          feedback_id as feedbackId,
+          repo,
+          issue_number as issueNumber,
+          category,
+          sentiment,
+          related_error_correlation as relatedErrorCorrelation,
+          correlation_confidence as correlationConfidence,
+          correlation_method as correlationMethod,
+          user_contact_encrypted as userContactEncrypted,
+          received_at as receivedAt,
+          updated_at as updatedAt
+        FROM feedback_events
+        WHERE related_error_correlation IS NOT NULL
+        ORDER BY correlation_confidence DESC, received_at DESC
+        LIMIT 20`
+      )
+      .all<FeedbackEvent>();
+
+    correlatedFeedback = result.results ?? [];
+
+    await kv.put('feedback:correlated:all', JSON.stringify(correlatedFeedback), {
+      expirationTtl: 900,
+    });
+  }
+
+  // Get counts by category
+  const categoryResult = await db
+    .prepare(
+      `SELECT category, COUNT(*) as count
+       FROM feedback_events
+       GROUP BY category`
+    )
+    .all<{ category: string; count: number }>();
+
+  for (const row of categoryResult.results ?? []) {
+    feedbackByCategory[row.category] = row.count;
+    totalFeedback += row.count;
+  }
+}
+
+// Calculate priority score for each feedback event
+// Higher correlation confidence = higher priority
+function getPriorityScore(feedback: FeedbackEvent): number {
+  let score = 0;
+
+  // Correlation confidence (0-100 points)
+  score += feedback.correlationConfidence * 100;
+
+  // Category weight
+  if (feedback.category === 'bug-report') score += 30;
+  if (feedback.category === 'feature-request') score += 20;
+  if (feedback.category === 'ux-improvement') score += 15;
+
+  // Sentiment weight (if available)
+  if (feedback.sentiment === 'negative') score += 25;
+  if (feedback.sentiment === 'positive') score += 5;
+
+  return Math.round(score);
+}
+
+// Sort by priority
+const prioritizedFeedback = [...recentFeedback].sort(
+  (a, b) => getPriorityScore(b) - getPriorityScore(a)
+);
+
+function formatDate(dateString: string): string {
+  const date = new Date(dateString);
+  const now = new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffMins = Math.floor(diffMs / 60000);
+  const diffHours = Math.floor(diffMs / 3600000);
+  const diffDays = Math.floor(diffMs / 86400000);
+
+  if (diffMins < 60) return `${diffMins}m ago`;
+  if (diffHours < 24) return `${diffHours}h ago`;
+  if (diffDays < 7) return `${diffDays}d ago`;
+  return date.toLocaleDateString();
+}
+
+function getCategoryBadgeColor(category: string): string {
+  switch (category) {
+    case 'feature-request':
+      return 'bg-blue-100 text-blue-800 dark:bg-blue-900 dark:text-blue-300';
+    case 'bug-report':
+      return 'bg-red-100 text-red-800 dark:bg-red-900 dark:text-red-300';
+    case 'ux-improvement':
+      return 'bg-purple-100 text-purple-800 dark:bg-purple-900 dark:text-purple-300';
+    default:
+      return 'bg-gray-100 text-gray-800 dark:bg-gray-700 dark:text-gray-300';
+  }
+}
+
+function getPriorityBadgeColor(score: number): string {
+  if (score >= 120) return 'bg-red-500 text-white';
+  if (score >= 80) return 'bg-orange-500 text-white';
+  if (score >= 40) return 'bg-yellow-500 text-white';
+  return 'bg-green-500 text-white';
+}
+---
+
+<DashboardLayout title="Feedback">
+  <div class="space-y-6">
+    <h2 class="text-3xl font-bold text-gray-900 dark:text-white">User Feedback</h2>
+
+    <!-- Summary Cards -->
+    <div class="grid grid-cols-1 gap-6 md:grid-cols-4">
+      <div class="metric-card">
+        <div class="metric-title">Total Feedback</div>
+        <div class="metric-value">{totalFeedback}</div>
+        <div class="mt-2 text-sm text-gray-600 dark:text-gray-400">All time</div>
+      </div>
+
+      <div class="metric-card">
+        <div class="metric-title">Feature Requests</div>
+        <div class="metric-value">{feedbackByCategory['feature-request']}</div>
+        <div class="mt-2 text-sm text-gray-600 dark:text-gray-400">
+          {((feedbackByCategory['feature-request'] / totalFeedback) * 100).toFixed(0)}%
+        </div>
+      </div>
+
+      <div class="metric-card">
+        <div class="metric-title">Bug Reports</div>
+        <div class="metric-value">{feedbackByCategory['bug-report']}</div>
+        <div class="mt-2 text-sm text-gray-600 dark:text-gray-400">
+          {((feedbackByCategory['bug-report'] / totalFeedback) * 100).toFixed(0)}%
+        </div>
+      </div>
+
+      <div class="metric-card">
+        <div class="metric-title">Correlated</div>
+        <div class="metric-value">{correlatedFeedback.length}</div>
+        <div class="mt-2 text-sm text-gray-600 dark:text-gray-400">Linked to errors</div>
+      </div>
+    </div>
+
+    <!-- Prioritized Feedback List -->
+    <div class="bg-white dark:bg-gray-800 rounded-lg shadow p-6">
+      <h3 class="text-xl font-semibold text-gray-900 dark:text-white mb-4">Feedback by Priority</h3>
+
+      <div class="space-y-3">
+        {
+          prioritizedFeedback.length === 0 ? (
+            <p class="text-gray-600 dark:text-gray-400">No feedback events yet.</p>
+          ) : (
+            prioritizedFeedback.map((feedback) => {
+              const priorityScore = getPriorityScore(feedback);
+              return (
+                <div class="border border-gray-200 dark:border-gray-700 rounded-lg p-4 hover:bg-gray-50 dark:hover:bg-gray-700 transition-colors">
+                  <div class="flex items-start justify-between">
+                    <div class="flex-1">
+                      <div class="flex items-center gap-2 mb-2">
+                        <span
+                          class={`px-2 py-1 rounded text-xs font-medium ${getCategoryBadgeColor(feedback.category)}`}
+                        >
+                          {feedback.category}
+                        </span>
+                        <span
+                          class={`px-2 py-1 rounded text-xs font-bold ${getPriorityBadgeColor(priorityScore)}`}
+                        >
+                          P{priorityScore}
+                        </span>
+                        {feedback.relatedErrorCorrelation && (
+                          <span class="px-2 py-1 rounded text-xs font-medium bg-green-100 text-green-800 dark:bg-green-900 dark:text-green-300">
+                            Correlated ({Math.round(feedback.correlationConfidence * 100)}%)
+                          </span>
+                        )}
+                      </div>
+
+                      <div class="flex items-center gap-2 text-sm text-gray-600 dark:text-gray-400">
+                        <span class="font-mono">{feedback.repo}</span>
+                        <span>•</span>
+                        <a
+                          href={`https://github.com/littlebearapps/${feedback.repo}/issues/${feedback.issueNumber}`}
+                          target="_blank"
+                          rel="noopener noreferrer"
+                          class="text-blue-600 dark:text-blue-400 hover:underline"
+                        >
+                          #{feedback.issueNumber}
+                        </a>
+                        <span>•</span>
+                        <span>{formatDate(feedback.receivedAt)}</span>
+                      </div>
+
+                      {feedback.relatedErrorCorrelation && (
+                        <div class="mt-2 text-xs text-gray-500 dark:text-gray-400">
+                          <span>Linked to error: </span>
+                          <span class="font-mono">
+                            {feedback.relatedErrorCorrelation.substring(0, 8)}...
+                          </span>
+                          <span class="ml-2">via {feedback.correlationMethod}</span>
+                        </div>
+                      )}
+
+                      {feedback.userContactEncrypted && (
+                        <div class="mt-2 text-xs text-gray-500 dark:text-gray-400">
+                          <span>User contact provided (encrypted)</span>
+                        </div>
+                      )}
+                    </div>
+                  </div>
+                </div>
+              );
+            })
+          )
+        }
+      </div>
+    </div>
+
+    <!-- Correlated Feedback Section -->
+    {
+      correlatedFeedback.length > 0 && (
+        <div class="bg-white dark:bg-gray-800 rounded-lg shadow p-6">
+          <h3 class="text-xl font-semibold text-gray-900 dark:text-white mb-4">
+            High-Confidence Correlations
+          </h3>
+
+          <div class="space-y-3">
+            {correlatedFeedback.map((feedback) => (
+              <div class="border border-green-200 dark:border-green-700 rounded-lg p-4 bg-green-50 dark:bg-green-900/20">
+                <div class="flex items-start justify-between">
+                  <div class="flex-1">
+                    <div class="flex items-center gap-2 mb-2">
+                      <span
+                        class={`px-2 py-1 rounded text-xs font-medium ${getCategoryBadgeColor(feedback.category)}`}
+                      >
+                        {feedback.category}
+                      </span>
+                      <span class="px-2 py-1 rounded text-xs font-bold bg-green-600 text-white">
+                        {Math.round(feedback.correlationConfidence * 100)}% confident
+                      </span>
+                    </div>
+
+                    <div class="flex items-center gap-2 text-sm text-gray-600 dark:text-gray-300">
+                      <span class="font-mono">{feedback.repo}</span>
+                      <span>•</span>
+                      <a
+                        href={`https://github.com/littlebearapps/${feedback.repo}/issues/${feedback.issueNumber}`}
+                        target="_blank"
+                        rel="noopener noreferrer"
+                        class="text-blue-600 dark:text-blue-400 hover:underline"
+                      >
+                        #{feedback.issueNumber}
+                      </a>
+                      <span>•</span>
+                      <span>{formatDate(feedback.receivedAt)}</span>
+                    </div>
+
+                    <div class="mt-2 text-sm text-gray-700 dark:text-gray-300">
+                      <span>Linked to error: </span>
+                      <span class="font-mono bg-gray-100 dark:bg-gray-700 px-2 py-1 rounded">
+                        {feedback.relatedErrorCorrelation}
+                      </span>
+                      <span class="ml-2 text-xs text-gray-500 dark:text-gray-400">
+                        (via {feedback.correlationMethod})
+                      </span>
+                    </div>
+                  </div>
+                </div>
+              </div>
+            ))}
+          </div>
+        </div>
+      )
+    }
+
+    <!-- Category Breakdown -->
+    <div class="bg-white dark:bg-gray-800 rounded-lg shadow p-6">
+      <h3 class="text-xl font-semibold text-gray-900 dark:text-white mb-4">Feedback by Category</h3>
+
+      <div class="grid grid-cols-1 gap-4 md:grid-cols-2">
+        {
+          Object.entries(feedbackByCategory).map(([category, count]) => (
+            <div class="border border-gray-200 dark:border-gray-700 rounded-lg p-4">
+              <div class="flex items-center justify-between">
+                <span
+                  class={`px-3 py-1 rounded text-sm font-medium ${getCategoryBadgeColor(category)}`}
+                >
+                  {category}
+                </span>
+                <span class="text-2xl font-bold text-gray-900 dark:text-white">{count}</span>
+              </div>
+              <div class="mt-2 text-sm text-gray-600 dark:text-gray-400">
+                {totalFeedback > 0 ? ((count / totalFeedback) * 100).toFixed(1) : 0}% of total
+              </div>
+            </div>
+          ))
+        }
+      </div>
+    </div>
+  </div>
+</DashboardLayout>