gsd-trae 1.0.0 → 1.0.2

package/refs/vbenchmark/packages/leaderboard/src/routes/live.ts

@@ -1,175 +0,0 @@
-import { Hono } from 'hono';
-import { streamSSE } from 'hono/streaming';
-
-const liveRoutes = new Hono();
-
-// Store for active runs (in production, use Redis pub/sub)
-interface LiveRun {
-  id: string;
-  agentName: string;
-  taskId: string;
-  status: 'initializing' | 'running' | 'evaluating' | 'completed' | 'failed';
-  progress: number;
-  currentStep: string;
-  metrics: {
-    tokensUsed: number;
-    filesRead: number;
-    filesWritten: number;
-    testsPass: number;
-    testsFail: number;
-    elapsedMs: number;
-  };
-  startedAt: string;
-  logs: Array<{ timestamp: string; message: string }>;
-}
-
-const activeRuns = new Map<string, LiveRun>();
-
-// Get all active runs
-liveRoutes.get('/runs', async (c) => {
-  const runs = Array.from(activeRuns.values());
-  return c.json({
-    runs,
-    totalActive: runs.length,
-  });
-});
-
-// Get specific run status
-liveRoutes.get('/runs/:id', async (c) => {
-  const id = c.req.param('id');
-  const run = activeRuns.get(id);
-
-  if (!run) {
-    return c.json({ error: 'Run not found' }, 404);
-  }
-
-  return c.json(run);
-});
-
-// Start a new live run
-liveRoutes.post('/runs', async (c) => {
-  const body = await c.req.json<{ agentName: string; taskId: string }>();
-
-  const run: LiveRun = {
-    id: crypto.randomUUID(),
-    agentName: body.agentName,
-    taskId: body.taskId,
-    status: 'initializing',
-    progress: 0,
-    currentStep: 'Setting up environment',
-    metrics: {
-      tokensUsed: 0,
-      filesRead: 0,
-      filesWritten: 0,
-      testsPass: 0,
-      testsFail: 0,
-      elapsedMs: 0,
-    },
-    startedAt: new Date().toISOString(),
-    logs: [],
-  };
-
-  activeRuns.set(run.id, run);
-
-  return c.json(run, 201);
-});
-
-// Update run status (called by CLI)
-liveRoutes.patch('/runs/:id', async (c) => {
-  const id = c.req.param('id');
-  const run = activeRuns.get(id);
-
-  if (!run) {
-    return c.json({ error: 'Run not found' }, 404);
-  }
-
-  const body = await c.req.json<Partial<LiveRun>>();
-
-  if (body.status) run.status = body.status;
-  if (body.progress !== undefined) run.progress = body.progress;
-  if (body.currentStep) run.currentStep = body.currentStep;
-  if (body.metrics) run.metrics = { ...run.metrics, ...body.metrics };
-  if (body.logs) {
-    run.logs.push(...body.logs);
-    // Keep only last 100 logs
-    if (run.logs.length > 100) {
-      run.logs = run.logs.slice(-100);
-    }
-  }
-
-  activeRuns.set(id, run);
-
-  return c.json(run);
-});
-
-// End run
-liveRoutes.delete('/runs/:id', async (c) => {
-  const id = c.req.param('id');
-
-  if (!activeRuns.has(id)) {
-    return c.json({ error: 'Run not found' }, 404);
-  }
-
-  activeRuns.delete(id);
-
-  return c.json({ status: 'removed' });
-});
-
-// SSE endpoint for real-time updates
-liveRoutes.get('/stream/:id', async (c) => {
-  const id = c.req.param('id');
-
-  return streamSSE(c, async (stream) => {
-    let lastUpdate = '';
-
-    while (true) {
-      const run = activeRuns.get(id);
-
-      if (!run) {
-        await stream.writeSSE({
-          event: 'end',
-          data: JSON.stringify({ reason: 'Run not found or completed' }),
-        });
-        break;
-      }
-
-      const currentUpdate = JSON.stringify(run);
-
-      if (currentUpdate !== lastUpdate) {
-        await stream.writeSSE({
-          event: 'update',
-          data: currentUpdate,
-        });
-        lastUpdate = currentUpdate;
-      }
-
-      if (run.status === 'completed' || run.status === 'failed') {
-        await stream.writeSSE({
-          event: 'end',
-          data: currentUpdate,
-        });
-        break;
-      }
-
-      await stream.sleep(1000);
-    }
-  });
-});
-
-// SSE endpoint for all active runs
-liveRoutes.get('/stream', async (c) => {
-  return streamSSE(c, async (stream) => {
-    while (true) {
-      const runs = Array.from(activeRuns.values());
-
-      await stream.writeSSE({
-        event: 'update',
-        data: JSON.stringify({ runs, totalActive: runs.length }),
-      });
-
-      await stream.sleep(2000);
-    }
-  });
-});
-
-export { liveRoutes };

