proagents 1.0.0

package/proagents/reporting/templates/metrics-queries.md

@@ -0,0 +1,427 @@
+# Metrics Queries
+
+SQL and API queries for dashboard metrics.
+
+---
+
+## Overview
+
+These queries can be used to populate ProAgents dashboards. Adapt them to your database schema and API structure.
+
+---
+
+## Feature Metrics
+
+### Features Completed (Count)
+
+```sql
+-- PostgreSQL
+SELECT COUNT(*) as count
+FROM features
+WHERE status = 'completed'
+  AND completed_at >= NOW() - INTERVAL '30 days';
+```
+
+```typescript
+// API Endpoint
+app.get('/api/metrics/features/completed', async (req, res) => {
+  const { timeRange = '30d' } = req.query;
+  const days = parseInt(timeRange);
+
+  const count = await db.feature.count({
+    where: {
+      status: 'completed',
+      completedAt: {
+        gte: new Date(Date.now() - days * 24 * 60 * 60 * 1000),
+      },
+    },
+  });
+
+  const previousCount = await db.feature.count({
+    where: {
+      status: 'completed',
+      completedAt: {
+        gte: new Date(Date.now() - days * 2 * 24 * 60 * 60 * 1000),
+        lt: new Date(Date.now() - days * 24 * 60 * 60 * 1000),
+      },
+    },
+  });
+
+  const change = previousCount > 0
+    ? ((count - previousCount) / previousCount) * 100
+    : 0;
+
+  res.json({ value: count, change: Math.round(change) });
+});
+```
+
+### Average Feature Completion Time
+
+```sql
+SELECT AVG(
+  EXTRACT(EPOCH FROM (completed_at - created_at)) / 86400
+) as avg_days
+FROM features
+WHERE status = 'completed'
+  AND completed_at >= NOW() - INTERVAL '30 days';
+```
+
+```typescript
+// API Endpoint
+app.get('/api/metrics/features/avg-time', async (req, res) => {
+  const features = await db.feature.findMany({
+    where: {
+      status: 'completed',
+      completedAt: { gte: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000) },
+    },
+    select: { createdAt: true, completedAt: true },
+  });
+
+  const totalDays = features.reduce((sum, f) => {
+    const days = (f.completedAt.getTime() - f.createdAt.getTime()) / (1000 * 60 * 60 * 24);
+    return sum + days;
+  }, 0);
+
+  const avgDays = features.length > 0 ? totalDays / features.length : 0;
+  res.json({ value: Math.round(avgDays * 10) / 10 });
+});
+```
+
+### Features by Phase
+
+```sql
+SELECT phase, COUNT(*) as count
+FROM features
+WHERE status = 'active'
+GROUP BY phase
+ORDER BY count DESC;
+```
+
+```typescript
+// API Endpoint
+app.get('/api/metrics/features/by-phase', async (req, res) => {
+  const result = await db.feature.groupBy({
+    by: ['phase'],
+    where: { status: 'active' },
+    _count: { phase: true },
+  });
+
+  const data = result.reduce((acc, r) => {
+    acc[r.phase] = r._count.phase;
+    return acc;
+  }, {} as Record<string, number>);
+
+  res.json(data);
+});
+```
+
+---
+
+## Bug Metrics
+
+### Bugs Fixed (Count)
+
+```sql
+SELECT COUNT(*) as count
+FROM bugs
+WHERE status = 'fixed'
+  AND fixed_at >= NOW() - INTERVAL '30 days';
+```
+
+### Average Bug Fix Time
+
+```sql
+SELECT AVG(
+  EXTRACT(EPOCH FROM (fixed_at - created_at)) / 3600
+) as avg_hours
+FROM bugs
+WHERE status = 'fixed'
+  AND fixed_at >= NOW() - INTERVAL '30 days';
+```
+
+### Bugs by Severity
+
+```sql
+SELECT severity, COUNT(*) as count
+FROM bugs
+WHERE status = 'open'
+GROUP BY severity
+ORDER BY
+  CASE severity
+    WHEN 'critical' THEN 1
+    WHEN 'high' THEN 2
+    WHEN 'medium' THEN 3
+    WHEN 'low' THEN 4
+  END;
+```
+
+---
+
+## Quality Metrics
+
+### Test Coverage
+
+```sql
+-- From latest coverage report
+SELECT coverage_percentage
+FROM coverage_reports
+ORDER BY created_at DESC
+LIMIT 1;
+```
+
+```typescript
+// API Endpoint (reads from coverage file)
+app.get('/api/metrics/quality/coverage', async (req, res) => {
+  try {
+    const coverageFile = await fs.readFile('./coverage/coverage-summary.json', 'utf-8');
+    const coverage = JSON.parse(coverageFile);
+    const percentage = coverage.total.lines.pct;
+    res.json({ value: percentage });
+  } catch {
+    res.json({ value: 0, error: 'Coverage report not found' });
+  }
+});
+```
+
+### Lint Errors
+
+```sql
+SELECT COUNT(*) as count
+FROM lint_reports
+WHERE created_at >= NOW() - INTERVAL '24 hours'
+  AND severity = 'error';
+```
+
+### Technical Debt Items
+
+```sql
+SELECT COUNT(*) as count
+FROM technical_debt
+WHERE status = 'open';
+```
+
+---
+
+## Team Metrics
+
+### Team Contributions
+
+```sql
+SELECT
+  u.name as developer,
+  COUNT(DISTINCT f.id) FILTER (WHERE f.status = 'completed') as features,
+  COUNT(DISTINCT b.id) FILTER (WHERE b.status = 'fixed') as bugs,
+  COUNT(DISTINCT r.id) as reviews
+FROM users u
+LEFT JOIN features f ON f.assignee_id = u.id
+  AND f.completed_at >= NOW() - INTERVAL '30 days'
+LEFT JOIN bugs b ON b.assignee_id = u.id
+  AND b.fixed_at >= NOW() - INTERVAL '30 days'
+LEFT JOIN reviews r ON r.reviewer_id = u.id
+  AND r.created_at >= NOW() - INTERVAL '30 days'
+WHERE u.role = 'developer'
+GROUP BY u.id, u.name
+ORDER BY features DESC;
+```
+
+```typescript
+// API Endpoint
+app.get('/api/metrics/team/contributions', async (req, res) => {
+  const thirtyDaysAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
+
+  const users = await db.user.findMany({
+    where: { role: 'developer' },
+    include: {
+      features: {
+        where: { status: 'completed', completedAt: { gte: thirtyDaysAgo } },
+      },
+      bugs: {
+        where: { status: 'fixed', fixedAt: { gte: thirtyDaysAgo } },
+      },
+      reviews: {
+        where: { createdAt: { gte: thirtyDaysAgo } },
+      },
+    },
+  });
+
+  const contributions = users.map((u) => ({
+    developer: u.name,
+    features: u.features.length,
+    bugs: u.bugs.length,
+    reviews: u.reviews.length,
+  }));
+
+  res.json(contributions.sort((a, b) => b.features - a.features));
+});
+```
+
+---
+
+## Velocity Metrics
+
+### Weekly Velocity
+
+```sql
+SELECT
+  DATE_TRUNC('week', completed_at) as week,
+  COUNT(*) FILTER (WHERE type = 'feature') as features,
+  COUNT(*) FILTER (WHERE type = 'bug') as bugs
+FROM (
+  SELECT 'feature' as type, completed_at FROM features WHERE status = 'completed'
+  UNION ALL
+  SELECT 'bug' as type, fixed_at as completed_at FROM bugs WHERE status = 'fixed'
+) combined
+WHERE completed_at >= NOW() - INTERVAL '90 days'
+GROUP BY week
+ORDER BY week;
+```
+
+```typescript
+// API Endpoint
+app.get('/api/metrics/velocity', async (req, res) => {
+  const { timeRange = '90d', granularity = 'week' } = req.query;
+
+  // Get features and bugs grouped by week
+  const features = await db.$queryRaw`
+    SELECT DATE_TRUNC('week', completed_at) as week, COUNT(*) as count
+    FROM features
+    WHERE status = 'completed'
+      AND completed_at >= NOW() - INTERVAL '90 days'
+    GROUP BY week
+    ORDER BY week
+  `;
+
+  const bugs = await db.$queryRaw`
+    SELECT DATE_TRUNC('week', fixed_at) as week, COUNT(*) as count
+    FROM bugs
+    WHERE status = 'fixed'
+      AND fixed_at >= NOW() - INTERVAL '90 days'
+    GROUP BY week
+    ORDER BY week
+  `;
+
+  res.json({ features, bugs });
+});
+```
+
+---
+
+## Deployment Metrics
+
+### Deployments Count
+
+```sql
+SELECT
+  environment,
+  COUNT(*) as deployments,
+  COUNT(*) FILTER (WHERE status = 'success') as successful,
+  COUNT(*) FILTER (WHERE status = 'failed') as failed
+FROM deployments
+WHERE deployed_at >= NOW() - INTERVAL '30 days'
+GROUP BY environment;
+```
+
+### Deployment Frequency
+
+```sql
+SELECT
+  DATE_TRUNC('day', deployed_at) as day,
+  COUNT(*) as count
+FROM deployments
+WHERE environment = 'production'
+  AND deployed_at >= NOW() - INTERVAL '30 days'
+GROUP BY day
+ORDER BY day;
+```
+
+### Mean Time to Recovery (MTTR)
+
+```sql
+SELECT AVG(
+  EXTRACT(EPOCH FROM (resolved_at - detected_at)) / 60
+) as avg_minutes
+FROM incidents
+WHERE resolved_at IS NOT NULL
+  AND resolved_at >= NOW() - INTERVAL '90 days';
+```
+
+---
+
+## Activity Feed
+
+### Recent Activity
+
+```sql
+SELECT
+  'feature_complete' as type,
+  CONCAT('Feature completed: ', name) as message,
+  completed_at as timestamp
+FROM features
+WHERE status = 'completed'
+  AND completed_at >= NOW() - INTERVAL '7 days'
+
+UNION ALL
+
+SELECT
+  'deployment' as type,
+  CONCAT('Deployed to ', environment) as message,
+  deployed_at as timestamp
+FROM deployments
+WHERE deployed_at >= NOW() - INTERVAL '7 days'
+
+UNION ALL
+
+SELECT
+  'pr_merged' as type,
+  CONCAT('PR merged: ', title) as message,
+  merged_at as timestamp
+FROM pull_requests
+WHERE merged_at >= NOW() - INTERVAL '7 days'
+
+ORDER BY timestamp DESC
+LIMIT 20;
+```
+
+```typescript
+// API Endpoint
+app.get('/api/activity/feed', async (req, res) => {
+  const { limit = 20 } = req.query;
+  const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
+
+  const [features, deployments, prs] = await Promise.all([
+    db.feature.findMany({
+      where: { status: 'completed', completedAt: { gte: sevenDaysAgo } },
+      select: { name: true, completedAt: true },
+    }),
+    db.deployment.findMany({
+      where: { deployedAt: { gte: sevenDaysAgo } },
+      select: { environment: true, deployedAt: true },
+    }),
+    db.pullRequest.findMany({
+      where: { mergedAt: { gte: sevenDaysAgo } },
+      select: { title: true, mergedAt: true },
+    }),
+  ]);
+
+  const activities = [
+    ...features.map((f) => ({
+      type: 'feature_complete',
+      message: `Feature completed: ${f.name}`,
+      timestamp: f.completedAt,
+    })),
+    ...deployments.map((d) => ({
+      type: 'deployment',
+      message: `Deployed to ${d.environment}`,
+      timestamp: d.deployedAt,
+    })),
+    ...prs.map((p) => ({
+      type: 'pr_merged',
+      message: `PR merged: ${p.title}`,
+      timestamp: p.mergedAt,
+    })),
+  ];
+
+  activities.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+  res.json(activities.slice(0, parseInt(limit as string)));
+});
+```