react-doctor-cli-dev 1.0.0

package/core/static-ana/static/scanner.ts

@@ -0,0 +1,93 @@
+import { glob } from "glob";
+import path from "path";
+
+export interface ScannedFile {
+  path: string;           // Full absolute path
+  relativePath: string;   // Relative to project root
+  name: string;           // Filename only
+  extension: string;      // .tsx or .jsx
+}
+
+export class FileScanner {
+  /**
+   * Find all React component files (.jsx, .tsx) in a project
+   * @param projectPath - Absolute or relative path to React project root
+   * @returns Array of scanned file metadata
+   */
+  async findFiles(projectPath: string): Promise<ScannedFile[]> {
+    // 1. Ensure the path is absolute and uses forward slashes
+    const normalizedPath = path.resolve(projectPath).replace(/\\/g, "/");
+
+    // 2. Try to scan src/ folder first (standard React location)
+    const srcPattern = `${normalizedPath}/src/**/*.{ts,js,jsx,tsx}`;
+    
+    try {
+      // 3. Run the glob search (focusing on src/ folder)
+      let files = await glob(srcPattern, {
+        ignore: [
+          "**/node_modules/**",
+          "**/dist/**",
+          "**/build/**",
+          "**/.next/**",
+          "**/coverage/**",
+          "**/*.test.{jsx,tsx}",     // Skip test files
+          "**/*.spec.{jsx,tsx}",     // Skip spec files
+          "**/*.stories.{jsx,tsx}",  // Skip Storybook files
+        ],
+        nodir: true,    // We only want files, not folders
+        absolute: true, // Return absolute paths
+      });
+
+      // 4. If no files found in src/, try scanning entire project as fallback
+      if (files.length === 0) {
+        console.warn(`⚠️  No files found in src/, scanning entire project...`);
+        const rootPattern = `${normalizedPath}/**/*.{ts,js,jsx,tsx}`;
+        
+        files = await glob(rootPattern, {
+          ignore: [
+            "**/node_modules/**",
+            "**/dist/**",
+            "**/build/**",
+            "**/.next/**",
+            "**/coverage/**",
+            "**/*.test.{jsx,tsx}",
+            "**/*.spec.{jsx,tsx}",
+            "**/*.stories.{jsx,tsx}",
+          ],
+          nodir: true,
+          absolute: true,
+        });
+      }
+
+      console.log(`✅ Found ${files.length} React component files`);
+
+      // 5. Map to structured metadata
+      return files.map(filePath => ({
+        path: filePath,
+        relativePath: path.relative(normalizedPath, filePath),
+        name: path.basename(filePath),
+        extension: path.extname(filePath),
+      }));
+
+    } catch (error) {
+      console.error("❌ Scanner Error:", error);
+      throw new Error(`Failed to scan files: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+
+  /**
+   * Get statistics about scanned files
+   */
+  getStats(files: ScannedFile[]): {
+    total: number;
+    byExtension: Record<string, number>;
+  } {
+    return {
+      total: files.length,
+      byExtension: files.reduce((acc, file) => {
+        acc[file.extension] = (acc[file.extension] || 0) + 1;
+        return acc;
+      }, {} as Record<string, number>),
+    };
+  }
+}

package/core/static-ana/test-analyzer.ts

@@ -0,0 +1,115 @@
+import { FileScanner } from './static/scanner';
+import { StaticAnalyzer } from './static/analyzer';
+import path from 'path';
+
+export async function testCompleteAnalysis() {
+  console.log("\n" + "=".repeat(70));
+  console.log("🩺 React Doctor - Complete Static Analysis Test");
+  console.log("=".repeat(70));
+
+  try {
+    const scanner = new FileScanner();
+    const targetDir = path.join(process.cwd(), 'tests', 'mock-react-project');
+    
+    const files = await scanner.findFiles(targetDir);
+
+    if (files.length === 0) {
+      console.log("⚠️  No React files found!");
+      return;
+    }
+
+    const analyzer = new StaticAnalyzer();
+    const report = await analyzer.analyze(files);
+
+    // ======================================================================
+    // 🏆 NEW: HEALTH GRADE SECTION
+    // ======================================================================
+    console.log("\n" + "=".repeat(70));
+    console.log(`🏆 PROJECT HEALTH GRADE: ${report.grade}`);
+    console.log("=".repeat(70));
+    console.log(getDoctorRecommendation(report.grade));
+    console.log("=".repeat(70));
+
+    // Display basic stats
+    console.log(`\n📊 Analysis Summary:`);
+    console.log(`Timestamp: ${new Date(report.timestamp).toLocaleString()}`);
+    console.log(`Files analyzed: ${report.filesAnalyzed}`);
+    console.log(`Total issues: ${report.issues.length}`);
+
+    const summary = analyzer.getSummary(report);
+    console.log(`\n🎯 Issues by Severity:`);
+    console.log(`   🔴 Critical: ${summary.critical}`);
+    console.log(`   🟡 Warnings: ${summary.warnings}`);
+    console.log(`   🔵 Info: ${summary.info}`);
+
+    console.log(`\n🔍 Issues by Type:`);
+    Object.entries(summary.byDetector).forEach(([type, count]) => {
+      console.log(`   ${type.padEnd(10)}: ${count}`);
+    });
+
+    // Display issues with corrected math
+    const DISPLAY_LIMIT = 30;
+    if (report.issues.length > 0) {
+      console.log(`\n📋 Detailed Issues (showing up to ${DISPLAY_LIMIT}):`);
+      console.log("-".repeat(70));
+      
+      report.issues.slice(0, DISPLAY_LIMIT).forEach((issue, index) => {
+        console.log(`\n${index + 1}. ${issue.file}:${issue.line}:${issue.column || 0}`);
+        console.log(`   Component: ${issue.component}`);
+        console.log(`   Severity: ${getSeverityIcon(issue.severity)} ${issue.severity}`);
+        console.log(`   Message: ${issue.message}`);
+        console.log(`   💡 Fix: ${issue.suggestion}`);
+      });
+
+      // Fixed the negative math bug here:
+      if (report.issues.length > DISPLAY_LIMIT) {
+        console.log(`\n... and ${report.issues.length - DISPLAY_LIMIT} more issue(s)`);
+      }
+    } else {
+      console.log(`\n✨ No issues found! Your code is in peak condition!`);
+    }
+
+    console.log("\n" + "=".repeat(70));
+    const reportPath = analyzer.saveReport(report);
+    console.log("\n" + "=".repeat(70));
+    console.log(`💾 JSON Report saved to: ${path.basename(reportPath)}`);
+    console.log("=".repeat(70));
+
+  } catch (error) {
+    console.error("\n❌ Test Failed:");
+    console.error((error as Error).message);
+    process.exit(1);
+  }
+}
+
+function getSeverityIcon(severity: string): string {
+  switch (severity) {
+    case 'critical': return '🔴';
+    case 'warning': return '🟡';
+    case 'info': return '🔵';
+    default: return '⚪';
+  }
+}
+
+/**
+ * 🩺 Provides a clinical recommendation based on the grade
+ */
+function getDoctorRecommendation(grade: string): string {
+  switch (grade) {
+    case 'A+': case 'A': 
+      return "✅ DOCTOR'S NOTE: Excellent health. Continue with regular checkups.";
+    case 'B': 
+      return "🟡 DOCTOR'S NOTE: Minor congestion detected. Consider cleaning up warnings.";
+    case 'C': 
+      return "⚠️  DOCTOR'S NOTE: Chronic issues found. Technical debt is accumulating.";
+    case 'D': 
+      return "🟠 DOCTOR'S NOTE: Patient in poor condition. Immediate refactoring advised.";
+    case 'F': 
+      return "🚨 DOCTOR'S NOTE: CRITICAL CONDITION. Fix infinite loops and memory leaks immediately!";
+    default: 
+      return "🩺 DOCTOR'S NOTE: Analysis inconclusive.";
+  }
+}
+
+testCompleteAnalysis();
+

package/core/static-ana/types.ts

@@ -0,0 +1,25 @@
+/**
+ * Represents a single issue found in a component
+ */
+export interface ComponentIssue {
+  id: string;              // Unique identifier (e.g., "large-component-App.tsx-12")
+  component: string;       // Component name (e.g., "UserDashboard")
+  file: string;            // File path
+  line: number;            // Line number where issue was found
+  column?: number;         // Column number (optional)
+  severity: 'critical' | 'warning' | 'info';
+  message: string;         // What's wrong (e.g., "Component is 450 lines")
+  suggestion: string;      // How to fix it (e.g., "Split into smaller components")
+}
+
+/**
+ * Complete static analysis report
+ */
+export interface StaticReport {
+  timestamp: string;
+  componentCount: number;  // Number of components analyzed
+  issues: ComponentIssue[];
+  filesAnalyzed: number;
+  filesFailed: number;
+  grade: string;
+}

package/core/tests/mock-react-project/src/app.tsx

@@ -0,0 +1,22 @@
+import React from 'react';
+
+// This component has multiple issues for testing
+export default function App() {
+  console.log('App rendered'); // Issue: console.log
+  
+  return (
+    <div>
+      <h1>React Doctor Test App</h1>
+      
+      {/* Issue: Inline function */}
+      <button onClick={() => console.log('clicked')}>
+        Click Me
+      </button>
+      
+      {/* Another inline function */}
+      <button onClick={() => alert('test')}>
+        Alert
+      </button>
+    </div>
+  );
+}

package/core/tests/mock-react-project/src/components/Button.tsx

@@ -0,0 +1,9 @@
+export default function Button() {
+  console.warn('Button component');
+  
+  return (
+    <button onClick={() => console.log('inline')}>
+      Button
+    </button>
+  );
+}

package/core/tests/mock-react-project/src/components/Header.tsx

@@ -0,0 +1,3 @@
+export default function Header() {
+  return <header>Header Component</header>;
+}

package/core/tests/mock-react-project/src/components/ListTesting.tsx

@@ -0,0 +1,51 @@
+import React from 'react';
+
+export default function ListTesting() {
+  const items = ['Apple', 'Banana', 'Cherry'];
+
+  // 1. ❌ THE DISEASE: Map Failure
+  const renderMap = () => {
+    return items.map(item => (
+      <div>{item}</div> 
+      /* ✅ THE CURE: 
+         <div key={item}>{item}</div> 
+      */
+    ));
+  };
+
+  // 2. ❌ THE DISEASE: Literal Array Failure
+  const staticList = [
+    <span>First Item</span>,  
+    <span>Second Item</span>, 
+    /* ✅ THE CURE: 
+       <span key="first">First Item</span>,
+       <span key="second">Second Item</span>,
+    */
+  ];
+
+  return (
+    <div className="list-container">
+      {renderMap()}
+
+      <ul>
+        {/* 3. ❌ THE DISEASE: Array.from Failure */}
+        {Array.from({ length: 3 }).map((_, i) => (
+          <li>Item {i}</li> 
+          /* ✅ THE CURE: 
+             <li key={i}>Item {i}</li> 
+             (Note: Use 'i' only if the list order is static!)
+          */
+        ))}
+      </ul>
+
+      <div className="static-section">
+        {staticList}
+      </div>
+
+      {/* 4. ✨ HEALTHY: Should NOT be flagged by the Doctor */}
+      {items.map(item => (
+        <p key={item}>{item}</p>
+      ))}
+    </div>
+  );
+}

package/core/tests/mock-react-project/src/components/UserDashboard.tsx

@@ -0,0 +1,66 @@
+import React, { useState, useEffect } from 'react';
+import { fetchUser } from './api'; // Imagine this exists
+import { GhostData } from './data'; // DEAD CODE: Unused import
+
+/**
+ * 1. GRANDPARENT: Has the data
+ */
+export default function UserDashboard({ theme }) {
+  const [user, setUser] = useState({ name: 'Shaheen', role: 'Admin' });
+  const [ticks, setTicks] = useState(0);
+  const unusedSecret = "12345"; // DEAD CODE: Unused variable
+
+  console.log("Dashboard rendering..."); // CONSOLE LOG
+
+  // 2. INFINITE LOOP: Missing dependency array
+  useEffect(() => {
+    setTicks(ticks + 1);
+  });
+
+  return (
+    <div className="dashboard">
+      <h1>User Panel</h1>
+      {/* Passing 'user' to Content (Drilling starts here) */}
+      <Content user={user} theme={theme} />
+    </div>
+  );
+}
+
+/**
+ * 3. PARENT (The Middleman): PROP DRILLING candidate
+ * Receives 'user', doesn't use it, just passes it to Profile.
+ */
+function Content({ user, theme }) {
+  return (
+    <main 
+      // 4. LARGE INLINE STYLE: > 5 properties
+      style={{
+        margin: '20px',
+        padding: '10px',
+        border: '1px solid black',
+        borderRadius: '5px',
+        backgroundColor: '#f0f0f0',
+        display: 'flex',
+        flexDirection: 'column'
+      }}
+    >
+      <h2>Main Content</h2>
+      <Profile user={user} theme={theme} />
+    </main>
+  );
+}
+
+/**
+ * 5. CHILD: Finally uses the data
+ */
+function Profile({ user, theme }) {
+  return (
+    <div className={`profile-${theme}`}>
+      <p>Name: {user.name}</p>
+      {/* 6. INLINE FUNCTION */}
+      <button onClick={() => console.log('Deleted!')}>
+        Delete Account
+      </button>
+    </div>
+  );
+}

package/core/tests/mock-react-project/src/utils.ts

@@ -0,0 +1,4 @@
+// This should be ignored (not a React component)
+export function add(a: number, b: number) {
+  return a + b;
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "react-doctor-cli-dev",
+  "version": "1.0.0",
+  "description": "React performance analyzer with static analysis, runtime profiling, rule engine, and dashboard upload",
+  "main": "index.js",
+  "type": "commonjs",
+
+  "bin": {
+    "react-doctor": "./cli/bin/react-doctor.js"
+  },
+
+  "scripts": {},
+
+  "keywords": [
+    "react",
+    "performance",
+    "profiler",
+    "cli",
+    "analyzer"
+  ],
+
+  "author": "Ozma",
+  "license": "ISC",
+
+  "dependencies": {
+    "@babel/parser": "^7.29.0",
+    "@babel/traverse": "^7.29.0",
+    "@babel/types": "^7.29.0",
+    "axios": "^1.6.0",
+    "better-sqlite3": "^12.10.0",
+    "chalk": "^4.1.2",
+    "commander": "^12.0.0",
+    "cors": "^2.8.6",
+    "dotenv": "^17.4.2",
+    "express": "^5.2.1",
+    "fs-extra": "^11.3.4",
+    "glob": "^13.0.6",
+    "helmet": "^8.2.0",
+    "ora": "^5.4.1",
+    "puppeteer-core": "^22.0.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.0.0",
+    "web-vitals": "^5.1.0"
+  },
+
+  "devDependencies": {
+    "@types/babel__traverse": "^7.28.0",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.6",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^25.9.1",
+    "nodemon": "^3.1.14"
+  }
+}

package/shared/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './schemas';

package/shared/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Exporting all types in one common used file
+__exportStar(require("./types"), exports);
+__exportStar(require("./schemas"), exports);

package/shared/dist/schemas.d.ts

@@ -0,0 +1,91 @@
+import * as v from 'valibot';
+
+export declare const WebVitalsSchema: v.ObjectSchema<{
+    readonly lcp: v.NumberSchema<undefined>;
+    readonly fcp: v.NumberSchema<undefined>;
+    readonly cls: v.NumberSchema<undefined>;
+    readonly inp: v.NumberSchema<undefined>;
+    readonly ttfb: v.NumberSchema<undefined>;
+}, undefined>;
+export declare const ComponentIssueSchema: v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    readonly component: v.StringSchema<undefined>;
+    readonly file: v.StringSchema<undefined>;
+    readonly line: v.NumberSchema<undefined>;
+    readonly severity: v.PicklistSchema<["critical", "warning", "info"], undefined>;
+    readonly message: v.StringSchema<undefined>;
+    readonly suggestion: v.StringSchema<undefined>;
+}, undefined>;
+export declare const StaticReportSchema: v.ObjectSchema<{
+    readonly timestamp: v.StringSchema<undefined>;
+    readonly issues: v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly component: v.StringSchema<undefined>;
+        readonly file: v.StringSchema<undefined>;
+        readonly line: v.NumberSchema<undefined>;
+        readonly severity: v.PicklistSchema<["critical", "warning", "info"], undefined>;
+        readonly message: v.StringSchema<undefined>;
+        readonly suggestion: v.StringSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly bundleSize: v.NumberSchema<undefined>;
+    readonly componentCount: v.NumberSchema<undefined>;
+}, undefined>;
+export declare const RuntimeReportSchema: v.ObjectSchema<{
+    readonly timestamp: v.StringSchema<undefined>;
+    readonly metrics: v.ObjectSchema<{
+        readonly lcp: v.NumberSchema<undefined>;
+        readonly fcp: v.NumberSchema<undefined>;
+        readonly cls: v.NumberSchema<undefined>;
+        readonly inp: v.NumberSchema<undefined>;
+        readonly ttfb: v.NumberSchema<undefined>;
+    }, undefined>;
+    readonly rerenders: v.RecordSchema<v.StringSchema<undefined>, v.NumberSchema<undefined>, undefined>;
+    readonly commitDurations: v.ArraySchema<v.NumberSchema<undefined>, undefined>;
+}, undefined>;
+export declare const SuggestionSchema: v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    readonly title: v.StringSchema<undefined>;
+    readonly description: v.StringSchema<undefined>;
+    readonly severity: v.PicklistSchema<["critical", "warning", "info"], undefined>;
+    readonly affectedComponent: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly fix: v.StringSchema<undefined>;
+}, undefined>;
+export declare const FinalReportSchema: v.ObjectSchema<{
+    readonly projectName: v.StringSchema<undefined>;
+    readonly analyzedAt: v.StringSchema<undefined>;
+    readonly static: v.ObjectSchema<{
+        readonly timestamp: v.StringSchema<undefined>;
+        readonly issues: v.ArraySchema<v.ObjectSchema<{
+            readonly id: v.StringSchema<undefined>;
+            readonly component: v.StringSchema<undefined>;
+            readonly file: v.StringSchema<undefined>;
+            readonly line: v.NumberSchema<undefined>;
+            readonly severity: v.PicklistSchema<["critical", "warning", "info"], undefined>;
+            readonly message: v.StringSchema<undefined>;
+            readonly suggestion: v.StringSchema<undefined>;
+        }, undefined>, undefined>;
+        readonly bundleSize: v.NumberSchema<undefined>;
+        readonly componentCount: v.NumberSchema<undefined>;
+    }, undefined>;
+    readonly runtime: v.ObjectSchema<{
+        readonly timestamp: v.StringSchema<undefined>;
+        readonly metrics: v.ObjectSchema<{
+            readonly lcp: v.NumberSchema<undefined>;
+            readonly fcp: v.NumberSchema<undefined>;
+            readonly cls: v.NumberSchema<undefined>;
+            readonly inp: v.NumberSchema<undefined>;
+            readonly ttfb: v.NumberSchema<undefined>;
+        }, undefined>;
+        readonly rerenders: v.RecordSchema<v.StringSchema<undefined>, v.NumberSchema<undefined>, undefined>;
+        readonly commitDurations: v.ArraySchema<v.NumberSchema<undefined>, undefined>;
+    }, undefined>;
+    readonly suggestions: v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly title: v.StringSchema<undefined>;
+        readonly description: v.StringSchema<undefined>;
+        readonly severity: v.PicklistSchema<["critical", "warning", "info"], undefined>;
+        readonly affectedComponent: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly fix: v.StringSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly performanceScore: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 100, undefined>]>;
+}, undefined>;

package/shared/dist/schemas.js

@@ -0,0 +1,82 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FinalReportSchema = exports.SuggestionSchema = exports.RuntimeReportSchema = exports.StaticReportSchema = exports.ComponentIssueSchema = exports.WebVitalsSchema = void 0;
+const v = __importStar(require("valibot"));
+// Valibot schemas for validation
+exports.WebVitalsSchema = v.object({
+    lcp: v.number(),
+    fcp: v.number(),
+    cls: v.number(),
+    inp: v.number(),
+    ttfb: v.number(),
+});
+exports.ComponentIssueSchema = v.object({
+    id: v.string(),
+    component: v.string(),
+    file: v.string(),
+    line: v.number(),
+    severity: v.picklist(['critical', 'warning', 'info']),
+    message: v.string(),
+    suggestion: v.string(),
+});
+exports.StaticReportSchema = v.object({
+    timestamp: v.string(),
+    issues: v.array(exports.ComponentIssueSchema),
+    bundleSize: v.number(),
+    componentCount: v.number(),
+});
+exports.RuntimeReportSchema = v.object({
+    timestamp: v.string(),
+    metrics: exports.WebVitalsSchema,
+    rerenders: v.record(v.string(), v.number()),
+    commitDurations: v.array(v.number()),
+});
+exports.SuggestionSchema = v.object({
+    id: v.string(),
+    title: v.string(),
+    description: v.string(),
+    severity: v.picklist(['critical', 'warning', 'info']),
+    affectedComponent: v.optional(v.string()),
+    fix: v.string(),
+});
+exports.FinalReportSchema = v.object({
+    projectName: v.string(),
+    analyzedAt: v.string(),
+    static: exports.StaticReportSchema,
+    runtime: exports.RuntimeReportSchema,
+    suggestions: v.array(exports.SuggestionSchema),
+    performanceScore: v.pipe(v.number(), v.minValue(0), v.maxValue(100)),
+});