ts-build

Build TypeScript project with intelligent error handling and analysis:

1. Detect Build Configuration

   • Check for build tool:
     • tsconfig.json → tsc
     • vite.config.ts → Vite
     • webpack.config.ts → webpack
     • tsup.config.ts → tsup
     • rollup.config.ts → Rollup
   • Determine build mode: development or production
   • Check for watch mode flag: $ARGUMENTS includes "--watch"

2. Pre-Build Validation

   • Verify TypeScript is installed
   • Check tsconfig.json is valid
   • Ensure dependencies are installed (node_modules exists)
   • Clean previous build artifacts if needed

3. Type-Check First

   • Run tsc --noEmit to check types without emitting
   • This is fast and catches type errors early
   • If type errors found, categorize them by:
     • File (group errors by file)
     • Error code (TS2322, TS2339, etc.)
     • Severity (error vs warning)

4. Build Project

   Execute appropriate build command:

   • tsc: npx tsc -p tsconfig.json
   • Vite: npx vite build
   • webpack: npx webpack --mode production
   • tsup: npx tsup
   • Custom: Use npm script from package.json

   Monitor build progress and capture output.

5. Handle Build Errors

   Type Errors:

   • Parse TypeScript error messages
   • Group similar errors together
   • For each unique error:
     • Show file and line number
     • Display code snippet with context
     • Explain error in plain English
     • Suggest specific fixes with code examples
     • Offer to apply automated fixes where possible

   Build Tool Errors:

   • Module resolution failures
   • Missing dependencies
   • Configuration issues
   • Asset loading problems

   Runtime Errors:

   • Import/export mismatches
   • Circular dependencies
   • Missing type declarations

6. Error Analysis & Suggestions

   Common Error Patterns:

   TS2322: Type Assignment Error

   // Error: Type 'string | undefined' is not assignable to type 'string'
   const name: string = user.name; // user.name is string | undefined
   
   // Fixes:
   // 1. Handle undefined:
   const name: string = user.name ?? 'Unknown';
   
   // 2. Use optional type:
   const name: string | undefined = user.name;
   
   // 3. Type guard:
   if (user.name) {
     const name: string = user.name;
   }
   

   TS2339: Property Does Not Exist

   // Error: Property 'foo' does not exist on type 'User'
   
   // Fixes:
   // 1. Add property to interface
   // 2. Use optional chaining: user.foo?.bar
   // 3. Type assertion with explanation (last resort)
   

   TS7006: Implicit Any Parameter

   // Error: Parameter 'x' implicitly has an 'any' type
   function add(x, y) { return x + y; }
   
   // Fix: Add explicit types
   function add(x: number, y: number): number { return x + y; }
   

7. Build Success Analysis

   If build succeeds:

   • Show build time
   • Display output file sizes
   • Check for large bundles (warn if > 500KB)
   • Show tree-shaking effectiveness (if applicable)
   • List generated files and their locations
   • Verify source maps were generated

8. Performance Metrics

   Track and report:

   • Type-checking time
   • Build/bundling time
   • Total time
   • Output bundle sizes
   • Number of modules processed

   Compare with previous builds if possible.

9. Post-Build Actions

   • Run automated tests if build successful
   • Generate type declaration files (.d.ts)
   • Update documentation if needed
   • Suggest next steps (deploy, test, etc.)

10. Watch Mode

    If --watch flag provided:

    • Start incremental build in watch mode
    • Monitor file changes
    • Rebuild only changed files
    • Show real-time type errors
    • Track build performance over time

11. Build Optimization Suggestions

    If build is slow or bundle is large:

    • Suggest enabling skipLibCheck
    • Recommend project references for monorepos
    • Suggest code splitting strategies
    • Identify large dependencies
    • Recommend tree-shaking improvements
    • Suggest moving to faster build tool (esbuild, swc)