@jigyasudham/veto 0.8.2 → 1.0.0

package/src/agents/development/performance.ts

@@ -1,144 +0,0 @@
-import { AgentPlan, WorkerAgentType } from '../types.js';
-
-type PerfDomain = 'database' | 'network' | 'cpu' | 'memory' | 'frontend' | 'general';
-
-function detectDomain(task: string, context?: string): PerfDomain {
-  const combined = (task + ' ' + (context ?? '')).toLowerCase();
-  if (combined.includes('database') || combined.includes('query') || combined.includes('sql') || combined.includes('slow query') || combined.includes('n+1')) return 'database';
-  if (combined.includes('network') || combined.includes('latency') || combined.includes('bandwidth') || combined.includes('api') || combined.includes('http')) return 'network';
-  if (combined.includes('cpu') || combined.includes('algorithm') || combined.includes('computation') || combined.includes('big-o') || combined.includes('loop')) return 'cpu';
-  if (combined.includes('memory') || combined.includes('ram') || combined.includes('heap') || combined.includes('leak') || combined.includes('gc')) return 'memory';
-  if (combined.includes('frontend') || combined.includes('render') || combined.includes('fcp') || combined.includes('lcp') || combined.includes('cls') || combined.includes('bundle')) return 'frontend';
-  return 'general';
-}
-
-const domainApproach: Record<PerfDomain, string> = {
-  database: 'Profile slow queries with EXPLAIN ANALYZE. Eliminate N+1 patterns. Add missing indexes. Implement query result caching. Consider read replicas for read-heavy workloads.',
-  network: 'Measure with real network traces (HAR file, curl --trace). Enable HTTP/2. Add connection pooling. Implement response compression. Use CDN for static assets. Cache at the edge.',
-  cpu: 'Profile with clinic.js or perf_hooks to find the hotspot. Check algorithm complexity — O(n²) over thousands of items is always the first target. Move heavy computation off the event loop (worker threads).',
-  memory: 'Take heap snapshots to identify retained objects. Implement LRU eviction on all caches. Remove event listeners on cleanup. Bound queue and buffer sizes. Configure GC flags for the workload.',
-  frontend: 'Measure Core Web Vitals (LCP, FID, CLS) with Lighthouse. Code-split by route. Lazy-load off-screen images. Tree-shake dependencies. Remove render-blocking scripts. Implement service worker caching.',
-  general: 'Establish a baseline measurement before optimising. Use a profiler to identify the actual bottleneck — never optimise by intuition. Fix one thing at a time and re-measure after each change.',
-};
-
-export function plan(task: string, context?: string): AgentPlan {
-  const domain = detectDomain(task, context);
-
-  const domainSteps: Record<PerfDomain, string[]> = {
-    database: [
-      'Enable query logging and collect the 10 slowest queries over a representative time window',
-      'Run EXPLAIN ANALYZE on each slow query — read the execution plan top to bottom',
-      'Identify sequential scans on large tables — these are the highest-priority index candidates',
-      'Add indexes for missing JOIN columns, frequent WHERE filters, and ORDER BY columns',
-      'Detect N+1 queries by counting DB calls per HTTP request (use a query counter middleware)',
-      'Fix N+1 by using JOIN, eager loading (include in ORM), or DataLoader batching',
-      'Implement query result caching for expensive read-only queries (Redis, in-memory LRU)',
-      'Review ORM-generated SQL — ORMs frequently produce inefficient queries',
-      'Set statement_timeout to prevent runaway queries from blocking the connection pool',
-      'Consider read replicas for analytics queries that do not need fresh data',
-      'Benchmark before and after with a realistic data volume (not an empty dev database)',
-    ],
-    network: [
-      'Capture a HAR file from the browser or use curl --trace for API calls',
-      'Measure Time to First Byte (TTFB) — high TTFB means server-side is slow',
-      'Enable HTTP/2 — multiplexes requests over a single connection',
-      'Enable Brotli or gzip compression on all text responses',
-      'Implement cache-control headers for static assets (immutable for hashed files)',
-      'Move static assets to a CDN geographically close to users',
-      'Reduce payload size — paginate, select only needed fields, avoid sending unused data',
-      'Implement connection pooling for HTTP clients making outbound requests',
-      'Add keep-alive headers to reuse TCP connections',
-      'Measure DNS lookup time — use DNS prefetching for known third-party domains',
-      'Benchmark with Apache Benchmark or k6 at realistic concurrency levels',
-    ],
-    cpu: [
-      'Run clinic.js flame or Node.js --prof to identify the CPU hotspot',
-      'Analyse the flame graph — find the widest block (most self-time)',
-      'Check the algorithm complexity of the hotspot — is it O(n²) over a large input?',
-      'Replace O(n²) nested loops with O(n) approaches using hash maps or sorting',
-      'Move CPU-heavy synchronous work to a worker thread pool (piscina)',
-      'Cache the results of deterministic expensive computations (memoisation)',
-      'Avoid creating large temporary arrays in hot paths — reuse buffers',
-      'Use Buffer.allocUnsafe() instead of Buffer.alloc() where the content is immediately overwritten',
-      'Profile again after the fix — confirm the hotspot is gone, not just moved',
-      'Add a performance regression test that benchmarks the fixed function',
-    ],
-    memory: [
-      'Take a heap snapshot with Chrome DevTools or --heapsnapshot-signal before the test',
-      'Run the operation that causes the memory growth',
-      'Take a second heap snapshot and use the Comparison view to find new retained objects',
-      'Identify the shortest GC root path to the retained objects',
-      'Find all unbounded caches and add LRU eviction (lru-cache npm package)',
-      'Audit all EventEmitter.on() calls — ensure off() is called in cleanup',
-      'Find all setInterval and setTimeout and ensure clearInterval/clearTimeout in cleanup',
-      'Check for closures that capture large objects unnecessarily',
-      'Set --max-old-space-size appropriately for the container memory limit',
-      'Monitor heap usage in production with process.memoryUsage() sent to metrics',
-      'Take a third heap snapshot after the fix to verify retention is resolved',
-    ],
-    frontend: [
-      'Run Lighthouse on the production URL and record the Core Web Vitals baseline',
-      'Fix Largest Contentful Paint (LCP) — preload the hero image, avoid render-blocking CSS/JS',
-      'Fix Cumulative Layout Shift (CLS) — reserve space for images and ads with width/height attributes',
-      'Fix First Input Delay / Interaction to Next Paint — break up long tasks (> 50ms) on the main thread',
-      'Implement route-based code splitting with dynamic import()',
-      'Lazy-load images below the fold with loading="lazy" or IntersectionObserver',
-      'Audit the JavaScript bundle with webpack-bundle-analyzer or vite-bundle-visualizer',
-      'Remove unused dependencies — check import cost of each third-party library',
-      'Tree-shake lodash — import { debounce } from \'lodash\' not import _ from \'lodash\'',
-      'Implement service worker caching for repeat visits (Workbox)',
-      'Serve next-gen image formats (WebP, AVIF) with <picture> fallback',
-      'Measure again with Lighthouse after each change — confirm improvement',
-    ],
-    general: [
-      'Establish a baseline — measure latency (p50, p95, p99), throughput (rps), CPU, and memory',
-      'Use a profiler appropriate to the stack — clinic.js, Pyspy, JProfiler, pprof',
-      'Identify the single largest bottleneck — fix that first before anything else',
-      'Check for database query issues (N+1, missing indexes, full table scans)',
-      'Check for algorithmic complexity issues (O(n²) loops)',
-      'Check for I/O blocking the event loop (synchronous file/network reads)',
-      'Check for memory pressure causing GC pauses',
-      'Fix one bottleneck at a time and re-measure after each change',
-      'Add performance regression tests to CI (k6, autocannon, benchmark.js)',
-      'Document the improvement with before/after numbers',
-    ],
-  };
-
-  return {
-    agent: 'performance' as WorkerAgentType,
-    task,
-    tier: 3,
-    approach: domainApproach[domain],
-    steps: domainSteps[domain],
-    checklist: [
-      '[ ] Baseline measurements recorded (p50/p95/p99 latency, throughput, CPU, memory)',
-      '[ ] Profiler run — bottleneck identified, not assumed',
-      '[ ] Highest-impact bottleneck fixed first',
-      '[ ] No N+1 query patterns in the hot path',
-      '[ ] All caches have a maximum size and eviction policy',
-      '[ ] No synchronous blocking I/O in async code paths',
-      '[ ] Algorithm complexity reviewed — no O(n²) over large inputs',
-      '[ ] Post-fix measurement confirms improvement',
-      '[ ] Performance regression test added to CI',
-      '[ ] Improvement documented with before/after numbers',
-    ],
-    pitfalls: [
-      'Optimising before profiling — wastes hours on non-bottlenecks',
-      'Caching without an eviction strategy — trades a performance problem for a memory leak',
-      'Fixing the wrong layer — optimising the API handler when the bottleneck is the database',
-      'Measuring on a development machine with a tiny dataset — results do not reflect production',
-      'Parallelising I/O without a concurrency limit — overwhelms the downstream service and causes cascading failure',
-      'Trusting microbenchmarks for macro performance — benchmark the real workload, not a toy example',
-    ],
-    patterns: [
-      'Memoisation (cache pure function results)',
-      'Lazy evaluation (compute on demand, not upfront)',
-      'Connection pooling (reuse expensive connections)',
-      'Read-through cache (populate cache on miss, serve from cache on hit)',
-      'Worker thread pool (offload CPU work from the event loop)',
-      'Pagination and cursor-based pagination (bound response size)',
-      'Index-only queries (cover all needed columns in the index)',
-    ],
-    duration_estimate: '4-8 hours',
-  };
-}

