gsd-trae 1.0.0 → 1.0.2

package/refs/vbenchmark/packages/dashboard/src/main.tsx

@@ -1,13 +0,0 @@
-import React from 'react';
-import ReactDOM from 'react-dom/client';
-import { BrowserRouter } from 'react-router-dom';
-import App from './App';
-import './index.css';
-
-ReactDOM.createRoot(document.getElementById('root')!).render(
-  <React.StrictMode>
-    <BrowserRouter>
-      <App />
-    </BrowserRouter>
-  </React.StrictMode>
-);

package/refs/vbenchmark/packages/dashboard/src/vite-env.d.ts

@@ -1,9 +0,0 @@
-/// <reference types="vite/client" />
-
-interface ImportMetaEnv {
-  readonly VITE_API_URL: string;
-}
-
-interface ImportMeta {
-  readonly env: ImportMetaEnv;
-}

package/refs/vbenchmark/packages/dashboard/tailwind.config.js

@@ -1,11 +0,0 @@
-/** @type {import('tailwindcss').Config} */
-export default {
-  content: [
-    "./index.html",
-    "./src/**/*.{js,ts,jsx,tsx}",
-  ],
-  theme: {
-    extend: {},
-  },
-  plugins: [],
-}

package/refs/vbenchmark/packages/dashboard/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "useDefineForClassFields": true,
-    "lib": ["ES2020", "DOM", "DOM.Iterable"],
-    "module": "ESNext",
-    "skipLibCheck": true,
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "noEmit": true,
-    "jsx": "react-jsx",
-    "strict": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "noFallthroughCasesInSwitch": true
-  },
-  "include": ["src"],
-  "references": [{ "path": "./tsconfig.node.json" }]
-}

package/refs/vbenchmark/packages/dashboard/tsconfig.node.json

@@ -1,11 +0,0 @@
-{
-  "compilerOptions": {
-    "composite": true,
-    "skipLibCheck": true,
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "allowSyntheticDefaultImports": true,
-    "strict": true
-  },
-  "include": ["vite.config.ts"]
-}

package/refs/vbenchmark/packages/dashboard/vercel.json

@@ -1,6 +0,0 @@
-{
-  "buildCommand": "npm run build",
-  "outputDirectory": "dist",
-  "framework": "vite",
-  "installCommand": "npm install"
-}

package/refs/vbenchmark/packages/dashboard/vite.config.ts

@@ -1,28 +0,0 @@
-import { defineConfig } from 'vite';
-import react from '@vitejs/plugin-react';
-
-export default defineConfig({
-  plugins: [react()],
-  // For custom domain, base is '/'
-  base: '/',
-  build: {
-    outDir: 'dist',
-    sourcemap: false,
-    // Optimize for production (esbuild is faster and bundled with Vite)
-    minify: 'esbuild',
-    rollupOptions: {
-      output: {
-        manualChunks: {
-          'chart': ['chart.js', 'react-chartjs-2'],
-          'react-vendor': ['react', 'react-dom', 'react-router-dom'],
-        },
-      },
-    },
-  },
-  server: {
-    port: 9011,
-    allowedHosts: [
-      'vibecoding.llmbench.xyz',
-    ],
-  },
-});

package/refs/vbenchmark/packages/evaluator/eslint.config.js

@@ -1,16 +0,0 @@
-import js from '@eslint/js';
-import tseslint from 'typescript-eslint';
-
-export default tseslint.config(
-  js.configs.recommended,
-  ...tseslint.configs.recommended,
-  {
-    ignores: ['dist/**', 'node_modules/**'],
-  },
-  {
-    rules: {
-      '@typescript-eslint/no-unused-vars': ['error', { argsIgnorePattern: '^_', varsIgnorePattern: '^_' }],
-      '@typescript-eslint/no-explicit-any': 'off',
-    },
-  }
-);

package/refs/vbenchmark/packages/evaluator/package.json

@@ -1,24 +0,0 @@
-{
-  "name": "@vibecodingbench/evaluator",
-  "version": "0.1.0",
-  "description": "Evaluation engine for VibeCodingBench",
-  "main": "dist/index.js",
-  "scripts": {
-    "build": "tsc",
-    "dev": "tsc --watch",
-    "test": "vitest run --passWithNoTests",
-    "lint": "eslint src/"
-  },
-  "dependencies": {
-    "drizzle-kit": "^0.31.8",
-    "pixelmatch": "^6.0.0",
-    "playwright": "^1.48.0",
-    "pngjs": "^7.0.0",
-    "vite": "7.3.1"
-  },
-  "devDependencies": {
-    "@types/pngjs": "^6.0.0",
-    "eslint": "^9.0.0",
-    "vitest": "^4.0.17"
-  }
-}

