mstro-app 0.4.2 → 0.4.4

package/server/services/websocket/quality-handlers.ts

@@ -1,41 +1,25 @@
 // Copyright (c) 2025-present Mstro, Inc. All rights reserved.
 // Licensed under the MIT License. See LICENSE file for details.
 
+/**
+ * Quality Handlers — WebSocket message router for quality scanning,
+ * code review, and fix operations.
+ *
+ * Agent logic lives in focused modules:
+ * - quality-review-agent.ts  — AI code review prompt, parsing, handler
+ * - quality-fix-agent.ts     — AI fix prompt, progress tracking, handler
+ */
+
 import { join } from 'node:path';
-import { runWithFileLogger } from '../../cli/headless/headless-logger.js';
-import { HeadlessRunner } from '../../cli/headless/index.js';
-import type { ToolUseEvent } from '../../cli/headless/types.js';
 import type { HandlerContext } from './handler-context.js';
+import type { FindingForFix } from './quality-fix-agent.js';
+import { handleFixIssues } from './quality-fix-agent.js';
 import { QualityPersistence } from './quality-persistence.js';
-import { detectTools, installTools, recomputeWithAiReview, runQualityScan } from './quality-service.js';
+import { handleCodeReview } from './quality-review-agent.js';
+import { detectTools, installTools, runQualityScan } from './quality-service.js';
 import type { WebSocketMessage, WSContext } from './types.js';
 
-const TOOL_MESSAGES: Record<string, string> = {
-  Read: 'Reading files to understand issues...',
-  Edit: 'Applying fixes...',
-  Write: 'Writing fixes...',
-  Grep: 'Searching for related code...',
-  Bash: 'Running verification...',
-};
-
-function createToolProgressCallback(ctx: HandlerContext, ws: WSContext, reportPath: string) {
-  const seenTools = new Set<string>();
-  return (event: ToolUseEvent) => {
-    if (event.type === 'tool_start' && event.toolName && !seenTools.has(event.toolName)) {
-      seenTools.add(event.toolName);
-      const message = TOOL_MESSAGES[event.toolName];
-      if (message) {
-        ctx.send(ws, { type: 'qualityFixProgress', data: { path: reportPath, message } });
-      }
-    }
-    if (event.type === 'tool_complete' && event.toolName === 'Edit' && event.completeInput?.file_path) {
-      ctx.send(ws, {
-        type: 'qualityFixProgress',
-        data: { path: reportPath, message: `Fixed ${String(event.completeInput.file_path).split('/').slice(-2).join('/')}` },
-      });
-    }
-  };
-}
+// ── Shared state ──────────────────────────────────────────────
 
 const persistenceCache = new Map<string, QualityPersistence>();
 const activeReviews = new Set<string>();
@@ -49,6 +33,14 @@ function getPersistence(workingDir: string): QualityPersistence {
   return persistence;
 }
 
+function resolvePath(workingDir: string, dirPath?: string): string {
+  if (!dirPath || dirPath === '.' || dirPath === './') return workingDir;
+  if (dirPath.startsWith('/')) return dirPath;
+  return join(workingDir, dirPath);
+}
+
+// ── Message router ────────────────────────────────────────────
+
 export function handleQualityMessage(
   ctx: HandlerContext,
   ws: WSContext,
@@ -60,8 +52,18 @@ export function handleQualityMessage(
     qualityDetectTools: () => handleDetectTools(ctx, ws, msg, workingDir),
     qualityScan: () => handleScan(ctx, ws, msg, workingDir),
     qualityInstallTools: () => handleInstallTools(ctx, ws, msg, workingDir),
-    qualityCodeReview: () => handleCodeReview(ctx, ws, msg, workingDir),
-    qualityFixIssues: () => handleFixIssues(ctx, ws, msg, workingDir),
+    qualityCodeReview: () => {
+      const dirPath = resolvePath(workingDir, msg.data?.path);
+      const reportPath = msg.data?.path || '.';
+      handleCodeReview(ctx, ws, reportPath, dirPath, workingDir, activeReviews, getPersistence);
+    },
+    qualityFixIssues: () => {
+      const dirPath = resolvePath(workingDir, msg.data?.path);
+      const reportPath = msg.data?.path || '.';
+      const section: string | undefined = msg.data?.section;
+      const findings: FindingForFix[] = msg.data?.findings || [];
+      handleFixIssues(ctx, ws, reportPath, dirPath, workingDir, section, findings, getPersistence);
+    },
     qualityLoadState: () => handleLoadState(ctx, ws, workingDir),
     qualitySaveDirectories: () => handleSaveDirectories(ctx, ws, msg, workingDir),
   };
@@ -80,11 +82,7 @@ export function handleQualityMessage(
   }
 }
 