package/src/agents/development/refactor.ts

@@ -1,86 +0,0 @@
-import { AgentPlan, WorkerAgentType } from '../types.js';
-
-type RefactorFocus = 'complexity' | 'duplication' | 'naming' | 'architecture' | 'types' | 'general';
-
-function detectFocus(task: string, context?: string): RefactorFocus {
-  const combined = (task + ' ' + (context ?? '')).toLowerCase();
-  if (combined.includes('complex') || combined.includes('nesting') || combined.includes('long function') || combined.includes('spaghetti')) return 'complexity';
-  if (combined.includes('duplicat') || combined.includes('copy') || combined.includes('repeat') || combined.includes('dry')) return 'duplication';
-  if (combined.includes('naming') || combined.includes('rename') || combined.includes('readab')) return 'naming';
-  if (combined.includes('architect') || combined.includes('layer') || combined.includes('module') || combined.includes('structure')) return 'architecture';
-  if (combined.includes('type') || combined.includes('any') || combined.includes('typescript') || combined.includes('interface')) return 'types';
-  return 'general';
-}
-
-const focusApproach: Record<RefactorFocus, string> = {
-  complexity: 'Identify the most complex functions first using cyclomatic complexity metrics. Extract sub-functions, apply guard clauses, replace conditionals with polymorphism, reduce nesting step by step.',
-  duplication: 'Find all duplicated logic using diff tools or manual inspection. Extract to a shared utility/hook/module. Parameterise differences. Verify all callers still work after consolidation.',
-  naming: 'Rename systematically using IDE refactoring tools, not text-replace. Start with the most confusing names. Add JSDoc where a name alone is insufficient. Update all references atomically.',
-  architecture: 'Diagram the current structure, identify coupling hotspots, define the target architecture, then migrate incrementally with an anti-corruption layer during transition.',
-  types: 'Eliminate all implicit any types by enabling TypeScript strict mode. Define precise interfaces for all data shapes. Replace type assertions with proper narrowing. Add runtime validation at boundaries.',
-  general: 'Apply the Boy Scout Rule: leave the code cleaner than you found it. Identify the highest-impact improvement (complexity, duplication, naming, or architecture) and address it first.',
-};
-
-export function plan(task: string, context?: string): AgentPlan {
-  const focus = detectFocus(task, context);
-
-  return {
-    agent: 'refactor' as WorkerAgentType,
-    task,
-    tier: 2,
-    approach: focusApproach[focus],
-    steps: [
-      'Run the full test suite and record the baseline — all tests must pass before and after',
-      'Identify code smells: long functions, deep nesting, duplicated logic, primitive obsession, feature envy',
-      'Prioritise by impact — fix the highest-complexity or most-duplicated code first',
-      'Add missing tests for code that lacks coverage before refactoring it',
-      'Apply extract function refactoring to any function longer than 30 lines',
-      'Apply guard clauses (early returns) to reduce nesting depth',
-      'Extract magic numbers and strings to named constants',
-      'Rename variables and functions to be self-documenting — eliminate abbreviations',
-      'Consolidate duplicated logic into shared utilities or base classes',
-      'Remove dead code — if it is not tested and not called, delete it',
-      'Apply TypeScript strict improvements — eliminate any, add precise types',
-      'Run the linter and formatter after each logical change',
-      'Run the full test suite again — compare with baseline, all tests must pass',
-      'Review the diff — if a single commit is too large, split into atomic changes',
-    ],
-    checklist: [
-      '[ ] All tests pass before starting refactoring',
-      '[ ] All tests still pass after each refactoring step',
-      '[ ] No function exceeds 30 lines of executable code after refactoring',
-      '[ ] Nesting depth reduced to maximum 3 levels',
-      '[ ] All magic numbers replaced with named constants',
-      '[ ] No duplicated code blocks (copy-paste > 5 lines)',
-      '[ ] All variables and functions have descriptive names',
-      '[ ] No implicit any types remain',
-      '[ ] Dead code removed (unused functions, imports, variables)',
-      '[ ] Linter passes with zero warnings',
-      '[ ] Code coverage not reduced by the refactoring',
-      '[ ] Each commit is a single atomic refactoring step',
-      '[ ] Public API is unchanged (or version-bumped if breaking)',
-      '[ ] Complexity metrics improved — measure before and after',
-    ],
-    pitfalls: [
-      'Refactoring without tests — you will not know if you broke something',
-      'Big-bang refactoring in one commit — impossible to review, high merge conflict risk',
-      'Renaming without IDE refactoring tools — misses call sites, creates runtime bugs',
-      'Extracting a function that is only called once without a clear abstraction reason',
-      'Changing behaviour while refactoring — refactoring must be semantics-preserving',
-      'Removing code that looks unused but is called via dynamic reflection or eval',
-      'Over-abstracting — a third function extracted for two call sites adds indirection without clarity',
-    ],
-    patterns: [
-      'Extract Function (Fowler refactoring catalogue)',
-      'Replace Conditional with Polymorphism',
-      'Guard Clause (replace nested conditionals with early returns)',
-      'Introduce Parameter Object (replace long parameter lists)',
-      'Replace Magic Number with Symbolic Constant',
-      'Move Function (reduce feature envy)',
-      'Inline Variable (remove unnecessary variable aliases)',
-      'Decompose Conditional',
-      'Consolidate Duplicate Conditional Fragments',
-    ],
-    duration_estimate: focus === 'architecture' ? '1-3 days' : '2-6 hours',
-  };
-}