package/refs/vbenchmark/packages/leaderboard/src/routes/submissions.ts

@@ -1,183 +0,0 @@
-import { Hono } from 'hono';
-import { z } from 'zod';
-import { zValidator } from '@hono/zod-validator';
-
-const submissionsRoutes = new Hono();
-
-// In-memory store for demo (replace with database in production)
-const submissions: Submission[] = [];
-
-interface Submission {
-  id: string;
-  agentName: string;
-  agentVersion: string;
-  taskId: string;
-  status: 'pending' | 'running' | 'completed' | 'failed';
-  scores: {
-    functional: number;
-    visual: number;
-    quality: number;
-    security: number;
-    cost: number;
-    speed: number;
-    overall: number;
-  } | null;
-  metrics: {
-    tokensUsed: number;
-    filesRead: number;
-    filesWritten: number;
-    executionTimeMs: number;
-  } | null;
-  createdAt: string;
-  completedAt: string | null;
-}
-
-const createSubmissionSchema = z.object({
-  agentName: z.string().min(1),
-  agentVersion: z.string().min(1),
-  taskId: z.string().min(1),
-});
-
-const updateSubmissionSchema = z.object({
-  status: z.enum(['pending', 'running', 'completed', 'failed']).optional(),
-  scores: z.object({
-    functional: z.number().min(0).max(100),
-    visual: z.number().min(0).max(100),
-    quality: z.number().min(0).max(100),
-    security: z.number().min(0).max(100),
-    cost: z.number().min(0).max(100),
-    speed: z.number().min(0).max(100),
-    overall: z.number().min(0).max(100),
-  }).optional(),
-  metrics: z.object({
-    tokensUsed: z.number(),
-    filesRead: z.number(),
-    filesWritten: z.number(),
-    executionTimeMs: z.number(),
-  }).optional(),
-});
-
-// Create submission
-submissionsRoutes.post(
-  '/',
-  zValidator('json', createSubmissionSchema),
-  async (c) => {
-    const body = c.req.valid('json');
-
-    const submission: Submission = {
-      id: crypto.randomUUID(),
-      agentName: body.agentName,
-      agentVersion: body.agentVersion,
-      taskId: body.taskId,
-      status: 'pending',
-      scores: null,
-      metrics: null,
-      createdAt: new Date().toISOString(),
-      completedAt: null,
-    };
-
-    submissions.push(submission);
-
-    return c.json(submission, 201);
-  }
-);
-
-// List submissions
-submissionsRoutes.get('/', async (c) => {
-  const agentName = c.req.query('agent');
-  const taskId = c.req.query('task');
-  const status = c.req.query('status');
-
-  let filtered = submissions;
-
-  if (agentName) {
-    filtered = filtered.filter((s) => s.agentName === agentName);
-  }
-  if (taskId) {
-    filtered = filtered.filter((s) => s.taskId === taskId);
-  }
-  if (status) {
-    filtered = filtered.filter((s) => s.status === status);
-  }
-
-  return c.json({
-    submissions: filtered,
-    total: filtered.length,
-  });
-});
-
-// Get submission by ID
-submissionsRoutes.get('/:id', async (c) => {
-  const id = c.req.param('id');
-  const submission = submissions.find((s) => s.id === id);
-
-  if (!submission) {
-    return c.json({ error: 'Submission not found' }, 404);
-  }
-
-  return c.json(submission);
-});
-
-// Update submission
-submissionsRoutes.patch(
-  '/:id',
-  zValidator('json', updateSubmissionSchema),
-  async (c) => {
-    const id = c.req.param('id');
-    const body = c.req.valid('json');
-
-    const index = submissions.findIndex((s) => s.id === id);
-
-    if (index === -1) {
-      return c.json({ error: 'Submission not found' }, 404);
-    }
-
-    const submission = submissions[index];
-
-    if (body.status) {
-      submission.status = body.status;
-      if (body.status === 'completed' || body.status === 'failed') {
-        submission.completedAt = new Date().toISOString();
-      }
-    }
-    if (body.scores) {
-      submission.scores = {
-        functional: body.scores.functional,
-        visual: body.scores.visual,
-        quality: body.scores.quality,
-        security: body.scores.security,
-        cost: body.scores.cost,
-        speed: body.scores.speed,
-        overall: body.scores.overall,
-      };
-    }
-    if (body.metrics) {
-      submission.metrics = {
-        tokensUsed: body.metrics.tokensUsed,
-        filesRead: body.metrics.filesRead,
-        filesWritten: body.metrics.filesWritten,
-        executionTimeMs: body.metrics.executionTimeMs,
-      };
-    }
-
-    submissions[index] = submission;
-
-    return c.json(submission);
-  }
-);
-
-// Delete submission
-submissionsRoutes.delete('/:id', async (c) => {
-  const id = c.req.param('id');
-  const index = submissions.findIndex((s) => s.id === id);
-
-  if (index === -1) {
-    return c.json({ error: 'Submission not found' }, 404);
-  }
-
-  submissions.splice(index, 1);
-
-  return c.json({ status: 'deleted' });
-});
-
-export { submissionsRoutes };

