@doccov/api 0.3.6 → 0.4.0

package/src/routes/coverage.ts

@@ -0,0 +1,270 @@
+import { Hono } from 'hono';
+import { nanoid } from 'nanoid';
+import { auth } from '../auth/config';
+import { db } from '../db/client';
+
+type Session = Awaited<ReturnType<typeof auth.api.getSession>>;
+
+type Env = {
+  Variables: {
+    session: NonNullable<Session>;
+  };
+};
+
+export const coverageRoute = new Hono<Env>();
+
+// Middleware: require auth
+coverageRoute.use('*', async (c, next) => {
+  const session = await auth.api.getSession({ headers: c.req.raw.headers });
+  if (!session) {
+    return c.json({ error: 'Unauthorized' }, 401);
+  }
+  c.set('session', session);
+  await next();
+});
+
+// Get coverage history for a project
+coverageRoute.get('/projects/:projectId/history', async (c) => {
+  const session = c.get('session');
+  const { projectId } = c.req.param();
+  const { range = '30d', limit = '50' } = c.req.query();
+
+  // Verify user has access to project
+  const project = await db
+    .selectFrom('projects')
+    .innerJoin('org_members', 'org_members.orgId', 'projects.orgId')
+    .where('projects.id', '=', projectId)
+    .where('org_members.userId', '=', session.user.id)
+    .select(['projects.id', 'projects.name'])
+    .executeTakeFirst();
+
+  if (!project) {
+    return c.json({ error: 'Project not found' }, 404);
+  }
+
+  // Calculate date filter based on range
+  let dateFilter: Date | null = null;
+  const now = new Date();
+  switch (range) {
+    case '7d':
+      dateFilter = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+      break;
+    case '30d':
+      dateFilter = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
+      break;
+    case '90d':
+      dateFilter = new Date(now.getTime() - 90 * 24 * 60 * 60 * 1000);
+      break;
+    // 'all' and 'versions' - no date filter
+  }
+
+  let query = db
+    .selectFrom('coverage_snapshots')
+    .where('projectId', '=', projectId)
+    .orderBy('createdAt', 'desc')
+    .limit(parseInt(limit, 10));
+
+  if (dateFilter) {
+    query = query.where('createdAt', '>=', dateFilter);
+  }
+
+  const snapshots = await query
+    .select([
+      'id',
+      'version',
+      'branch',
+      'commitSha',
+      'coveragePercent',
+      'documentedCount',
+      'totalCount',
+      'descriptionCount',
+      'paramsCount',
+      'returnsCount',
+      'examplesCount',
+      'driftCount',
+      'source',
+      'createdAt',
+    ])
+    .execute();
+
+  // Reverse to get chronological order
+  const chronological = snapshots.reverse();
+
+  // Calculate insights
+  const insights = generateInsights(chronological);
+
+  // Detect regressions
+  const regression = detectRegression(chronological);
+
+  return c.json({
+    snapshots: chronological,
+    insights,
+    regression,
+  });
+});
+
+// Record a new coverage snapshot
+coverageRoute.post('/projects/:projectId/snapshots', async (c) => {
+  const session = c.get('session');
+  const { projectId } = c.req.param();
+  const body = await c.req.json<{
+    version?: string;
+    branch?: string;
+    commitSha?: string;
+    coveragePercent: number;
+    documentedCount: number;
+    totalCount: number;
+    descriptionCount?: number;
+    paramsCount?: number;
+    returnsCount?: number;
+    examplesCount?: number;
+    driftCount?: number;
+    source?: 'ci' | 'manual' | 'scheduled';
+  }>();
+
+  // Verify user has admin access to project
+  const membership = await db
+    .selectFrom('projects')
+    .innerJoin('org_members', 'org_members.orgId', 'projects.orgId')
+    .where('projects.id', '=', projectId)
+    .where('org_members.userId', '=', session.user.id)
+    .where('org_members.role', 'in', ['owner', 'admin'])
+    .select(['projects.id'])
+    .executeTakeFirst();
+
+  if (!membership) {
+    return c.json({ error: 'Forbidden' }, 403);
+  }
+
+  const snapshot = await db
+    .insertInto('coverage_snapshots')
+    .values({
+      id: nanoid(21),
+      projectId,
+      version: body.version || null,
+      branch: body.branch || null,
+      commitSha: body.commitSha || null,
+      coveragePercent: body.coveragePercent,
+      documentedCount: body.documentedCount,
+      totalCount: body.totalCount,
+      descriptionCount: body.descriptionCount || null,
+      paramsCount: body.paramsCount || null,
+      returnsCount: body.returnsCount || null,
+      examplesCount: body.examplesCount || null,
+      driftCount: body.driftCount || 0,
+      source: body.source || 'manual',
+    })
+    .returningAll()
+    .executeTakeFirst();
+
+  // Update project's latest coverage
+  await db
+    .updateTable('projects')
+    .set({
+      coverageScore: body.coveragePercent,
+      driftCount: body.driftCount || 0,
+      lastAnalyzedAt: new Date(),
+    })
+    .where('id', '=', projectId)
+    .execute();
+
+  return c.json({ snapshot }, 201);
+});
+
+// Helper: Generate insights from coverage data
+interface Snapshot {
+  version: string | null;
+  coveragePercent: number;
+  documentedCount: number;
+  totalCount: number;
+  driftCount: number;
+}
+
+interface Insight {
+  type: 'improvement' | 'regression' | 'prediction' | 'milestone';
+  message: string;
+  severity: 'info' | 'warning' | 'success';
+}
+
+function generateInsights(snapshots: Snapshot[]): Insight[] {
+  const insights: Insight[] = [];
+  if (snapshots.length < 2) return insights;
+
+  const first = snapshots[0];
+  const last = snapshots[snapshots.length - 1];
+  const diff = last.coveragePercent - first.coveragePercent;
+
+  // Overall improvement/regression
+  if (diff > 0) {
+    insights.push({
+      type: 'improvement',
+      message: `Coverage increased ${diff.toFixed(0)}% since ${first.version || 'first snapshot'}`,
+      severity: 'success',
+    });
+  } else if (diff < 0) {
+    insights.push({
+      type: 'regression',
+      message: `Coverage decreased ${Math.abs(diff).toFixed(0)}% since ${first.version || 'first snapshot'}`,
+      severity: 'warning',
+    });
+  }
+
+  // Predict time to 100%
+  if (diff > 0 && last.coveragePercent < 100) {
+    const remaining = 100 - last.coveragePercent;
+    const avgGainPerSnapshot = diff / (snapshots.length - 1);
+    if (avgGainPerSnapshot > 0) {
+      const snapshotsToComplete = Math.ceil(remaining / avgGainPerSnapshot);
+      insights.push({
+        type: 'prediction',
+        message: `At current pace, 100% coverage in ~${snapshotsToComplete} releases`,
+        severity: 'info',
+      });
+    }
+  }
+
+  // Check for milestones
+  const milestones = [50, 75, 90, 100];
+  for (const milestone of milestones) {
+    const crossedAt = snapshots.findIndex(
+      (s, i) =>
+        i > 0 && s.coveragePercent >= milestone && snapshots[i - 1].coveragePercent < milestone,
+    );
+    if (crossedAt > 0) {
+      insights.push({
+        type: 'milestone',
+        message: `Reached ${milestone}% coverage at ${snapshots[crossedAt].version || `snapshot ${crossedAt + 1}`}`,
+        severity: 'success',
+      });
+    }
+  }
+
+  return insights.slice(0, 5); // Limit to 5 insights
+}
+
+// Helper: Detect recent regression
+function detectRegression(
+  snapshots: Snapshot[],
+): { fromVersion: string; toVersion: string; coverageDrop: number; exportsLost: number } | null {
+  if (snapshots.length < 2) return null;
+
+  // Look at last 5 snapshots for recent regressions
+  const recent = snapshots.slice(-5);
+  for (let i = 1; i < recent.length; i++) {
+    const prev = recent[i - 1];
+    const curr = recent[i];
+    const drop = prev.coveragePercent - curr.coveragePercent;
+
+    if (drop >= 3) {
+      // 3% or more drop
+      return {
+        fromVersion: prev.version || `v${i}`,
+        toVersion: curr.version || `v${i + 1}`,
+        coverageDrop: Math.round(drop),
+        exportsLost: prev.documentedCount - curr.documentedCount,
+      };
+    }
+  }
+
+  return null;
+}

