mstro-app 0.3.8 → 0.4.0

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

@@ -0,0 +1,250 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+/**
+ * Quality Persistence — Persists quality config, reports, and history
+ * to .mstro/quality/ in the working directory.
+ *
+ * Files:
+ *   .mstro/quality/config.json       — Directory list (paths + labels)
+ *   .mstro/quality/reports/<slug>.json — Latest full report per directory
+ *   .mstro/quality/history.json       — Score history entries for trend tracking
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import type { QualityResults } from './quality-service.js';
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface QualityDirectoryConfig {
+  path: string;
+  label: string;
+}
+
+interface QualityConfig {
+  directories: QualityDirectoryConfig[];
+}
+
+export interface HistoryDirectoryEntry {
+  path: string;
+  score: number;
+  grade: string;
+}
+
+export interface QualityHistoryEntry {
+  timestamp: string;
+  overall: number;
+  grade: string;
+  directories: HistoryDirectoryEntry[];
+}
+
+interface QualityHistory {
+  entries: QualityHistoryEntry[];
+}
+
+export interface QualityPersistedState {
+  directories: QualityDirectoryConfig[];
+  reports: Record<string, QualityResults>;
+  history: QualityHistoryEntry[];
+}
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+const MAX_HISTORY_ENTRIES = 100;
+
+function slugify(dirPath: string): string {
+  if (dirPath === '.' || dirPath === './') return '_root';
+  return dirPath.replace(/[/\\]/g, '_').replace(/^_+|_+$/g, '') || '_root';
+}
+
+function ensureDir(dir: string): void {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+
+function readJson<T>(filePath: string, fallback: T): T {
+  try {
+    if (existsSync(filePath)) {
+      return JSON.parse(readFileSync(filePath, 'utf-8')) as T;
+    }
+  } catch {
+    // Corrupted or unreadable — return fallback
+  }
+  return fallback;
+}
+
+function writeJson(filePath: string, data: unknown): void {
+  try {
+    writeFileSync(filePath, JSON.stringify(data, null, 2));
+  } catch (error) {
+    console.error('[QualityPersistence] Error writing:', filePath, error);
+  }
+}
+
+// ============================================================================
+// Quality Persistence
+// ============================================================================
+
+export class QualityPersistence {
+  private qualityDir: string;
+  private reportsDir: string;
+  private configPath: string;
+  private historyPath: string;
+
+  constructor(workingDir: string) {
+    this.qualityDir = join(workingDir, '.mstro', 'quality');
+    this.reportsDir = join(this.qualityDir, 'reports');
+    this.configPath = join(this.qualityDir, 'config.json');
+    this.historyPath = join(this.qualityDir, 'history.json');
+    ensureDir(this.reportsDir);
+  }
+
+  // ---- Config (directory list) ----
+
+  loadConfig(): QualityDirectoryConfig[] {
+    const config = readJson<QualityConfig>(this.configPath, { directories: [] });
+    return config.directories;
+  }
+
+  saveConfig(directories: QualityDirectoryConfig[]): void {
+    writeJson(this.configPath, { directories });
+  }
+
+  addDirectory(path: string, label: string): void {
+    const dirs = this.loadConfig();
+    if (!dirs.some((d) => d.path === path)) {
+      dirs.push({ path, label });
+      this.saveConfig(dirs);
+    }
+  }
+
+  removeDirectory(path: string): void {
+    const dirs = this.loadConfig().filter((d) => d.path !== path);
+    this.saveConfig(dirs);
+  }
+
+  // ---- Reports (latest per directory) ----
+
+  loadReport(dirPath: string): QualityResults | null {
+    const slug = slugify(dirPath);
+    const reportPath = join(this.reportsDir, `${slug}.json`);
+    return readJson<QualityResults | null>(reportPath, null);
+  }
+
+  saveReport(dirPath: string, results: QualityResults): void {
+    const slug = slugify(dirPath);
+    const reportPath = join(this.reportsDir, `${slug}.json`);
+    writeJson(reportPath, results);
+  }
+
+  loadAllReports(directories: QualityDirectoryConfig[]): Record<string, QualityResults> {
+    const reports: Record<string, QualityResults> = {};
+    for (const dir of directories) {
+      const report = this.loadReport(dir.path);
+      if (report) {
+        reports[dir.path] = report;
+      }
+    }
+    return reports;
+  }
+
+  // ---- History (trend tracking) ----
+
+  loadHistory(): QualityHistoryEntry[] {
+    const history = readJson<QualityHistory>(this.historyPath, { entries: [] });
+    return history.entries;
+  }
+
+  appendHistory(results: QualityResults, dirPath: string): void {
+    const history = this.loadHistory();
+
+    // Find or create entry for this timestamp batch
+    // If the last entry was within 60 seconds, merge into it (for multi-dir scans)
+    const now = new Date();
+    const lastEntry = history[history.length - 1];
+    const lastTime = lastEntry ? new Date(lastEntry.timestamp).getTime() : 0;
+    const mergeWindow = 60_000; // 60 seconds
+
+    const dirEntry: HistoryDirectoryEntry = {
+      path: dirPath,
+      score: results.overall,
+      grade: results.grade,
+    };
+
+    if (lastEntry && now.getTime() - lastTime < mergeWindow) {
+      // Merge: update or add this directory in the last entry
+      const existing = lastEntry.directories.findIndex((d) => d.path === dirPath);
+      if (existing >= 0) {
+        lastEntry.directories[existing] = dirEntry;
+      } else {
+        lastEntry.directories.push(dirEntry);
+      }
+      // Recompute overall as average of all directories in this entry
+      const totalScore = lastEntry.directories.reduce((sum, d) => sum + d.score, 0);
+      lastEntry.overall = Math.round(totalScore / lastEntry.directories.length);
+      lastEntry.grade = gradeFromScore(lastEntry.overall);
+      lastEntry.timestamp = now.toISOString();
+    } else {
+      // New entry
+      history.push({
+        timestamp: now.toISOString(),
+        overall: results.overall,
+        grade: results.grade,
+        directories: [dirEntry],
+      });
+    }
+
+    // Trim to max entries
+    while (history.length > MAX_HISTORY_ENTRIES) {
+      history.shift();
+    }
+
+    writeJson(this.historyPath, { entries: history });
+  }
+
+  // ---- Code Review (persisted per directory) ----
+
+  loadCodeReview(dirPath: string): { findings: Record<string, unknown>[]; summary: string; timestamp: string } | null {
+    const slug = slugify(dirPath);
+    const reviewPath = join(this.reportsDir, `${slug}-review.json`);
+    return readJson<{ findings: Record<string, unknown>[]; summary: string; timestamp: string } | null>(reviewPath, null);
+  }
+
+  saveCodeReview(dirPath: string, findings: Record<string, unknown>[], summary: string): void {
+    const slug = slugify(dirPath);
+    const reviewPath = join(this.reportsDir, `${slug}-review.json`);
+    writeJson(reviewPath, { findings, summary, timestamp: new Date().toISOString() });
+  }
+
+  // ---- Full state load ----
+
+  loadState(): QualityPersistedState {
+    const directories = this.loadConfig();
+    const reports = this.loadAllReports(directories);
+    const history = this.loadHistory();
+
+    // Merge persisted code reviews into reports
+    for (const dir of directories) {
+      const review = this.loadCodeReview(dir.path);
+      if (review && reports[dir.path]) {
+        reports[dir.path] = { ...reports[dir.path], codeReview: review.findings as unknown as QualityResults['codeReview'] };
+      }
+    }
+
+    return { directories, reports, history };
+  }
+}
+
+function gradeFromScore(score: number): string {
+  if (score >= 90) return 'A';
+  if (score >= 80) return 'B';
+  if (score >= 70) return 'C';
+  if (score >= 60) return 'D';
+  return 'F';
+}

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

@@ -54,7 +54,7 @@ export interface ScanProgress {
   total: number;
 }
 
-type Ecosystem = 'node' | 'python' | 'rust' | 'go' | 'unknown';
+type Ecosystem = 'node' | 'python' | 'rust' | 'go' | 'swift' | 'kotlin' | 'unknown';
 
 interface ToolSpec {
   name: string;
@@ -75,9 +75,9 @@ const ECOSYSTEM_TOOLS: Record<Ecosystem, ToolSpec[]> = {
     { name: 'typescript', check: ['npx', 'tsc', '--version'], category: 'general', installCmd: 'npm install -D typescript' },
   ],
   python: [
-    { name: 'ruff', check: ['ruff', '--version'], category: 'linter', installCmd: 'pip install ruff' },
-    { name: 'black', check: ['black', '--version'], category: 'formatter', installCmd: 'pip install black' },
-    { name: 'radon', check: ['radon', '--version'], category: 'complexity', installCmd: 'pip install radon' },
+    { name: 'ruff', check: ['ruff', '--version'], category: 'linter', installCmd: 'uv tool install ruff || pip install ruff' },
+    { name: 'black', check: ['black', '--version'], category: 'formatter', installCmd: 'uv tool install black || pip install black' },
+    { name: 'radon', check: ['radon', '--version'], category: 'complexity', installCmd: 'uv tool install radon || pip install radon' },
   ],
   rust: [
     { name: 'clippy', check: ['cargo', 'clippy', '--version'], category: 'linter', installCmd: 'rustup component add clippy' },
@@ -87,6 +87,14 @@ const ECOSYSTEM_TOOLS: Record<Ecosystem, ToolSpec[]> = {
     { name: 'golangci-lint', check: ['golangci-lint', '--version'], category: 'linter', installCmd: 'go install github.com/golangci-lint/golangci-lint/cmd/golangci-lint@latest' },
     { name: 'gofmt', check: ['gofmt', '-h'], category: 'formatter', installCmd: '(built-in with Go)' },
   ],
+  swift: [
+    { name: 'swiftlint', check: ['swiftlint', '--version'], category: 'linter', installCmd: 'brew install swiftlint' },
+    { name: 'swiftformat', check: ['swiftformat', '--version'], category: 'formatter', installCmd: 'brew install swiftformat' },
+  ],
+  kotlin: [
+    { name: 'ktlint', check: ['ktlint', '--version'], category: 'linter', installCmd: 'brew install ktlint' },
+    { name: 'ktfmt', check: ['ktfmt', '--version'], category: 'formatter', installCmd: 'brew install ktfmt' },
+  ],
   unknown: [],
 };
 
@@ -113,6 +121,20 @@ const FILE_LENGTH_THRESHOLD = 300;
 const FUNCTION_LENGTH_THRESHOLD = 50;
 const TOTAL_STEPS = 7;
 
+function hasInstalledToolInCategory(
+  installedSet: Set<string>,
+  ecosystems: Ecosystem[],
+  category: QualityTool['category'],
+): boolean {
+  for (const eco of ecosystems) {
+    const specs = ECOSYSTEM_TOOLS[eco] || [];
+    for (const spec of specs) {
+      if (spec.category === category && installedSet.has(spec.name)) return true;
+    }
+  }
+  return false;
+}
+
 // ============================================================================
 // Ecosystem Detection
 // ============================================================================
@@ -125,6 +147,8 @@ export function detectEcosystem(dirPath: string): Ecosystem[] {
     if (files.includes('pyproject.toml') || files.includes('setup.py') || files.includes('requirements.txt')) ecosystems.push('python');
     if (files.includes('Cargo.toml')) ecosystems.push('rust');
     if (files.includes('go.mod')) ecosystems.push('go');
+    if (files.includes('Package.swift') || files.some(f => f.endsWith('.xcodeproj') || f.endsWith('.xcworkspace'))) ecosystems.push('swift');
+    if (files.includes('build.gradle') || files.includes('build.gradle.kts')) ecosystems.push('kotlin');
   } catch {
     // Directory not readable
   }
@@ -132,6 +156,29 @@ export function detectEcosystem(dirPath: string): Ecosystem[] {
   return ecosystems;
 }
 
+/** Detect the Node.js package manager from lockfiles */
+function detectNodePackageManager(dirPath: string): 'npm' | 'yarn' | 'pnpm' | 'bun' {
+  try {
+    const files = readdirSync(dirPath);
+    if (files.includes('bun.lockb') || files.includes('bun.lock')) return 'bun';
+    if (files.includes('pnpm-lock.yaml')) return 'pnpm';
+    if (files.includes('yarn.lock')) return 'yarn';
+  } catch {
+    // Directory not readable
+  }
+  return 'npm';
+}
+
+/** Build the install command for a Node.js dev dependency */
+function nodeInstallCmd(pm: 'npm' | 'yarn' | 'pnpm' | 'bun', pkg: string): string {
+  switch (pm) {
+    case 'yarn': return `yarn add -D ${pkg}`;
+    case 'pnpm': return `pnpm add -D ${pkg}`;
+    case 'bun': return `bun add -d ${pkg}`;
+    default: return `npm install -D ${pkg}`;
+  }
+}
+
 // ============================================================================
 // Tool Detection
 // ============================================================================