package/refs/vbenchmark/packages/evaluator/src/index.ts

@@ -1,15 +0,0 @@
-export { FunctionalRunner } from './runners/functional.js';
-export { SecurityRunner } from './runners/security.js';
-export { QualityRunner } from './runners/quality.js';
-export { VisualRunner } from './runners/visual.js';
-
-export interface EvaluationResult {
-  score: number;
-  maxScore: number;
-  details: Record<string, unknown>;
-}
-
-export interface RunnerOptions {
-  workspacePath: string;
-  timeout?: number;
-}

package/refs/vbenchmark/packages/evaluator/src/runners/functional.ts

@@ -1,88 +0,0 @@
-import { spawn } from 'child_process';
-import * as path from 'path';
-import type { EvaluationResult, RunnerOptions } from '../index.js';
-
-export class FunctionalRunner {
-  async run(testPath: string, options: RunnerOptions): Promise<EvaluationResult> {
-    const ext = path.extname(testPath);
-
-    let command: string;
-    let args: string[];
-
-    switch (ext) {
-      case '.ts':
-      case '.js':
-        command = 'npx';
-        args = ['vitest', 'run', testPath, '--reporter=json'];
-        break;
-      case '.py':
-        command = 'python';
-        args = ['-m', 'pytest', testPath, '--json-report', '--json-report-file=-'];
-        break;
-      case '.go':
-        command = 'go';
-        args = ['test', '-json', testPath];
-        break;
-      default:
-        return { score: 0, maxScore: 100, details: { error: `Unsupported test type: ${ext}` } };
-    }
-
-    return new Promise((resolve) => {
-      const proc = spawn(command, args, {
-        cwd: options.workspacePath,
-        timeout: options.timeout || 60000
-      });
-
-      let stdout = '';
-      let stderr = '';
-
-      proc.stdout.on('data', (data) => { stdout += data; });
-      proc.stderr.on('data', (data) => { stderr += data; });
-
-      proc.on('close', (code) => {
-        if (code === 0) {
-          resolve({ score: 100, maxScore: 100, details: { passed: true, output: stdout } });
-        } else {
-          // Try to parse test output for partial credit
-          const passed = this.parseTestOutput(stdout, ext);
-          resolve({
-            score: passed.passed / passed.total * 100,
-            maxScore: 100,
-            details: { passed: passed.passed, total: passed.total, output: stdout, error: stderr }
-          });
-        }
-      });
-
-      proc.on('error', (err) => {
-        resolve({ score: 0, maxScore: 100, details: { error: err.message } });
-      });
-    });
-  }
-
-  private parseTestOutput(output: string, ext: string): { passed: number; total: number } {
-    try {
-      if (ext === '.ts' || ext === '.js') {
-        const json = JSON.parse(output);
-        return {
-          passed: json.numPassedTests || 0,
-          total: json.numTotalTests || 1
-        };
-      }
-      if (ext === '.py') {
-        const json = JSON.parse(output);
-        return {
-          passed: json.summary?.passed || 0,
-          total: json.summary?.total || 1
-        };
-      }
-    } catch {
-      // Fall back to regex parsing
-      const passMatch = output.match(/(\d+) passed/);
-      const failMatch = output.match(/(\d+) failed/);
-      const passed = passMatch ? parseInt(passMatch[1]) : 0;
-      const failed = failMatch ? parseInt(failMatch[1]) : 0;
-      return { passed, total: passed + failed || 1 };
-    }
-    return { passed: 0, total: 1 };
-  }
-}

package/refs/vbenchmark/packages/evaluator/src/runners/quality.ts

