@doccov/api 0.3.4 → 0.3.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doccov/api",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "DocCov API - Badge endpoint and coverage services",
   "keywords": [
     "doccov",
@@ -18,18 +18,19 @@
   "license": "MIT",
   "author": "Ryan Waits",
   "type": "module",
-  "main": "./src/index.ts",
   "scripts": {
     "dev": "bun run --hot src/index.ts",
     "start": "bun run src/index.ts",
-    "lint": "biome check src/",
-    "lint:fix": "biome check --write src/",
-    "format": "biome format --write src/"
+    "lint": "biome check src/ api/",
+    "lint:fix": "biome check --write src/ api/",
+    "format": "biome format --write src/ api/"
   },
   "dependencies": {
-    "@openpkg-ts/spec": "^0.8.0",
+    "@ai-sdk/anthropic": "^2.0.55",
+    "@doccov/sdk": "^0.13.0",
+    "@openpkg-ts/spec": "^0.9.0",
     "@vercel/sandbox": "^1.0.3",
-    "hono": "^4.0.0",
+    "ai": "^5.0.111",
     "ms": "^2.1.3",
     "zod": "^3.25.0"
   },

package/src/index.ts

@@ -2,20 +2,20 @@ import { Hono } from 'hono';
 import { cors } from 'hono/cors';
 import { rateLimit } from './middleware/rate-limit';
 import { badgeRoute } from './routes/badge';
-import { scanRoute } from './routes/scan';
+import { planRoute } from './routes/plan';
 
 const app = new Hono();
 
 // Middleware
 app.use('*', cors());
 
-// Rate limit /scan endpoint: 10 requests per minute per IP
+// Rate limit /plan endpoint: 10 requests per minute per IP
 app.use(
-  '/scan/*',
+  '/plan',
   rateLimit({
     windowMs: 60 * 1000,
     max: 10,
-    message: 'Too many scan requests. Please try again in a minute.',
+    message: 'Too many plan requests. Please try again in a minute.',
   }),
 );
 
@@ -23,10 +23,12 @@ app.use(
 app.get('/', (c) => {
   return c.json({
     name: 'DocCov API',
-    version: '0.3.0',
+    version: '0.4.0',
     endpoints: {
       badge: '/badge/:owner/:repo',
-      scan: '/scan',
+      plan: '/plan',
+      execute: '/execute',
+      'execute-stream': '/execute-stream',
       health: '/health',
     },
   });
@@ -38,7 +40,7 @@ app.get('/health', (c) => {
 
 // Routes
 app.route('/badge', badgeRoute);
-app.route('/scan', scanRoute);
+app.route('/plan', planRoute);
 
 // Vercel serverless handler + Bun auto-serves this export
 export default app;

package/src/routes/plan.ts

@@ -0,0 +1,81 @@
+/**
+ * Plan route for local development (mirrors api/plan.ts)
+ * Does NOT use Vercel Sandbox - only GitHub API + Anthropic Claude
+ */
+
+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,
+    );
+  }
+});

package/tsconfig.json

@@ -10,6 +10,6 @@
     "isolatedModules": true,
     "noEmit": true
   },
-  "include": ["api/**/*", "src/**/*"],
-  "exclude": ["node_modules"]
+  "include": ["api/**/*", "functions/**/*", "lib/**/*", "src/**/*"],
+  "exclude": ["node_modules", "dist"]
 }

package/vercel.json

@@ -1,10 +1,8 @@
 {
+  "framework": null,
+  "installCommand": "bun install",
+  "outputDirectory": ".",
   "rewrites": [
-    { "source": "/badge/:path*", "destination": "/api" },
-    { "source": "/spec/:path*", "destination": "/api" },
-    { "source": "/scan-stream", "destination": "/api/scan-stream" },
-    { "source": "/scan/detect", "destination": "/api/scan/detect" },
-    { "source": "/scan", "destination": "/api/scan" },
     { "source": "/(.*)", "destination": "/api" }
   ]
 }

package/api/scan/detect.ts

@@ -1,118 +0,0 @@
-/**
- * Detect endpoint - uses SDK detection via SandboxFileSystem.
- * Detects monorepo structure and package manager for a GitHub repository.
- */
-
-import {
-  detectPackageManager,
-  SandboxFileSystem,
-  detectMonorepo as sdkDetectMonorepo,
-} from '@doccov/sdk';
-import type { VercelRequest, VercelResponse } from '@vercel/node';
-import { Sandbox } from '@vercel/sandbox';
-
-export const config = {
-  runtime: 'nodejs',
-  maxDuration: 60, // Quick detection, 1 minute max
-};
-
-interface DetectRequestBody {
-  url: string;
-  ref?: string;
-}
-
-interface PackageInfo {
-  name: string;
-  path: string;
-  description?: string;
-}
-
-interface DetectResponse {
-  isMonorepo: boolean;
-  packageManager: 'npm' | 'pnpm' | 'bun' | 'yarn';
-  packages?: PackageInfo[];
-  defaultPackage?: string;
-  error?: string;
-}
-
-export default async function handler(req: VercelRequest, res: VercelResponse) {
-  // CORS
-  res.setHeader('Access-Control-Allow-Origin', '*');
-  res.setHeader('Access-Control-Allow-Methods', 'POST, OPTIONS');
-  res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
-
-  if (req.method === 'OPTIONS') {
-    return res.status(200).end();
-  }
-
-  if (req.method !== 'POST') {
-    return res.status(405).json({ error: 'Method not allowed' });
-  }
-
-  const body = req.body as DetectRequestBody;
-
-  if (!body.url) {
-    return res.status(400).json({ error: 'url is required' });
-  }
-
-  try {
-    const result = await detectRepoStructure(body.url);
-    return res.status(200).json(result);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return res.status(500).json({
-      isMonorepo: false,
-      packageManager: 'npm',
-      error: message,
-    } as DetectResponse);
-  }
-}
-
-/**
- * Detect repository structure using SDK utilities via SandboxFileSystem.
- */
-async function detectRepoStructure(url: string): Promise<DetectResponse> {
-  const sandbox = await Sandbox.create({
-    source: {
-      url,
-      type: 'git',
-    },
-    resources: { vcpus: 2 },
-    timeout: 60 * 1000, // 1 minute
-    runtime: 'node22',
-  });
-
-  try {
-    // Create SDK FileSystem abstraction for sandbox
-    const fs = new SandboxFileSystem(sandbox);
-
-    // Use SDK detection functions
-    const [monoInfo, pmInfo] = await Promise.all([sdkDetectMonorepo(fs), detectPackageManager(fs)]);
-
-    if (!monoInfo.isMonorepo) {
-      return {
-        isMonorepo: false,
-        packageManager: pmInfo.name,
-      };
-    }
-
-    // Map SDK package info to API response format
-    const packages: PackageInfo[] = monoInfo.packages
-      .filter((p) => !p.private)
-      .map((p) => ({
-        name: p.name,
-        path: p.path,
-        description: p.description,
-      }))
-      .sort((a, b) => a.name.localeCompare(b.name));
-
-    return {
-      isMonorepo: true,
-      packageManager: pmInfo.name,
-      packages,
-      defaultPackage: packages[0]?.name,
-    };
-  } finally {
-    await sandbox.stop();
-  }
-}