package/src/agents/development/reviewer.ts

@@ -1,268 +0,0 @@
-import { AgentPlan, AgentAnalysis, AgentFinding, FindingSeverity, WorkerAgentType } from '../types.js';
-
-// ─── plan ────────────────────────────────────────────────────────────────────
-
-export function plan(task: string, _context?: string): AgentPlan {
-  return {
-    agent: 'reviewer' as WorkerAgentType,
-    task,
-    tier: 2,
-    approach: 'Systematic code review: assess complexity, error handling, naming, magic literals, nesting depth, and test coverage. Produce scored findings with actionable fixes.',
-    steps: [
-      'Read the module top-to-bottom to understand its purpose and public contract',
-      'Identify all exported symbols and verify they are intentional',
-      'Check function lengths — flag any function exceeding 50 lines for extraction',
-      'Assess cyclomatic complexity — any function with more than 10 branches is a risk',
-      'Verify every async call is awaited or explicitly fire-and-forget',
-      'Check error handling — all try/catch blocks must do something meaningful',
-      'Scan for magic numbers and untyped string literals',
-      'Measure nesting depth — refactor anything deeper than 3 levels',
-      'Review naming — variables, functions, and types should be self-documenting',
-      'Check for TODO/FIXME comments and ensure each links to a tracking issue',
-      'Verify unused imports and variables are removed',
-      'Confirm test coverage exists for every public function',
-      'Assess consistency with the rest of the codebase style',
-    ],
-    checklist: [
-      '[ ] No function exceeds 50 lines of executable code',
-      '[ ] No function has cyclomatic complexity > 10',
-      '[ ] Every await is inside an async function',
-      '[ ] Every try/catch logs or rethrows — no silent swallow',
-      '[ ] No magic numbers — use named constants',
-      '[ ] No deeply nested if/for (max 3 levels)',
-      '[ ] All TODO/FIXME comments reference a ticket number',
-      '[ ] No unused variables or imports',
-      '[ ] Naming is consistent with the project convention (camelCase, PascalCase for types)',
-      '[ ] No console.log left in production paths',
-      '[ ] Public functions have JSDoc',
-      '[ ] Every exported function has at least one test',
-      '[ ] No any types without an explanatory comment',
-      '[ ] No circular imports',
-    ],
-    pitfalls: [
-      'Approving a PR because it "looks fine" without running it locally',
-      'Missing async bugs — a synchronous function calling an async one without await silently drops the Promise',
-      'Over-reviewing style while missing logic errors — focus on correctness first',
-      'Not reading the tests — tests reveal intent, bad tests reveal bad design',
-      'Ignoring error handling because the happy path looks clean',
-    ],
-    patterns: [
-      'Guard clause pattern (early returns to reduce nesting)',
-      'Strategy pattern (replace long switch/if chains)',
-      'Extract function refactoring',
-      'Null Object pattern (replace null checks)',
-      'Result/Option type (replace throw-based error handling)',
-    ],
-    duration_estimate: '1-2 hours',
-  };
-}
-
-// ─── helpers ─────────────────────────────────────────────────────────────────
-
-function countLines(code: string): number {
-  return code.split('\n').length;
-}
-
-function detectFunctions(code: string): Array<{ name: string; body: string; start: number }> {
-  const results: Array<{ name: string; body: string; start: number }> = [];
-  const lines = code.split('\n');
-
-  // Match function declarations and arrow functions assigned to const/let/var
-  const funcRegex = /(?:function\s+(\w+)|(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s*)?\()/;
-
-  let i = 0;
-  while (i < lines.length) {
-    const match = lines[i].match(funcRegex);
-    if (match) {
-      const name = match[1] || match[2] || 'anonymous';
-      let depth = 0;
-      let started = false;
-      const bodyLines: string[] = [];
-      let j = i;
-      while (j < lines.length) {
-        for (const ch of lines[j]) {
-          if (ch === '{') { depth++; started = true; }
-          if (ch === '}') depth--;
-        }
-        bodyLines.push(lines[j]);
-        if (started && depth === 0) break;
-        j++;
-      }
-      results.push({ name, body: bodyLines.join('\n'), start: i + 1 });
-      i = j + 1;
-    } else {
-      i++;
-    }
-  }
-  return results;
-}
-
-function maxNestingDepth(code: string): number {
-  let max = 0;
-  let depth = 0;
-  for (const ch of code) {
-    if (ch === '{') { depth++; max = Math.max(max, depth); }
-    if (ch === '}') depth--;
-  }
-  return max;
-}
-
-// ─── analyze ─────────────────────────────────────────────────────────────────
-
-export function analyze(code: string, context?: string): AgentAnalysis {
-  const findings: AgentFinding[] = [];
-  const lines = code.split('\n');
-  const totalLines = countLines(code);
-  const subject = context ?? `Code (${totalLines} lines)`;
-
-  // 1. Long functions
-  const functions = detectFunctions(code);
-  for (const fn of functions) {
-    const fnLines = fn.body.split('\n').length;
-    if (fnLines > 50) {
-      findings.push({
-        severity: 'medium',
-        category: 'Complexity',
-        description: `Function '${fn.name}' is ${fnLines} lines long (limit: 50).`,
-        fix: `Extract logical blocks into named helper functions. Aim for functions that do one thing and fit on one screen.`,
-        location: `Line ${fn.start}`,
-      });
-    }
-  }
-
-  // 2. Deep nesting
-  const nestingDepth = maxNestingDepth(code);
-  if (nestingDepth > 5) {
-    findings.push({
-      severity: 'medium',
-      category: 'Complexity',
-      description: `Maximum brace nesting depth is ${nestingDepth} (limit: 5). Deep nesting makes code hard to reason about.`,
-      fix: 'Apply guard clauses (early returns), extract inner blocks to functions, or flatten with Promise chains.',
-    });
-  }
-
-  // 3. Missing error handling — try without catch, or bare promise .then without .catch
-  const tryCatchBalance = (code.match(/\btry\b/g) || []).length;
-  const catchBalance = (code.match(/\bcatch\b/g) || []).length;
-  if (tryCatchBalance > catchBalance) {
-    findings.push({
-      severity: 'high',
-      category: 'Error Handling',
-      description: `Found ${tryCatchBalance} try block(s) but only ${catchBalance} catch block(s). Unmatched try blocks may silently swallow errors.`,
-      fix: 'Ensure every try has a corresponding catch. Log the error and either rethrow or return a typed error result.',
-    });
-  }
-
-  // 4. Unhandled promise (.then without .catch)
-  lines.forEach((line, idx) => {
-    if (/\.then\s*\(/.test(line) && !/\.catch\s*\(/.test(line)) {
-      // Check next few lines for .catch
-      const window = lines.slice(idx, idx + 5).join(' ');
-      if (!/\.catch\s*\(/.test(window)) {
-        findings.push({
-          severity: 'high',
-          category: 'Error Handling',
-          description: `Promise .then() at line ${idx + 1} has no visible .catch() — unhandled rejection risk.`,
-          fix: 'Add .catch(err => { ... }) or convert to async/await with try/catch.',
-          location: `Line ${idx + 1}`,
-        });
-      }
-    }
-  });
-
-  // 5. Magic numbers
-  lines.forEach((line, idx) => {
-    // Skip comments and import lines
-    if (/^\s*(\/\/|\/\*|\*|import|export)/.test(line)) return;
-    // Match standalone numeric literals that aren't 0 or 1
-    const magicMatches = line.match(/(?<![.\w])(?:[2-9]\d*|\d{2,})(?!\w)/g);
-    if (magicMatches) {
-      findings.push({
-        severity: 'low',
-        category: 'Maintainability',
-        description: `Magic number(s) [${magicMatches.join(', ')}] at line ${idx + 1}. Bare literals obscure intent.`,
-        fix: 'Extract to a named constant: const MAX_RETRIES = 3; at the top of the file or in a constants module.',
-        location: `Line ${idx + 1}`,
-      });
-    }
-  });
-
-  // 6. TODO/FIXME without issue reference
-  lines.forEach((line, idx) => {
-    if (/\/\/.*\b(TODO|FIXME|HACK|XXX)\b/.test(line) && !/\b(#\d+|https?:\/\/|JIRA|GH-|issue)/i.test(line)) {
-      findings.push({
-        severity: 'low',
-        category: 'Technical Debt',
-        description: `Untracked TODO/FIXME at line ${idx + 1}: "${line.trim()}"`,
-        fix: 'Link to a tracking issue: // TODO(#123): fix this.',
-        location: `Line ${idx + 1}`,
-      });
-    }
-  });
-
-  // 7. Unused variable patterns (_var that is actually used, or var that starts with _ but is referenced)
-  lines.forEach((line, idx) => {
-    if (/const\s+_\w+\s*=/.test(line) || /let\s+_\w+\s*=/.test(line)) {
-      const varMatch = line.match(/(?:const|let)\s+(_\w+)/);
-      if (varMatch) {
-        const varName = varMatch[1];
-        const usedElsewhere = code.split('\n').filter((_, i) => i !== idx).some(l => l.includes(varName));
-        if (usedElsewhere) {
-          findings.push({
-            severity: 'info',
-            category: 'Naming',
-            description: `Variable '${varName}' starts with underscore (convention: unused) but is referenced elsewhere in the code.`,
-            fix: `Rename '${varName}' to '${varName.slice(1)}' since it is actively used.`,
-            location: `Line ${idx + 1}`,
-          });
-        }
-      }
-    }
-  });
-
-  // 8. Consistent naming — detect mixed camelCase / snake_case for variables
-  const camelVars = (code.match(/\b(?:const|let|var)\s+([a-z][a-zA-Z0-9]*[A-Z][a-zA-Z0-9]*)\b/g) || []).length;
-  const snakeVars = (code.match(/\b(?:const|let|var)\s+([a-z][a-z0-9]*_[a-z][a-z0-9]*)\b/g) || []).length;
-  if (camelVars > 0 && snakeVars > 0) {
-    findings.push({
-      severity: 'low',
-      category: 'Naming',
-      description: `Mixed naming convention: ${camelVars} camelCase and ${snakeVars} snake_case variable declarations detected.`,
-      fix: 'Standardise on camelCase for variables and functions in TypeScript/JavaScript codebases.',
-    });
-  }
-
-  // ─── Score ────────────────────────────────────────────────────────────────
-  let score = 100;
-  const critical_count = findings.filter(f => f.severity === 'critical').length;
-  const high_count = findings.filter(f => f.severity === 'high').length;
-  const medium_count = findings.filter(f => f.severity === 'medium').length;
-  const low_count = findings.filter(f => f.severity === 'low').length;
-
-  score -= critical_count * 25;
-  score -= high_count * 15;
-  score -= medium_count * 8;
-  score -= low_count * 3;
-  score = Math.max(0, Math.min(100, score));
-
-  let verdict: AgentAnalysis['verdict'];
-  if (critical_count > 0) verdict = 'rejected';
-  else if (high_count > 0) verdict = 'needs_revision';
-  else if (medium_count > 0 || low_count > 2) verdict = 'approved_with_warnings';
-  else verdict = 'approved';
-
-  const summary = findings.length === 0
-    ? 'Code looks clean — no significant issues detected.'
-    : `Found ${findings.length} issue(s): ${critical_count} critical, ${high_count} high, ${medium_count} medium, ${low_count} low. Score: ${score}/100.`;
-
-  return {
-    agent: 'reviewer' as WorkerAgentType,
-    subject,
-    findings,
-    score,
-    verdict,
-    summary,
-    critical_count,
-    high_count,
-  };
-}

package/src/agents/development/tester.ts

@@ -1,151 +0,0 @@
-import { AgentPlan, WorkerAgentType } from '../types.js';
-
-type TestType = 'unit' | 'integration' | 'e2e';
-
-function detectTestType(task: string, context?: string): TestType {
-  const combined = (task + ' ' + (context ?? '')).toLowerCase();
-  if (combined.includes('e2e') || combined.includes('end-to-end') || combined.includes('playwright') || combined.includes('cypress') || combined.includes('browser')) return 'e2e';
-  if (combined.includes('integration') || combined.includes('database') || combined.includes('api') || combined.includes('endpoint') || combined.includes('http')) return 'integration';
-  return 'unit';
-}
-
-const typeApproach: Record<TestType, string> = {
-  unit: 'Isolate the unit under test by mocking all dependencies. Cover happy path, error paths, boundary conditions, and type edge cases. Aim for 100% branch coverage on business logic.',
-  integration: 'Test the interaction between real components (DB, HTTP, filesystem). Use test containers or in-memory alternatives. Verify contracts and side effects, not just return values.',
-  e2e: 'Test user journeys from browser to backend. Run against a staging environment or local stack. Focus on critical paths — registration, login, core workflows. Avoid testing every permutation.',
-};
-
-const typeSteps: Record<TestType, string[]> = {
-  unit: [
-    'Identify the public interface of the unit under test',
-    'List all logical branches (if/else, switch, try/catch, null checks)',
-    'Create a test file co-located with the source file (*.test.ts)',
-    'Import the unit and mock all external dependencies at the top',
-    'Write the happy-path test first to establish baseline behaviour',
-    'Write a test for each error or exception path',
-    'Add boundary condition tests (empty array, zero, max value, null, undefined)',
-    'Add a test for each async path (resolved and rejected)',
-    'Verify mocks were called with the correct arguments',
-    'Run coverage report and fill gaps — target 90%+ branch coverage',
-    'Review test names — each should describe behaviour, not implementation',
-    'Run tests in watch mode and confirm they are deterministic across runs',
-  ],
-  integration: [
-    'Identify the integration boundary (DB, HTTP, message queue, filesystem)',
-    'Set up a test database or mock server that resets between tests',
-    'Write fixtures / seed data helpers',
-    'Test the full request-response cycle for each endpoint/operation',
-    'Verify response body schema and HTTP status codes',
-    'Verify database state after mutations',
-    'Test authentication and authorisation (valid token, expired token, wrong role)',
-    'Test concurrent requests do not corrupt shared state',
-    'Test rollback on partial failure (transaction integrity)',
-    'Clean up all test data in afterEach/afterAll hooks',
-    'Run tests against the CI database, not a developer\'s local DB',
-    'Assert on error response shape, not just status code',
-  ],
-  e2e: [
-    'Map the user journeys to test (registration, login, core workflow)',
-    'Set up a local or staging stack with predictable seed data',
-    'Write page object models (POMs) for each major screen',
-    'Implement the happy-path journey test first',
-    'Add negative journey tests (invalid login, blocked access)',
-    'Test form validation messages appear and are readable',
-    'Verify redirect behaviour after actions (post-login, post-submit)',
-    'Test on at least two viewport sizes (mobile and desktop)',
-    'Add accessibility checks (axe-core or Playwright a11y plugin)',
-    'Assert on URL changes to ensure navigation works',
-    'Run in headless mode in CI; headed mode for debugging',
-    'Keep each test independent — never rely on state from a previous test',
-  ],
-};
-
-const typeChecklist: Record<TestType, string[]> = {
-  unit: [
-    '[ ] Every public function has at least one test',
-    '[ ] Every branch of a conditional is exercised',
-    '[ ] Error throw / rejection is tested explicitly',
-    '[ ] Mocks are reset between tests (beforeEach)',
-    '[ ] No test depends on another test\'s side effects',
-    '[ ] Test names use "should <behaviour> when <condition>" format',
-    '[ ] No production code altered to make tests pass (unless it improves design)',
-    '[ ] Tests run in under 5 seconds total',
-    '[ ] Coverage threshold enforced in jest/vitest config',
-    '[ ] Snapshot tests (if used) are committed and reviewed',
-  ],
-  integration: [
-    '[ ] Test database is isolated from development database',
-    '[ ] Seed data is deterministic and version-controlled',
-    '[ ] All test data cleaned up after each test',
-    '[ ] Auth tokens generated fresh per test',
-    '[ ] Response schema validated against TypeScript types',
-    '[ ] Error response shape tested, not just status code',
-    '[ ] Transactions roll back correctly on failure',
-    '[ ] No hardcoded ports — use dynamic port allocation',
-    '[ ] CI pipeline runs integration tests in a Docker environment',
-    '[ ] Tests are tagged so unit and integration can run separately',
-  ],
-  e2e: [
-    '[ ] Page object models used — no raw selectors in test bodies',
-    '[ ] data-testid attributes used for element selection (not CSS classes)',
-    '[ ] Each test is fully independent (own seed data)',
-    '[ ] Tests run in headless mode in CI',
-    '[ ] Mobile and desktop viewports both tested',
-    '[ ] Accessibility check passes on each major screen',
-    '[ ] Network errors are simulated for critical flows',
-    '[ ] Screenshots taken on failure for debugging',
-    '[ ] Test retries configured (max 2) to handle flakiness',
-    '[ ] Critical path coverage maps to product requirements',
-  ],
-};
-
-const typePitfalls: Record<TestType, string[]> = {
-  unit: [
-    'Testing implementation details (private methods, internal state) — test behaviour, not internals',
-    'Mocking the module under test — only mock its dependencies',
-    'Asserting on mock call count without asserting on arguments',
-    'Writing tests after the fact without TDD discipline — causes incomplete coverage',
-    'Using Math.random() or Date.now() in tests without mocking — non-deterministic results',
-  ],
-  integration: [
-    'Running integration tests against shared databases — causes test pollution between developers',
-    'Forgetting to rollback DB transactions — leaves dirty state that breaks subsequent tests',
-    'Hardcoding localhost ports — causes CI failures when ports are in use',
-    'Not testing the unhappy auth paths — security gap',
-    'Asserting only on status codes, not response body — misses contract violations',
-  ],
-  e2e: [
-    'Using CSS class selectors — they change on style refactors and break tests',
-    'Sharing state between tests — one failure cascades to all subsequent tests',
-    'Testing every UI permutation — creates a massive suite that nobody maintains',
-    'Ignoring flaky tests — they erode trust in the entire suite',
-    'Not running e2e on CI — catching bugs only locally defeats the purpose',
-  ],
-};
-
-const typePatterns: Record<TestType, string[]> = {
-  unit: ['Arrange-Act-Assert', 'Mock object pattern', 'Test data builder', 'Parameterised tests', 'Given-When-Then'],
-  integration: ['Test container pattern', 'Database cleaner pattern', 'Fixture factory', 'Contract testing', 'Seeding pattern'],
-  e2e: ['Page Object Model', 'Journey test pattern', 'Screenplay pattern', 'Seed-and-clean pattern', 'Visual regression testing'],
-};
-
-const typeDuration: Record<TestType, string> = {
-  unit: '1-3 hours',
-  integration: '3-6 hours',
-  e2e: '4-8 hours',
-};
-
-export function plan(task: string, context?: string): AgentPlan {
-  const testType = detectTestType(task, context);
-  return {
-    agent: 'tester' as WorkerAgentType,
-    task,
-    tier: 2,
-    approach: typeApproach[testType],
-    steps: typeSteps[testType],
-    checklist: typeChecklist[testType],
-    pitfalls: typePitfalls[testType],
-    patterns: typePatterns[testType],
-    duration_estimate: typeDuration[testType],
-  };
-}