@@ -1,140 +0,0 @@
-import { spawn } from 'child_process';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import type { EvaluationResult, RunnerOptions } from '../index.js';
-
-interface QualityMetrics {
-  lintErrors: number;
-  lintWarnings: number;
-  complexity: number;
-  duplications: number;
-}
-
-export class QualityRunner {
-  async run(options: RunnerOptions): Promise<EvaluationResult & { metrics: QualityMetrics }> {
-    const files = await this.findSourceFiles(options.workspacePath);
-
-    let lintErrors = 0;
-    let lintWarnings = 0;
-
-    // Run appropriate linter based on file types
-    const hasTs = files.some(f => f.endsWith('.ts') || f.endsWith('.tsx'));
-    const hasPy = files.some(f => f.endsWith('.py'));
-    const hasGo = files.some(f => f.endsWith('.go'));
-
-    if (hasTs) {
-      const result = await this.runEslint(options.workspacePath);
-      lintErrors += result.errors;
-      lintWarnings += result.warnings;
-    }
-
-    if (hasPy) {
-      const result = await this.runRuff(options.workspacePath);
-      lintErrors += result.errors;
-      lintWarnings += result.warnings;
-    }
-
-    if (hasGo) {
-      const result = await this.runGolangci(options.workspacePath);
-      lintErrors += result.errors;
-      lintWarnings += result.warnings;
-    }
-
-    const metrics: QualityMetrics = {
-      lintErrors,
-      lintWarnings,
-      complexity: 0, // TODO: Calculate cyclomatic complexity
-      duplications: 0 // TODO: Detect code duplication
-    };
-
-    // Scoring: start at 100, deduct for issues
-    let score = 100;
-    score -= lintErrors * 5; // 5 points per error
-    score -= lintWarnings * 1; // 1 point per warning
-    score = Math.max(0, score);
-
-    return {
-      score,
-      maxScore: 100,
-      metrics,
-      details: { files: files.length, lintErrors, lintWarnings }
-    };
-  }
-
-  private async findSourceFiles(dir: string): Promise<string[]> {
-    const files: string[] = [];
-    const extensions = ['.ts', '.tsx', '.js', '.jsx', '.py', '.go', '.rs'];
-
-    async function scan(d: string) {
-      try {
-        const entries = await fs.readdir(d, { withFileTypes: true });
-        for (const entry of entries) {
-          if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
-          const full = path.join(d, entry.name);
-          if (entry.isDirectory()) {
-            await scan(full);
-          } else if (extensions.some(ext => entry.name.endsWith(ext))) {
-            files.push(full);
-          }
-        }
-      } catch {
-        // Skip inaccessible directories
-      }
-    }
-
-    await scan(dir);
-    return files;
-  }
-
-  private runEslint(cwd: string): Promise<{ errors: number; warnings: number }> {
-    return this.runLinter('npx', ['eslint', '.', '--format=json'], cwd, (output) => {
-      try {
-        const json = JSON.parse(output);
-        return {
-          errors: json.reduce((a: number, f: { errorCount: number }) => a + f.errorCount, 0),
-          warnings: json.reduce((a: number, f: { warningCount: number }) => a + f.warningCount, 0)
-        };
-      } catch {
-        return { errors: 0, warnings: 0 };
-      }
-    });
-  }
-
-  private runRuff(cwd: string): Promise<{ errors: number; warnings: number }> {
-    return this.runLinter('ruff', ['check', '.', '--output-format=json'], cwd, (output) => {
-      try {
-        const json = JSON.parse(output);
-        return { errors: json.length, warnings: 0 };
-      } catch {
-        return { errors: 0, warnings: 0 };
-      }
-    });
-  }
-
-  private runGolangci(cwd: string): Promise<{ errors: number; warnings: number }> {
-    return this.runLinter('golangci-lint', ['run', '--out-format=json'], cwd, (output) => {
-      try {
-        const json = JSON.parse(output);
-        return { errors: json.Issues?.length || 0, warnings: 0 };
-      } catch {
-        return { errors: 0, warnings: 0 };
-      }
-    });
-  }
-
-  private runLinter(
-    cmd: string,
-    args: string[],
-    cwd: string,
-    parser: (output: string) => { errors: number; warnings: number }
-  ): Promise<{ errors: number; warnings: number }> {
-    return new Promise((resolve) => {
-      const proc = spawn(cmd, args, { cwd, timeout: 60000 });
-      let stdout = '';
-
-      proc.stdout.on('data', (data) => { stdout += data; });
-      proc.on('close', () => resolve(parser(stdout)));
-      proc.on('error', () => resolve({ errors: 0, warnings: 0 }));
-    });
-  }
-}

package/refs/vbenchmark/packages/evaluator/src/runners/security.ts