@@ -151,15 +198,20 @@ async function checkToolInstalled(check: string[], cwd: string): Promise<boolean
 export async function detectTools(dirPath: string): Promise<{ tools: QualityTool[]; ecosystem: string[] }> {
   const ecosystems = detectEcosystem(dirPath);
   const tools: QualityTool[] = [];
+  const nodePm = ecosystems.includes('node') ? detectNodePackageManager(dirPath) : 'npm';
 
   for (const eco of ecosystems) {
     const specs = ECOSYSTEM_TOOLS[eco] || [];
     for (const spec of specs) {
       const installed = await checkToolInstalled(spec.check, dirPath);
+      // For node tools, resolve install command using the project's package manager
+      const installCommand = eco === 'node'
+        ? nodeInstallCmd(nodePm, spec.installCmd.replace(/^npm install -D /, ''))
+        : spec.installCmd;
       tools.push({
         name: spec.name,
         installed,
-        installCommand: spec.installCmd,
+        installCommand,
         category: spec.category,
       });
     }
@@ -179,14 +231,35 @@ export async function installTools(
   const { tools } = await detectTools(dirPath);
   const toInstall = tools.filter((t) => !t.installed && (!toolNames || toolNames.includes(t.name)));
 
+  const failures: string[] = [];
   for (const tool of toInstall) {
     if (tool.installCommand.startsWith('(')) continue; // built-in, skip
-    const parts = tool.installCommand.split(' ');
-    await runCommand(parts[0], parts.slice(1), dirPath);
+    // Support chained commands with || (try first, fallback to second)
+    const commands = tool.installCommand.split(' || ');
+    let installed = false;
+    for (const cmd of commands) {
+      const parts = cmd.trim().split(' ');
+      const result = await runCommand(parts[0], parts.slice(1), dirPath);
+      if (result.exitCode === 0) { installed = true; break; }
+    }
+    if (!installed) {
+      failures.push(`${tool.name}: all install methods failed`);
+    }
   }
 
   // Re-detect after install
-  return detectTools(dirPath);
+  const detected = await detectTools(dirPath);
+
+  // Check if any requested tools are still missing after install
+  const requestedNames = new Set(toolNames ?? toInstall.map((t) => t.name));
+  const stillMissing = detected.tools.filter((t) => !t.installed && requestedNames.has(t.name)).map((t) => t.name);
+
+  if (stillMissing.length > 0) {
+    const detail = failures.length > 0 ? ` ${failures.join('; ')}` : '';
+    throw new Error(`Failed to install: ${stillMissing.join(', ')}.${detail}`);
+  }
+
+  return detected;
 }
 
 // ============================================================================
@@ -371,7 +444,7 @@ async function lintNode(dirPath: string, acc: LintAccumulator): Promise<void> {
 
 async function lintPython(dirPath: string, acc: LintAccumulator): Promise<void> {
   const result = await runCommand('ruff', ['check', '--output-format=json', '.'], dirPath);
-  if (result.exitCode > 1) return;
+  if (result.exitCode !== 0 && !result.stdout.trim().startsWith('[')) return;
 
   acc.ran = true;
   try {
@@ -789,16 +862,47 @@ interface CategoryWeights {
   complexity: number;
   fileLength: number;
   functionLength: number;
+  aiReview: number;
 }
 
 const DEFAULT_WEIGHTS: CategoryWeights = {
-  linting: 0.30,
-  formatting: 0.15,
-  complexity: 0.25,
-  fileLength: 0.15,
-  functionLength: 0.15,
+  linting: 0.25,
+  formatting: 0.10,
+  complexity: 0.20,
+  fileLength: 0.12,
+  functionLength: 0.13,
+  aiReview: 0.20,
 };
 
+// ============================================================================
+// AI Code Review Score
+// ============================================================================
+
+const SEVERITY_PENALTY: Record<string, number> = {
+  critical: 10.0,
+  high: 5.0,
+  medium: 2.0,
+  low: 0.5,
+};
+
+/** Exponential decay constant — higher = harsher scoring */
+const AI_REVIEW_DECAY = 0.10;
+
+export function computeAiReviewScore(
+  findings: Array<{ severity: string }>,
+  totalLines: number,
+): number {
+  if (findings.length === 0) return 100;
+
+  const effectiveKloc = Math.max(totalLines / 1000, 1.0);
+  const totalPenalty = findings.reduce(
+    (sum, f) => sum + (SEVERITY_PENALTY[f.severity] ?? 2.0),
+    0,
+  );
+  const penaltyDensity = totalPenalty / effectiveKloc;
+  return Math.round(100 * Math.exp(-AI_REVIEW_DECAY * penaltyDensity));
+}
+
 function computeOverallScore(categories: CategoryScore[]): number {
   const available = categories.filter((c) => c.available);
   if (available.length === 0) return 0;
@@ -823,9 +927,13 @@ export type ProgressCallback = (progress: ScanProgress) => void;
 export async function runQualityScan(
   dirPath: string,
   onProgress?: ProgressCallback,
+  installedToolNames?: string[],
 ): Promise<QualityResults> {
   const ecosystems = detectEcosystem(dirPath);
 
+  // Build set of installed tools for gating analyses
+  const installedSet = installedToolNames ? new Set(installedToolNames) : null;
+
   const progress = (step: string, current: number) => {
     onProgress?.({ step, current, total: TOTAL_STEPS });
   };
@@ -834,13 +942,19 @@ export async function runQualityScan(
   progress('Collecting source files', 1);
   const files = collectSourceFiles(dirPath, dirPath);
 
-  // Step 2: Run linting
+  // Step 2: Run linting (only if a linter is installed)
   progress('Running linters', 2);
-  const lintResult = await analyzeLinting(dirPath, ecosystems, files);
+  const hasLinter = !installedSet || hasInstalledToolInCategory(installedSet, ecosystems, 'linter');
+  const lintResult = hasLinter
+    ? await analyzeLinting(dirPath, ecosystems, files)
+    : { score: 0, findings: [], available: false, issueCount: 0 };
 
-  // Step 3: Check formatting
+  // Step 3: Check formatting (only if a formatter is installed)
   progress('Checking formatting', 3);
-  const fmtResult = await analyzeFormatting(dirPath, ecosystems, files);
+  const hasFormatter = !installedSet || hasInstalledToolInCategory(installedSet, ecosystems, 'formatter');
+  const fmtResult = hasFormatter
+    ? await analyzeFormatting(dirPath, ecosystems, files)
+    : { score: 0, available: false, issueCount: 0 };
 
   // Step 4: Analyze complexity
   progress('Analyzing complexity', 4);
@@ -898,6 +1012,14 @@ export async function runQualityScan(
       available: true,
       issueCount: funcLengthResult.issueCount,
     },
+    {
+      name: 'AI Review',
+      score: 0,
+      weight: DEFAULT_WEIGHTS.aiReview,
+      effectiveWeight: DEFAULT_WEIGHTS.aiReview,
+      available: false,
+      issueCount: 0,
+    },
   ];
 
   const overall = computeOverallScore(categories);
@@ -920,3 +1042,46 @@ export async function runQualityScan(
     ecosystem: ecosystems,
   };
 }
+
+// ============================================================================
+// Recompute with AI Review
+// ============================================================================
+
+/**
+ * Recompute the overall score after AI code review findings become available.
+ * Returns a new QualityResults with the AI Review category enabled and score updated.
+ */
+export function recomputeWithAiReview(
+  results: QualityResults,
+  aiFindings: Array<{ severity: string }>,
+): QualityResults {
+  const aiScore = computeAiReviewScore(aiFindings, results.totalLines);
+
+  // Update or add the AI Review category
+  const categories = results.categories.map((cat) => ({ ...cat }));
+  const aiCatIndex = categories.findIndex((c) => c.name === 'AI Review');
+  const aiCategory: CategoryScore = {
+    name: 'AI Review',
+    score: aiScore,
+    weight: DEFAULT_WEIGHTS.aiReview,
+    effectiveWeight: DEFAULT_WEIGHTS.aiReview,
+    available: true,
+    issueCount: aiFindings.length,
+  };
+
+  if (aiCatIndex >= 0) {
+    categories[aiCatIndex] = aiCategory;
+  } else {
+    categories.push(aiCategory);
+  }
+
+  const overall = computeOverallScore(categories);
+
+  return {
+    ...results,
+    overall,
+    grade: computeGrade(overall),
+    categories,
+    codeReview: results.codeReview,
+  };
+}

package/server/services/websocket/types.ts

@@ -112,11 +112,31 @@ export interface WebSocketMessage {
     | 'qualityScan'
     | 'qualityInstallTools'
     | 'qualityCodeReview'
+    | 'qualityFixIssues'
+    | 'qualityLoadState'
+    | 'qualitySaveDirectories'
     // File upload message types (chunked remote uploads)
     | 'fileUploadStart'
     | 'fileUploadChunk'
     | 'fileUploadComplete'
-    | 'fileUploadCancel';
+    | 'fileUploadCancel'
+    // Plan message types
+    | 'planInit'
+    | 'planGetState'
+    | 'planListIssues'
+    | 'planGetIssue'
+    | 'planGetSprint'
+    | 'planGetMilestone'
+    | 'planCreateIssue'
+    | 'planUpdateIssue'
+    | 'planDeleteIssue'
+    | 'planScaffold'
+    | 'planPrompt'
+    | 'planExecute'
+    | 'planExecuteEpic'
+    | 'planPause'
+    | 'planStop'
+    | 'planResume';
   tabId?: string;
   terminalId?: string;
   // biome-ignore lint/suspicious/noExplicitAny: message envelope carries heterogeneous payloads
@@ -231,12 +251,38 @@ export interface WebSocketResponse {
     | 'qualityInstallProgress'
     | 'qualityInstallComplete'
     | 'qualityCodeReview'
+    | 'qualityCodeReviewProgress'
     | 'qualityPostSession'
+    | 'qualityFixProgress'
+    | 'qualityFixComplete'
     | 'qualityError'
+    | 'qualityStateLoaded'
     // File upload response types
     | 'fileUploadAck'
     | 'fileUploadReady'
-    | 'fileUploadError';
+    | 'fileUploadError'
+    // Plan response types
+    | 'planState'
+    | 'planIssueList'
+    | 'planIssue'
+    | 'planSprint'
+    | 'planMilestone'
+    | 'planNotFound'
+    | 'planStateUpdated'
+    | 'planIssueUpdated'
+    | 'planIssueCreated'
+    | 'planIssueDeleted'
+    | 'planScaffolded'
+    | 'planPromptStreaming'
+    | 'planPromptProgress'
+    | 'planPromptResponse'
+    | 'planExecutionStarted'
+    | 'planExecutionProgress'
+    | 'planExecutionOutput'
+    | 'planExecutionMetrics'
+    | 'planExecutionComplete'
+    | 'planExecutionError'
+    | 'planError';
   tabId?: string;
   terminalId?: string;
   // biome-ignore lint/suspicious/noExplicitAny: message envelope carries heterogeneous payloads