-function resolvePath(workingDir: string, dirPath?: string): string {
-  if (!dirPath || dirPath === '.' || dirPath === './') return workingDir;
-  if (dirPath.startsWith('/')) return dirPath;
-  return join(workingDir, dirPath);
-}
+// ── Scan / detect / install handlers ──────────────────────────
 
 async function handleLoadState(
   ctx: HandlerContext,
@@ -94,10 +92,7 @@ async function handleLoadState(
   try {
     const persistence = getPersistence(workingDir);
     const state = persistence.loadState();
-    ctx.send(ws, {
-      type: 'qualityStateLoaded',
-      data: state,
-    });
+    ctx.send(ws, { type: 'qualityStateLoaded', data: state });
   } catch (error) {
     ctx.send(ws, {
       type: 'qualityError',
@@ -155,7 +150,6 @@ async function handleScan(
   const reportPath = msg.data?.path || '.';
 
   try {
-    // Detect installed tools so the scan can skip unavailable categories
     const { tools: detectedTools } = await detectTools(dirPath);
     const installedToolNames = detectedTools.filter((t) => t.installed).map((t) => t.name);
 
@@ -170,7 +164,6 @@ async function handleScan(
       data: { path: reportPath, results },
     });
 
-    // Persist report and append to history
     try {
       const persistence = getPersistence(workingDir);
       persistence.saveReport(reportPath, results);
@@ -215,364 +208,3 @@ async function handleInstallTools(
     });
   }
 }
-
-// ============================================================================
-// Code Review Agent
-// ============================================================================
-
-function buildCodeReviewPrompt(dirPath: string): string {
-  return `You are an expert code review agent. Your task is to perform a comprehensive, language-agnostic code review of the project in the current working directory.
-
-IMPORTANT: Your current working directory is "${dirPath}". Only review files within this directory. Do NOT traverse parent directories or review files outside this path.
-
-## Review Process
-
-1. **Discover**: Use Glob to find source files (e.g. "**/*.{ts,tsx,js,py,rs,go,java,rb,php}"). Understand the project structure. Only search within the current directory.
-2. **Read**: Read the most important files — entry points, core modules, handlers, services. Prioritize files with recent git changes (\`git diff --name-only HEAD~5\` via Bash if available).
-3. **Analyze**: Look for real, actionable issues across these categories:
-   - **security**: Injection vulnerabilities (SQL, XSS, command), hardcoded secrets/credentials, auth bypasses, insecure crypto, path traversal, SSRF, unsafe deserialization
-   - **bugs**: Null/undefined errors, race conditions, logic errors, unhandled edge cases, off-by-one errors, resource leaks, incorrect error handling
-   - **performance**: N+1 queries, unnecessary re-renders, missing memoization, blocking I/O in hot paths, unbounded data structures, missing pagination
-   - **maintainability**: God functions (>100 lines), deep nesting (>4 levels), duplicated logic, missing error handling at system boundaries, tight coupling
-
-## Rules
-
-- Only report findings you are >80% confident about. No speculative or low-confidence issues.
-- Focus on bugs and security over style. Skip formatting, naming preferences, and minor nits.
-- Each finding MUST reference a specific file and line number. Do not report vague or file-level issues.
-- Limit to the 20 most important findings, ranked by severity.
-- Do NOT modify any files. This is a read-only review.
-
-## Output
-
-After your analysis, output EXACTLY one JSON code block with your findings. No other text after the JSON block.
-
-\`\`\`json
-{
-  "findings": [
-    {
-      "severity": "critical|high|medium|low",
-      "category": "security|bugs|performance|maintainability",
-      "file": "relative/path/to/file.ts",
-      "line": 42,
-      "title": "Short title describing the issue",
-      "description": "What the problem is and why it matters.",
-      "suggestion": "How to fix it."
-    }
-  ],
-  "summary": "Brief 1-2 sentence summary of overall code quality."
-}
-\`\`\``;
-}
-
-interface CodeReviewFinding {
-  severity: 'critical' | 'high' | 'medium' | 'low';
-  category: 'security' | 'bugs' | 'performance' | 'maintainability';
-  file: string;
-  line: number | null;
-  title: string;
-  description: string;
-  suggestion?: string;
-}
-
-const VALID_SEVERITIES = new Set(['critical', 'high', 'medium', 'low']);
-const VALID_CATEGORIES = new Set(['security', 'bugs', 'performance', 'maintainability']);
-
-function normalizeFinding(f: Record<string, unknown>): CodeReviewFinding | null {
-  if (typeof f.file !== 'string' || typeof f.title !== 'string') return null;
-  return {
-    severity: VALID_SEVERITIES.has(f.severity as string) ? f.severity as CodeReviewFinding['severity'] : 'medium',
-    category: VALID_CATEGORIES.has(f.category as string) ? f.category as CodeReviewFinding['category'] : 'maintainability',
-    file: f.file as string,
-    line: typeof f.line === 'number' ? f.line : null,
-    title: f.title as string,
-    description: typeof f.description === 'string' ? f.description : '',
-    suggestion: typeof f.suggestion === 'string' ? f.suggestion : undefined,
-  };
-}
-
-function extractJson(response: string): string {
-  // Try ```json ... ``` first, then plain ``` ... ```, then largest {...} block
-  const fencedJson = response.match(/```json\s*([\s\S]*?)```/);
-  if (fencedJson) return fencedJson[1].trim();
-
-  const fencedPlain = response.match(/```\s*([\s\S]*?)```/);
-  if (fencedPlain) return fencedPlain[1].trim();
-
-  const braceMatch = response.match(/\{[\s\S]*\}/);
-  if (braceMatch) return braceMatch[0].trim();
-
-  return response.trim();
-}
-
-function parseCodeReviewResponse(response: string): { findings: CodeReviewFinding[]; summary: string } {
-  const jsonStr = extractJson(response);
-
-  try {
-    const parsed = JSON.parse(jsonStr);
-    const rawFindings: Record<string, unknown>[] = Array.isArray(parsed.findings) ? parsed.findings : [];
-    const findings = rawFindings.map(normalizeFinding).filter((f): f is CodeReviewFinding => f !== null);
-    const summary = typeof parsed.summary === 'string' ? parsed.summary : `Found ${findings.length} issue(s).`;
-    return { findings, summary };
-  } catch {
-    return { findings: [], summary: 'Failed to parse code review results.' };
-  }
-}
-
-const TOOL_START_MESSAGES: Record<string, string> = {
-  Glob: 'Discovering project files...',
-  Read: 'Reading source files...',
-  Grep: 'Searching codebase...',
-  Bash: 'Running analysis command...',
-};
-
-function getToolCompleteMessage(event: ToolUseEvent): string | null {
-  const input = event.completeInput;
-  if (!input) return null;
-  if (event.toolName === 'Read' && input.file_path) {
-    return `Reviewed ${String(input.file_path).split('/').slice(-2).join('/')}`;
-  }
-  if (event.toolName === 'Grep' && input.pattern) {
-    return `Searched for "${String(input.pattern).slice(0, 40)}"`;
-  }
-  return null;
-}
-
-function createCodeReviewProgressTracker() {
-  const seenToolStarts = new Set<string>();
-
-  return (event: ToolUseEvent): string | null => {
-    if (event.type === 'tool_start' && event.toolName) {
-      if (seenToolStarts.has(event.toolName)) return null;
-      seenToolStarts.add(event.toolName);
-      return TOOL_START_MESSAGES[event.toolName] ?? null;
-    }
-    if (event.type === 'tool_complete') return getToolCompleteMessage(event);
-    return null;
-  };
-}
-
-async function handleCodeReview(
-  ctx: HandlerContext,
-  ws: WSContext,
-  msg: WebSocketMessage,
-  workingDir: string,
-): Promise<void> {
-  const dirPath = resolvePath(workingDir, msg.data?.path);
-  const reportPath = msg.data?.path || '.';
-
-  if (activeReviews.has(dirPath)) {
-    ctx.send(ws, {
-      type: 'qualityError',
-      data: { path: reportPath, error: 'A code review is already running for this directory.' },
-    });
-    return;
-  }
-
-  activeReviews.add(dirPath);
-  try {
-    // Send initial progress
-    ctx.send(ws, {
-      type: 'qualityCodeReviewProgress',
-      data: { path: reportPath, message: 'Starting AI code review...' },
-    });
-
-    const runner = new HeadlessRunner({
-      workingDir: dirPath,
-      directPrompt: buildCodeReviewPrompt(dirPath),
-      stallWarningMs: 120_000,
-      stallKillMs: 600_000,
-      stallHardCapMs: 900_000,
-      toolUseCallback: (() => {
-        const getProgressMessage = createCodeReviewProgressTracker();
-        return (event: ToolUseEvent) => {
-          const message = getProgressMessage(event);
-          if (message) {
-            ctx.send(ws, {
-              type: 'qualityCodeReviewProgress',
-              data: { path: reportPath, message },
-            });
-          }
-        };
-      })(),
-    });
-
-    ctx.send(ws, {
-      type: 'qualityCodeReviewProgress',
-      data: { path: reportPath, message: 'Claude is analyzing your codebase...' },
-    });
-
-    const result = await runWithFileLogger('code-review', () => runner.run());
-
-    ctx.send(ws, {
-      type: 'qualityCodeReviewProgress',
-      data: { path: reportPath, message: 'Generating review report...' },
-    });
-
-    const responseText = result.assistantResponse || '';
-    const { findings, summary } = parseCodeReviewResponse(responseText);
-
-    // Recompute overall score with AI review findings included
-    let updatedResults: import('./quality-service.js').QualityResults | null = null;
-    try {
-      const persistence = getPersistence(workingDir);
-      const existingReport = persistence.loadReport(reportPath);
-      if (existingReport) {
-        updatedResults = recomputeWithAiReview(existingReport, findings);
-        updatedResults = { ...updatedResults, codeReview: findings as unknown as typeof updatedResults.codeReview };
-        persistence.saveReport(reportPath, updatedResults);
-        persistence.appendHistory(updatedResults, reportPath);
-      }
-      persistence.saveCodeReview(reportPath, findings as unknown as Record<string, unknown>[], summary);
-    } catch {
-      // Persistence failure should not break the review flow
-    }
-
-    ctx.send(ws, {
-      type: 'qualityCodeReview',
-      data: { path: reportPath, findings, summary, results: updatedResults },
-    });
-  } catch (error) {
-    ctx.send(ws, {
-      type: 'qualityError',
-      data: { path: reportPath, error: error instanceof Error ? error.message : String(error) },
-    });
-  } finally {
-    activeReviews.delete(dirPath);
-  }
-}
-
-// ============================================================================
-// Fix Issues Agent
-// ============================================================================
-
-interface FindingForFix {
-  severity: string;
-  category: string;
-  file: string;
-  line: number | null;
-  title: string;
-  description: string;
-  suggestion?: string;
-}
-
-function buildFixPrompt(findings: FindingForFix[], section?: string): string {
-  const filtered = section ? findings.filter((f) => f.category === section) : findings;
-  const sorted = filtered.sort((a, b) => {
-    const order: Record<string, number> = { critical: 0, high: 1, medium: 2, low: 3 };
-    return (order[a.severity] ?? 4) - (order[b.severity] ?? 4);
-  });
-
-  const issueList = sorted.slice(0, 30).map((f, i) => {
-    const loc = f.line ? `${f.file}:${f.line}` : f.file;
-    const parts = [`${i + 1}. [${f.severity.toUpperCase()}] ${loc} — ${f.title}`];
-    if (f.description) parts.push(`   ${f.description}`);
-    if (f.suggestion) parts.push(`   Suggestion: ${f.suggestion}`);
-    return parts.join('\n');
-  }).join('\n\n');
-
-  return `You are a code quality fix agent. Fix the following quality issues in the codebase.
-
-## Issues to Fix (${sorted.length} total, showing top ${Math.min(30, sorted.length)})
-
-${issueList}
-
-## Rules
-
-- Fix each issue by editing the relevant file at the specified location.
-- For complexity issues: refactor into smaller functions. For long files: split or extract modules. For long functions: break into smaller functions.
-- For security issues: apply the suggested fix or use secure coding best practices.
-- For bugs: fix the root cause, not just the symptom.
-- For linting/formatting: apply the standard for the project.
-- Do NOT introduce new issues. Make minimal, focused changes.
-- After fixing, verify the changes compile/pass linting if tools are available.
-- Work through the issues systematically from most to least severe.`;
-}
-
-const activeFixes = new Set<string>();
-
-async function handleFixIssues(
-  ctx: HandlerContext,
-  ws: WSContext,
-  msg: WebSocketMessage,
-  workingDir: string,
-): Promise<void> {
-  const dirPath = resolvePath(workingDir, msg.data?.path);
-  const reportPath = msg.data?.path || '.';
-  const section: string | undefined = msg.data?.section;
-  const findings: FindingForFix[] = msg.data?.findings || [];
-
-  if (activeFixes.has(dirPath)) {
-    ctx.send(ws, {
-      type: 'qualityError',
-      data: { path: reportPath, error: 'A fix operation is already running for this directory.' },
-    });
-    return;
-  }
-
-  if (findings.length === 0) {
-    ctx.send(ws, {
-      type: 'qualityError',
-      data: { path: reportPath, error: 'No findings to fix.' },
-    });
-    return;
-  }
-
-  activeFixes.add(dirPath);
-  try {
-    ctx.send(ws, {
-      type: 'qualityFixProgress',
-      data: { path: reportPath, message: 'Starting Claude Code to fix issues...' },
-    });
-
-    const prompt = buildFixPrompt(findings, section);
-
-    const runner = new HeadlessRunner({
-      workingDir: dirPath,
-      directPrompt: prompt,
-      stallWarningMs: 120_000,
-      stallKillMs: 600_000,
-      stallHardCapMs: 900_000,
-      toolUseCallback: createToolProgressCallback(ctx, ws, reportPath),
-    });
-
-    await runWithFileLogger('code-review-fix', () => runner.run());
-
-    ctx.send(ws, {
-      type: 'qualityFixProgress',
-      data: { path: reportPath, message: 'Fixes applied. Re-running quality checks...' },
-    });
-
-    // Re-run quality scan after fixing
-    const { tools: detectedTools } = await detectTools(dirPath);
-    const installedToolNames = detectedTools.filter((t) => t.installed).map((t) => t.name);
-
-    const results = await runQualityScan(dirPath, (progress) => {
-      ctx.send(ws, {
-        type: 'qualityScanProgress',
-        data: { path: reportPath, progress },
-      });
-    }, installedToolNames);
-
-    ctx.send(ws, {
-      type: 'qualityFixComplete',
-      data: { path: reportPath, results },
-    });
-
-    // Persist
-    try {
-      const persistence = getPersistence(workingDir);
-      persistence.saveReport(reportPath, results);
-      persistence.appendHistory(results, reportPath);
-    } catch {
-      // Persistence failure should not break the fix flow
-    }
-  } catch (error) {
-    ctx.send(ws, {
-      type: 'qualityError',
-      data: { path: reportPath, error: error instanceof Error ? error.message : String(error) },
-    });
-  } finally {
-    activeFixes.delete(dirPath);
-  }
-}

package/server/services/websocket/quality-linting.ts

@@ -0,0 +1,187 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+import { existsSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { runCommand, type SourceFile } from './quality-tools.js';
+import { biomeDiagToFinding, type Ecosystem, isBiomeComplexityDiagnostic, isEslintComplexityRule, type QualityFinding } from './quality-types.js';
+
+interface LintAccumulator {
+  errors: number;
+  warnings: number;
+  findings: QualityFinding[];
+  ran: boolean;
+}
+
+function newLintAccumulator(): LintAccumulator {
+  return { errors: 0, warnings: 0, findings: [], ran: false };
+}
+
+function processBiomeDiagnostic(d: Record<string, unknown>, acc: LintAccumulator): void {
+  if (isBiomeComplexityDiagnostic(d)) return;
+  if (d.severity === 'error') acc.errors++;
+  else acc.warnings++;
+  acc.findings.push(biomeDiagToFinding(d, 'linting'));
+}
+
+function parseBiomeDiagnostics(stdout: string, acc: LintAccumulator): void {
+  const parsed = JSON.parse(stdout);
+  if (!parsed.diagnostics) return;
+  for (const d of parsed.diagnostics) {
+    processBiomeDiagnostic(d, acc);
+  }
+}
+
+async function lintWithBiome(dirPath: string, acc: LintAccumulator): Promise<void> {
+  const result = await runCommand('npx', ['@biomejs/biome', 'lint', '--reporter=json', '.'], dirPath);
+  if (result.exitCode > 1) return;
+
+  acc.ran = true;
+  try {
+    parseBiomeDiagnostics(result.stdout, acc);
+  } catch {
+    acc.errors += (result.stdout.match(/error/gi) || []).length;
+    acc.warnings += (result.stdout.match(/warning/gi) || []).length;
+    acc.ran = acc.errors > 0 || acc.warnings > 0 || result.exitCode === 0;
+  }
+}
+
+function processEslintMessage(
+  msg: Record<string, unknown>,
+  filePath: string,
+  dirPath: string,
+  acc: LintAccumulator,
+): void {
+  if (isEslintComplexityRule(msg.ruleId as string)) return;
+  if (msg.severity === 2) acc.errors++;
+  else acc.warnings++;
+  acc.findings.push({
+    severity: msg.severity === 2 ? 'high' : 'medium',
+    category: 'linting',
+    file: relative(dirPath, filePath),
+    line: (msg.line as number) ?? null,
+    title: (msg.ruleId as string) || 'Lint issue',
+    description: (msg.message as string) || '',
+  });
+}
+
+async function lintWithEslint(dirPath: string, acc: LintAccumulator): Promise<void> {
+  const result = await runCommand('npx', ['eslint', '--format=json', '.'], dirPath);
+  acc.ran = true;
+  try {
+    const parsed = JSON.parse(result.stdout);
+    for (const file of parsed) {
+      for (const msg of file.messages || []) {
+        processEslintMessage(msg, file.filePath, dirPath, acc);
+      }
+    }
+  } catch {
+    acc.errors += (result.stderr.match(/error/gi) || []).length;
+    acc.warnings += (result.stderr.match(/warning/gi) || []).length;
+  }
+}
+
+async function lintNode(dirPath: string, acc: LintAccumulator): Promise<void> {
+  const biomeConfig = existsSync(join(dirPath, 'biome.json')) || existsSync(join(dirPath, 'biome.jsonc'));
+  if (biomeConfig) {
+    await lintWithBiome(dirPath, acc);
+  } else {
+    await lintWithEslint(dirPath, acc);
+  }
+}
+
+async function lintPython(dirPath: string, acc: LintAccumulator): Promise<void> {
+  const result = await runCommand('ruff', ['check', '--output-format=json', '.'], dirPath);
+  if (result.exitCode !== 0 && !result.stdout.trim().startsWith('[')) return;
+
+  acc.ran = true;
+  try {
+    const parsed = JSON.parse(result.stdout);
+    for (const item of parsed) {
+      const sev = item.code?.startsWith('E') ? 'high' : 'medium';
+      if (sev === 'high') acc.errors++;
+      else acc.warnings++;
+      acc.findings.push({
+        severity: sev,
+        category: 'linting',
+        file: item.filename ? relative(dirPath, item.filename) : '',
+        line: item.location?.row ?? null,
+        title: item.code || 'Lint issue',
+        description: item.message || '',
+      });
+    }
+  } catch { /* ignore */ }
+}
+
+function processClippyMessage(msg: Record<string, unknown>, acc: LintAccumulator): void {
+  if (msg.reason !== 'compiler-message' || !msg.message) return;
+  const message = msg.message as Record<string, unknown>;
+  const level = message.level as string;
+  if (level === 'error') acc.errors++;
+  else if (level === 'warning') acc.warnings++;
+  const spans = message.spans as Array<Record<string, unknown>> | undefined;
+  const span = spans?.[0];
+  const code = message.code as Record<string, unknown> | undefined;
+  acc.findings.push({
+    severity: level === 'error' ? 'high' : 'medium',
+    category: 'linting',
+    file: (span?.file_name as string) || '',
+    line: (span?.line_start as number) ?? null,
+    title: (code?.code as string) || 'Clippy',
+    description: (message.message as string) || '',
+  });
+}
+
+async function lintRust(dirPath: string, acc: LintAccumulator): Promise<void> {
+  const result = await runCommand('cargo', ['clippy', '--message-format=json', '--', '-W', 'clippy::all'], dirPath);
+  if (result.exitCode > 1) return;
+
+  acc.ran = true;
+  for (const line of result.stdout.split('\n')) {
+    try {
+      const msg = JSON.parse(line);
+      processClippyMessage(msg, acc);
+    } catch { /* not JSON line */ }
+  }
+}
+
+function computeLintScore(totalErrors: number, totalWarnings: number, totalLines: number): number {
+  const kloc = Math.max(totalLines / 1000, 1);
+  const penaltyRaw = totalErrors * 10 + totalWarnings * 3;
+  const penaltyPerKloc = penaltyRaw / kloc;
+
+  let score: number;
+  if (penaltyPerKloc === 0) score = 100;
+  else if (penaltyPerKloc <= 5) score = 100 - penaltyPerKloc * 2;
+  else if (penaltyPerKloc <= 20) score = 90 - (penaltyPerKloc - 5) * 2;
+  else if (penaltyPerKloc <= 50) score = 60 - (penaltyPerKloc - 20) * 1.5;
+  else score = Math.max(0, 15 - (penaltyPerKloc - 50) * 0.3);
+
+  return Math.round(Math.max(0, Math.min(100, score)));
+}
+
+export async function analyzeLinting(
+  dirPath: string,
+  ecosystems: Ecosystem[],
+  files: SourceFile[],
+): Promise<{ score: number; findings: QualityFinding[]; available: boolean; issueCount: number }> {
+  const acc = newLintAccumulator();
+
+  if (ecosystems.includes('node')) await lintNode(dirPath, acc);
+  if (ecosystems.includes('python')) await lintPython(dirPath, acc);
+  if (ecosystems.includes('rust')) await lintRust(dirPath, acc);
+
+  if (!acc.ran) {
+    return { score: 0, findings: [], available: false, issueCount: 0 };
+  }
+
+  const totalLines = files.reduce((sum, f) => sum + f.lines, 0);
+  const score = computeLintScore(acc.errors, acc.warnings, totalLines);
+
+  return {
+    score,
+    findings: acc.findings.slice(0, 100),
+    available: true,
+    issueCount: acc.errors + acc.warnings,
+  };
+}