@@ -1,94 +0,0 @@
-import { spawn } from 'child_process';
-import type { EvaluationResult, RunnerOptions } from '../index.js';
-
-interface SecurityIssue {
-  severity: 'critical' | 'high' | 'medium' | 'low' | 'info';
-  rule: string;
-  message: string;
-  file: string;
-  line: number;
-}
-
-export class SecurityRunner {
-  async run(options: RunnerOptions): Promise<EvaluationResult & { issues: SecurityIssue[] }> {
-    return new Promise((resolve) => {
-      // Use Semgrep for security scanning
-      const proc = spawn('semgrep', [
-        '--config=p/owasp-top-ten',
-        '--json',
-        options.workspacePath
-      ], {
-        timeout: options.timeout || 120000
-      });
-
-      let stdout = '';
-      let _stderr = '';
-
-      proc.stdout.on('data', (data) => { stdout += data; });
-      proc.stderr.on('data', (data) => { _stderr += data; });
-
-      proc.on('close', (_code) => {
-        const issues = this.parseSemgrepOutput(stdout);
-        const critical = issues.filter(i => i.severity === 'critical' || i.severity === 'high');
-
-        // Any critical/high = fail
-        if (critical.length > 0) {
-          resolve({
-            score: 0,
-            maxScore: 100,
-            issues,
-            details: { passed: false, critical: critical.length, total: issues.length }
-          });
-        } else {
-          // Deduct points for medium/low issues
-          const deduction = issues.reduce((acc, i) => {
-            if (i.severity === 'medium') return acc + 10;
-            if (i.severity === 'low') return acc + 5;
-            return acc;
-          }, 0);
-
-          resolve({
-            score: Math.max(0, 100 - deduction),
-            maxScore: 100,
-            issues,
-            details: { passed: true, issues: issues.length }
-          });
-        }
-      });
-
-      proc.on('error', () => {
-        // Semgrep not installed - skip security checks
-        resolve({
-          score: 100,
-          maxScore: 100,
-          issues: [],
-          details: { skipped: true, reason: 'Semgrep not available' }
-        });
-      });
-    });
-  }
-
-  private parseSemgrepOutput(output: string): SecurityIssue[] {
-    try {
-      const json = JSON.parse(output);
-      return (json.results || []).map((r: Record<string, unknown>) => ({
-        severity: this.mapSeverity(r.extra as Record<string, unknown>),
-        rule: r.check_id as string,
-        message: (r.extra as Record<string, unknown>)?.message as string || '',
-        file: r.path as string,
-        line: (r.start as Record<string, number>)?.line || 0
-      }));
-    } catch {
-      return [];
-    }
-  }
-
-  private mapSeverity(extra: Record<string, unknown>): SecurityIssue['severity'] {
-    const severity = (extra?.severity as string)?.toLowerCase() || 'info';
-    if (severity.includes('critical') || severity.includes('error')) return 'critical';
-    if (severity.includes('high') || severity.includes('warning')) return 'high';
-    if (severity.includes('medium')) return 'medium';
-    if (severity.includes('low')) return 'low';
-    return 'info';
-  }
-}

package/refs/vbenchmark/packages/evaluator/src/runners/visual.ts