package/refs/vbenchmark/packages/leaderboard/src/routes/tasks.ts

@@ -1,215 +0,0 @@
-import { Hono } from 'hono';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as yaml from 'yaml';
-
-const tasksRoutes = new Hono();
-
-interface TaskTests {
-  functional?: string;
-  visual?: string;
-  security?: string;
-}
-
-interface TaskLinks {
-  prompt: string;
-  tests: { [key: string]: string };
-  taskYaml: string;
-  directory: string;
-}
-
-interface Task {
-  id: string;
-  name: string;
-  category: string;
-  subcategory: string;
-  description: string;
-  difficulty: 'easy' | 'medium' | 'hard';
-  stack: string;
-  timeout: number;
-  tokenLimit: number;
-  tags: string[];
-  weight: number;
-  tests: TaskTests;
-  promptFile: string;
-  links: TaskLinks;
-}
-
-const GITHUB_BASE_URL = 'https://github.com/alt-research/vibe-coding-benchmark-public/blob/master/tasks';
-
-interface TasksByCategory {
-  [category: string]: Task[];
-}
-
-// Cache for tasks
-let tasksCache: Task[] | null = null;
-let lastCacheTime = 0;
-const CACHE_TTL_MS = 60000; // 1 minute
-
-// Find tasks directory (relative to package)
-function getTasksDir(): string {
-  // Try common locations relative to cwd
-  const candidates = [
-    path.join(process.cwd(), '../../tasks'),
-    path.join(process.cwd(), '../../../tasks'),
-    path.join(process.cwd(), 'tasks'),
-  ];
-  return candidates[0]; // Default to relative path
-}
-
-async function loadAllTasks(): Promise<Task[]> {
-  const now = Date.now();
-  if (tasksCache && now - lastCacheTime < CACHE_TTL_MS) {
-    return tasksCache;
-  }
-
-  const tasks: Task[] = [];
-  const tasksDir = getTasksDir();
-
-  async function scanDirectory(dir: string, prefix: string = ''): Promise<void> {
-    try {
-      const entries = await fs.readdir(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (!entry.isDirectory()) continue;
-        const fullPath = path.join(dir, entry.name);
-        const taskId = prefix ? `${prefix}/${entry.name}` : entry.name;
-        const taskYaml = path.join(fullPath, 'task.yaml');
-
-        try {
-          await fs.access(taskYaml);
-          const content = await fs.readFile(taskYaml, 'utf-8');
-          const parsed = yaml.parse(content);
-
-          // Build test links (only for files that exist)
-          const tests: TaskTests = parsed.tests || {};
-          const testLinks: { [key: string]: string } = {};
-          for (const [testType, testPath] of Object.entries(tests)) {
-            if (testPath) {
-              const testFilePath = path.join(fullPath, testPath as string);
-              try {
-                await fs.access(testFilePath);
-                testLinks[testType] = `${GITHUB_BASE_URL}/${taskId}/${testPath}`;
-              } catch {
-                // Test file doesn't exist, skip link
-              }
-            }
-          }
-
-          // Build all links
-          const promptFile = parsed.promptFile || 'PROMPT.md';
-          const links: TaskLinks = {
-            prompt: `${GITHUB_BASE_URL}/${taskId}/${promptFile}`,
-            tests: testLinks,
-            taskYaml: `${GITHUB_BASE_URL}/${taskId}/task.yaml`,
-            directory: `${GITHUB_BASE_URL}/${taskId}`,
-          };
-
-          tasks.push({
-            id: taskId,
-            name: parsed.name || taskId,
-            category: parsed.category || taskId.split('/')[0],
-            subcategory: parsed.subcategory || taskId.split('/')[1] || '',
-            description: parsed.description || '',
-            difficulty: parsed.difficulty || 'medium',
-            stack: parsed.stack || 'unknown',
-            timeout: parsed.timeout || 300,
-            tokenLimit: parsed.tokenLimit || 100000,
-            tags: parsed.tags || [],
-            weight: parsed.weight || 1.0,
-            tests,
-            promptFile,
-            links,
-          });
-        } catch {
-          // Not a task directory, recurse
-          await scanDirectory(fullPath, taskId);
-        }
-      }
-    } catch (error) {
-      console.error(`Error scanning directory ${dir}:`, error);
-    }
-  }
-
-  try {
-    await scanDirectory(tasksDir);
-    tasks.sort((a, b) => {
-      if (a.category !== b.category) return a.category.localeCompare(b.category);
-      if (a.subcategory !== b.subcategory) return a.subcategory.localeCompare(b.subcategory);
-      return a.name.localeCompare(b.name);
-    });
-    tasksCache = tasks;
-    lastCacheTime = now;
-  } catch (error) {
-    console.error('Failed to load tasks:', error);
-  }
-
-  return tasks;
-}
-
-// Get all tasks
-tasksRoutes.get('/', async (c) => {
-  const tasks = await loadAllTasks();
-  const category = c.req.query('category');
-  const difficulty = c.req.query('difficulty');
-
-  let filtered = tasks;
-
-  if (category) {
-    filtered = filtered.filter(t => t.category === category);
-  }
-  if (difficulty) {
-    filtered = filtered.filter(t => t.difficulty === difficulty);
-  }
-
-  return c.json({
-    tasks: filtered,
-    total: filtered.length,
-    categories: [...new Set(tasks.map(t => t.category))],
-  });
-});
-
-// Get tasks grouped by category
-tasksRoutes.get('/by-category', async (c) => {
-  const tasks = await loadAllTasks();
-  const byCategory: TasksByCategory = {};
-
-  for (const task of tasks) {
-    if (!byCategory[task.category]) {
-      byCategory[task.category] = [];
-    }
-    byCategory[task.category].push(task);
-  }
-
-  const summary = Object.entries(byCategory).map(([category, tasks]) => ({
-    category,
-    count: tasks.length,
-    difficulties: {
-      easy: tasks.filter(t => t.difficulty === 'easy').length,
-      medium: tasks.filter(t => t.difficulty === 'medium').length,
-      hard: tasks.filter(t => t.difficulty === 'hard').length,
-    },
-    subcategories: [...new Set(tasks.map(t => t.subcategory))].filter(Boolean),
-  }));
-
-  return c.json({
-    categories: byCategory,
-    summary,
-    totalTasks: tasks.length,
-    totalCategories: Object.keys(byCategory).length,
-  });
-});
-
-// Get single task by ID
-tasksRoutes.get('/:taskId{.+}', async (c) => {
-  const taskId = c.req.param('taskId');
-  const tasks = await loadAllTasks();
-  const task = tasks.find(t => t.id === taskId);
-
-  if (!task) {
-    return c.json({ error: 'Task not found' }, 404);
-  }
-
-  return c.json(task);
-});
-
-export { tasksRoutes };