package/src/routes/orgs.ts

@@ -0,0 +1,138 @@
+import { Hono } from 'hono';
+import { nanoid } from 'nanoid';
+import { auth } from '../auth/config';
+import { db } from '../db/client';
+
+type Session = Awaited<ReturnType<typeof auth.api.getSession>>;
+
+type Env = {
+  Variables: {
+    session: NonNullable<Session>;
+  };
+};
+
+export const orgsRoute = new Hono<Env>();
+
+// Middleware: require auth
+orgsRoute.use('*', async (c, next) => {
+  const session = await auth.api.getSession({ headers: c.req.raw.headers });
+  if (!session) {
+    return c.json({ error: 'Unauthorized' }, 401);
+  }
+  c.set('session', session);
+  await next();
+});
+
+// List user's organizations
+orgsRoute.get('/', async (c) => {
+  const session = c.get('session');
+
+  const memberships = await db
+    .selectFrom('org_members')
+    .innerJoin('organizations', 'organizations.id', 'org_members.orgId')
+    .where('org_members.userId', '=', session.user.id)
+    .select([
+      'organizations.id',
+      'organizations.name',
+      'organizations.slug',
+      'organizations.plan',
+      'organizations.isPersonal',
+      'organizations.aiCallsUsed',
+      'org_members.role',
+    ])
+    .execute();
+
+  return c.json({ organizations: memberships });
+});
+
+// Get single org by slug
+orgsRoute.get('/:slug', async (c) => {
+  const session = c.get('session');
+  const { slug } = c.req.param();
+
+  const org = await db
+    .selectFrom('organizations')
+    .innerJoin('org_members', 'org_members.orgId', 'organizations.id')
+    .where('organizations.slug', '=', slug)
+    .where('org_members.userId', '=', session.user.id)
+    .select([
+      'organizations.id',
+      'organizations.name',
+      'organizations.slug',
+      'organizations.plan',
+      'organizations.isPersonal',
+      'organizations.aiCallsUsed',
+      'organizations.aiCallsResetAt',
+      'org_members.role',
+    ])
+    .executeTakeFirst();
+
+  if (!org) {
+    return c.json({ error: 'Organization not found' }, 404);
+  }
+
+  return c.json({ organization: org });
+});
+
+// Get org's projects
+orgsRoute.get('/:slug/projects', async (c) => {
+  const session = c.get('session');
+  const { slug } = c.req.param();
+
+  // Verify membership
+  const membership = await db
+    .selectFrom('org_members')
+    .innerJoin('organizations', 'organizations.id', 'org_members.orgId')
+    .where('organizations.slug', '=', slug)
+    .where('org_members.userId', '=', session.user.id)
+    .select(['org_members.orgId'])
+    .executeTakeFirst();
+
+  if (!membership) {
+    return c.json({ error: 'Organization not found' }, 404);
+  }
+
+  const projects = await db
+    .selectFrom('projects')
+    .where('orgId', '=', membership.orgId)
+    .selectAll()
+    .execute();
+
+  return c.json({ projects });
+});
+
+// Create a project
+orgsRoute.post('/:slug/projects', async (c) => {
+  const session = c.get('session');
+  const { slug } = c.req.param();
+  const body = await c.req.json<{ name: string; fullName: string; isPrivate?: boolean }>();
+
+  // Verify owner/admin membership
+  const membership = await db
+    .selectFrom('org_members')
+    .innerJoin('organizations', 'organizations.id', 'org_members.orgId')
+    .where('organizations.slug', '=', slug)
+    .where('org_members.userId', '=', session.user.id)
+    .where('org_members.role', 'in', ['owner', 'admin'])
+    .select(['org_members.orgId'])
+    .executeTakeFirst();
+
+  if (!membership) {
+    return c.json({ error: 'Forbidden' }, 403);
+  }
+
+  const project = await db
+    .insertInto('projects')
+    .values({
+      id: nanoid(21),
+      orgId: membership.orgId,
+      name: body.name,
+      fullName: body.fullName,
+      isPrivate: body.isPrivate ?? false,
+      defaultBranch: 'main',
+    })
+    .returningAll()
+    .executeTakeFirst();
+
+  return c.json({ project }, 201);
+});