@@ -1,108 +0,0 @@
-import { PNG } from 'pngjs';
-import pixelmatch from 'pixelmatch';
-import * as fs from 'fs/promises';
-import type { EvaluationResult, RunnerOptions } from '../index.js';
-
-export interface VisualRunnerOptions extends RunnerOptions {
-  referenceImage: string;
-  capturedImage: string;
-  threshold?: number; // Default 0.1 (10% tolerance)
-  breakpoints?: number[]; // Viewport widths to test
-}
-
-export class VisualRunner {
-  async run(options: VisualRunnerOptions): Promise<EvaluationResult> {
-    try {
-      const [refBuffer, capBuffer] = await Promise.all([
-        fs.readFile(options.referenceImage),
-        fs.readFile(options.capturedImage)
-      ]);
-
-      const refPng = PNG.sync.read(refBuffer);
-      const capPng = PNG.sync.read(capBuffer);
-
-      // Resize if dimensions don't match
-      if (refPng.width !== capPng.width || refPng.height !== capPng.height) {
-        return {
-          score: 0,
-          maxScore: 100,
-          details: {
-            error: 'Image dimensions do not match',
-            reference: { width: refPng.width, height: refPng.height },
-            captured: { width: capPng.width, height: capPng.height }
-          }
-        };
-      }
-
-      const { width, height } = refPng;
-      const diff = new PNG({ width, height });
-
-      const mismatchedPixels = pixelmatch(
-        refPng.data,
-        capPng.data,
-        diff.data,
-        width,
-        height,
-        { threshold: options.threshold || 0.1 }
-      );
-
-      const totalPixels = width * height;
-      const matchPercentage = ((totalPixels - mismatchedPixels) / totalPixels) * 100;
-
-      // Save diff image for debugging
-      const diffPath = options.capturedImage.replace(/\.[^.]+$/, '.diff.png');
-      await fs.writeFile(diffPath, PNG.sync.write(diff));
-
-      return {
-        score: Math.round(matchPercentage * 10) / 10,
-        maxScore: 100,
-        details: {
-          mismatchedPixels,
-          totalPixels,
-          matchPercentage,
-          diffImage: diffPath
-        }
-      };
-    } catch (error) {
-      return {
-        score: 0,
-        maxScore: 100,
-        details: { error: String(error) }
-      };
-    }
-  }
-
-  async runResponsive(options: VisualRunnerOptions): Promise<EvaluationResult> {
-    const breakpoints = options.breakpoints || [375, 768, 1440];
-    const results: Array<{ breakpoint: number; score: number }> = [];
-
-    for (const bp of breakpoints) {
-      const refImage = options.referenceImage.replace(/\.[^.]+$/, `-${bp}$&`);
-      const capImage = options.capturedImage.replace(/\.[^.]+$/, `-${bp}$&`);
-
-      try {
-        await fs.access(refImage);
-        await fs.access(capImage);
-
-        const result = await this.run({
-          ...options,
-          referenceImage: refImage,
-          capturedImage: capImage
-        });
-
-        results.push({ breakpoint: bp, score: result.score });
-      } catch {
-        // Skip missing breakpoint images
-        results.push({ breakpoint: bp, score: 0 });
-      }
-    }
-
-    const avgScore = results.reduce((a, r) => a + r.score, 0) / results.length;
-
-    return {
-      score: Math.round(avgScore * 10) / 10,
-      maxScore: 100,
-      details: { breakpoints: results }
-    };
-  }
-}

package/refs/vbenchmark/packages/evaluator/src/types.d.ts

@@ -1,19 +0,0 @@
-declare module 'pixelmatch' {
-  function pixelmatch(
-    img1: Buffer | Uint8Array,
-    img2: Buffer | Uint8Array,
-    output: Buffer | Uint8Array | null,
-    width: number,
-    height: number,
-    options?: {
-      threshold?: number;
-      includeAA?: boolean;
-      alpha?: number;
-      aaColor?: [number, number, number];
-      diffColor?: [number, number, number];
-      diffColorAlt?: [number, number, number];
-      diffMask?: boolean;
-    }
-  ): number;
-  export = pixelmatch;
-}

package/refs/vbenchmark/packages/evaluator/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "dist",
-    "rootDir": "src"
-  },
-  "include": ["src/**/*"]
-}

package/refs/vbenchmark/packages/leaderboard/Dockerfile

@@ -1,38 +0,0 @@
-FROM node:20-alpine AS builder
-
-WORKDIR /app
-
-# Copy package files
-COPY package.json ./
-
-# Install dependencies
-RUN npm install
-
-# Copy source
-COPY tsconfig.docker.json ./tsconfig.json
-COPY src/ ./src/
-
-# Build
-RUN npm run build
-
-# Production image
-FROM node:20-alpine
-
-WORKDIR /app
-
-# Copy package files
-COPY package.json ./
-
-# Install production dependencies only
-RUN npm install --omit=dev
-
-# Copy built files
-COPY --from=builder /app/dist ./dist
-
-# Environment
-ENV NODE_ENV=production
-ENV PORT=3001
-
-EXPOSE 3001
-
-CMD ["node", "dist/index.js"]

package/refs/vbenchmark/packages/leaderboard/drizzle.config.ts

@@ -1,10 +0,0 @@
-import type { Config } from 'drizzle-kit';
-
-export default {
-  schema: './src/db/schema.ts',
-  out: './drizzle',
-  driver: 'pg',
-  dbCredentials: {
-    connectionString: process.env.DATABASE_URL || 'postgresql://localhost:5432/vibecodingbench',
-  },
-} satisfies Config;