package/src/routes/plan.ts

@@ -1,81 +1,11 @@
 /**
- * Plan route for local development (mirrors api/plan.ts)
- * Does NOT use Vercel Sandbox - only GitHub API + Anthropic Claude
+ * Plan route - TODO: implement plan-agent
  */
 
-import { fetchGitHubContext, parseScanGitHubUrl } from '@doccov/sdk';
 import { Hono } from 'hono';
-import { generateBuildPlan } from '../../lib/plan-agent';
 
 export const planRoute = new Hono();
 
 planRoute.post('/', async (c) => {
-  const body = await c.req.json<{ url: string; ref?: string; package?: string }>();
-
-  if (!body.url) {
-    return c.json({ error: 'url is required' }, 400);
-  }
-
-  // Validate URL format
-  let repoUrl: string;
-  try {
-    const parsed = parseScanGitHubUrl(body.url);
-    if (!parsed) {
-      return c.json({ error: 'Invalid GitHub URL' }, 400);
-    }
-    repoUrl = `https://github.com/${parsed.owner}/${parsed.repo}`;
-  } catch {
-    return c.json({ error: 'Invalid GitHub URL' }, 400);
-  }
-
-  try {
-    // Fetch project context from GitHub
-    const context = await fetchGitHubContext(repoUrl, body.ref);
-
-    // Check for private repos
-    if (context.metadata.isPrivate) {
-      return c.json(
-        {
-          error: 'Private repositories are not supported',
-          hint: 'Use a public repository or run doccov locally',
-        },
-        403,
-      );
-    }
-
-    // Generate build plan using AI
-    const plan = await generateBuildPlan(context, {
-      targetPackage: body.package,
-    });
-
-    return c.json({
-      plan,
-      context: {
-        owner: context.metadata.owner,
-        repo: context.metadata.repo,
-        ref: context.ref,
-        packageManager: context.packageManager,
-        isMonorepo: context.workspace.isMonorepo,
-      },
-    });
-  } catch (error) {
-    console.error('Plan generation error:', error);
-
-    if (error instanceof Error) {
-      if (error.message.includes('404') || error.message.includes('not found')) {
-        return c.json({ error: 'Repository not found' }, 404);
-      }
-      if (error.message.includes('rate limit')) {
-        return c.json({ error: 'GitHub API rate limit exceeded' }, 429);
-      }
-    }
-
-    return c.json(
-      {
-        error: 'Failed to generate build plan',
-        message: error instanceof Error ? error.message : 'Unknown error',
-      },
-      500,
-    );
-  }
+  return c.json({ error: 'Plan endpoint not yet implemented' }, 501);
 });

package/src/server.ts

@@ -0,0 +1,22 @@
+import { serve } from '@hono/node-server';
+import { runMigrations } from './db/migrate';
+import app from './index';
+
+const port = parseInt(process.env.PORT || '3001');
+
+async function start() {
+  // Run migrations on startup
+  console.log('Running migrations...');
+  await runMigrations();
+
+  // Start server
+  console.log(`Starting server on port ${port}`);
+  serve({
+    fetch: app.fetch,
+    port,
+  });
+
+  console.log(`Server running at http://localhost:${port}`);
+}
+
+start().catch(console.error);

package/src/utils/api-keys.ts

@@ -0,0 +1,20 @@
+import { createHash } from 'node:crypto';
+import { nanoid } from 'nanoid';
+
+const KEY_PREFIX = 'doccov_';
+
+export function generateApiKey(): { key: string; hash: string; prefix: string } {
+  const random = nanoid(32);
+  const key = `${KEY_PREFIX}${random}`;
+  const hash = hashApiKey(key);
+  const prefix = key.slice(0, 12);
+  return { key, hash, prefix };
+}
+
+export function hashApiKey(key: string): string {
+  return createHash('sha256').update(key).digest('hex');
+}
+
+export function isValidKeyFormat(key: string): boolean {
+  return key.startsWith(KEY_PREFIX) && key.length === KEY_PREFIX.length + 32;
+}

package/vercel.json

@@ -2,7 +2,5 @@
   "framework": null,
   "installCommand": "bun install",
   "outputDirectory": ".",
-  "rewrites": [
-    { "source": "/(.*)", "destination": "/api" }
-  ]
+  "rewrites": [{ "source": "/(.*)", "destination": "/api" }]
 }