ios-app-review-plugin 1.0.0

package/src/history/comparator.ts

@@ -0,0 +1,114 @@
+import type { Issue } from '../types/index.js';
+import type { ScanRecord, HistoricalComparison, TrendReport } from './types.js';
+import * as path from 'path';
+
+export class ScanComparator {
+  /**
+   * Create a fingerprint for an issue that is stable across scans.
+   * Uses id + category + relative file path (excluding line number which can shift).
+   */
+  fingerprint(issue: Issue, projectPath: string): string {
+    const relativePath = issue.filePath
+      ? path.relative(projectPath, issue.filePath)
+      : '';
+    return `${issue.id}::${issue.category}::${relativePath}`;
+  }
+
+  compare(previous: ScanRecord, current: ScanRecord): HistoricalComparison {
+    const prevFingerprints = new Set<string>();
+    const currFingerprints = new Set<string>();
+
+    for (const result of previous.report.results) {
+      for (const issue of result.issues) {
+        prevFingerprints.add(this.fingerprint(issue, previous.projectPath));
+      }
+    }
+
+    for (const result of current.report.results) {
+      for (const issue of result.issues) {
+        currFingerprints.add(this.fingerprint(issue, current.projectPath));
+      }
+    }
+
+    const newIssues: string[] = [];
+    const resolvedIssues: string[] = [];
+    const ongoingIssues: string[] = [];
+
+    for (const fp of currFingerprints) {
+      if (prevFingerprints.has(fp)) {
+        ongoingIssues.push(fp);
+      } else {
+        newIssues.push(fp);
+      }
+    }
+
+    for (const fp of prevFingerprints) {
+      if (!currFingerprints.has(fp)) {
+        resolvedIssues.push(fp);
+      }
+    }
+
+    const scoreDelta = current.score - previous.score;
+    let trend: 'improving' | 'declining' | 'stable';
+    if (scoreDelta > 2) {
+      trend = 'improving';
+    } else if (scoreDelta < -2) {
+      trend = 'declining';
+    } else {
+      trend = 'stable';
+    }
+
+    return {
+      previousScan: previous,
+      currentScan: current,
+      newIssues,
+      resolvedIssues,
+      ongoingIssues,
+      scoreDelta,
+      trend,
+    };
+  }
+
+  analyzeTrend(scans: ScanRecord[]): TrendReport {
+    const scanData = scans.map((s) => ({
+      id: s.id,
+      timestamp: s.timestamp,
+      score: s.score,
+    }));
+
+    const scores = scanData.map((s) => s.score);
+
+    // Determine trend from last 3 scores
+    let overallTrend: 'improving' | 'declining' | 'stable' = 'stable';
+    if (scores.length >= 3) {
+      const recent = scores.slice(-3);
+      const first = recent[0]!;
+      const last = recent[recent.length - 1]!;
+      const delta = last - first;
+      if (delta > 5) {
+        overallTrend = 'improving';
+      } else if (delta < -5) {
+        overallTrend = 'declining';
+      }
+    } else if (scores.length >= 2) {
+      const first = scores[0]!;
+      const last = scores[scores.length - 1]!;
+      const delta = last - first;
+      if (delta > 2) {
+        overallTrend = 'improving';
+      } else if (delta < -2) {
+        overallTrend = 'declining';
+      }
+    }
+
+    const sum = scores.reduce((a, b) => a + b, 0);
+
+    return {
+      scans: scanData,
+      overallTrend,
+      averageScore: scores.length > 0 ? Math.round(sum / scores.length) : 0,
+      bestScore: scores.length > 0 ? Math.max(...scores) : 0,
+      worstScore: scores.length > 0 ? Math.min(...scores) : 0,
+    };
+  }
+}

package/src/history/index.ts

@@ -0,0 +1,3 @@
+export { HistoryStore } from './store.js';
+export { ScanComparator } from './comparator.js';
+export type { ScanRecord, HistoricalComparison, TrendReport, ScanIndex } from './types.js';

package/src/history/store.ts

@@ -0,0 +1,135 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import * as crypto from 'crypto';
+import type { AnalysisReport } from '../types/index.js';
+import type { ScanRecord, ScanIndex } from './types.js';
+
+export class HistoryStore {
+  private baseDir: string;
+
+  constructor(projectPath: string) {
+    this.baseDir = path.join(projectPath, '.ios-review-history');
+  }
+
+  private get scansDir(): string {
+    return path.join(this.baseDir, 'scans');
+  }
+
+  private get indexPath(): string {
+    return path.join(this.baseDir, 'index.json');
+  }
+
+  private async ensureDirs(): Promise<void> {
+    await fs.mkdir(this.scansDir, { recursive: true });
+  }
+
+  private async loadIndex(): Promise<ScanIndex> {
+    try {
+      const data = await fs.readFile(this.indexPath, 'utf-8');
+      return JSON.parse(data) as ScanIndex;
+    } catch {
+      return { scans: [] };
+    }
+  }
+
+  private async saveIndex(index: ScanIndex): Promise<void> {
+    await fs.writeFile(this.indexPath, JSON.stringify(index, null, 2));
+  }
+
+  private getGitInfo(projectPath: string): { commit?: string; branch?: string } {
+    try {
+      const commit = execSync('git rev-parse HEAD', { cwd: projectPath, encoding: 'utf-8' }).trim();
+      const branch = execSync('git rev-parse --abbrev-ref HEAD', { cwd: projectPath, encoding: 'utf-8' }).trim();
+      return { commit, branch };
+    } catch {
+      return {};
+    }
+  }
+
+  async saveScan(report: AnalysisReport, score: number): Promise<ScanRecord> {
+    await this.ensureDirs();
+
+    const id = crypto.randomUUID();
+    const gitInfo = this.getGitInfo(report.projectPath);
+
+    const record: ScanRecord = {
+      id,
+      timestamp: report.timestamp,
+      projectPath: report.projectPath,
+      gitCommit: gitInfo.commit,
+      gitBranch: gitInfo.branch,
+      report,
+      score,
+    };
+
+    // Save scan file
+    const scanPath = path.join(this.scansDir, `${id}.json`);
+    await fs.writeFile(scanPath, JSON.stringify(record, null, 2));
+
+    // Update index
+    const index = await this.loadIndex();
+    index.scans.push({
+      id,
+      timestamp: record.timestamp,
+      projectPath: record.projectPath,
+      score,
+      gitCommit: gitInfo.commit,
+      gitBranch: gitInfo.branch,
+    });
+    await this.saveIndex(index);
+
+    return record;
+  }
+
+  async getLatestScan(): Promise<ScanRecord | null> {
+    const index = await this.loadIndex();
+    if (index.scans.length === 0) return null;
+
+    const latest = index.scans[index.scans.length - 1];
+    if (!latest) return null;
+
+    try {
+      const data = await fs.readFile(path.join(this.scansDir, `${latest.id}.json`), 'utf-8');
+      return JSON.parse(data) as ScanRecord;
+    } catch {
+      return null;
+    }
+  }
+
+  async getScan(id: string): Promise<ScanRecord | null> {
+    try {
+      const data = await fs.readFile(path.join(this.scansDir, `${id}.json`), 'utf-8');
+      return JSON.parse(data) as ScanRecord;
+    } catch {
+      return null;
+    }
+  }
+
+  async listScans(limit?: number): Promise<ScanIndex['scans']> {
+    const index = await this.loadIndex();
+    const scans = index.scans.slice().reverse(); // newest first
+    return limit ? scans.slice(0, limit) : scans;
+  }
+
+  async pruneHistory(keepCount: number): Promise<number> {
+    const index = await this.loadIndex();
+    if (index.scans.length <= keepCount) return 0;
+
+    const toRemove = index.scans.slice(0, index.scans.length - keepCount);
+    const kept = index.scans.slice(index.scans.length - keepCount);
+
+    for (const scan of toRemove) {
+      try {
+        await fs.unlink(path.join(this.scansDir, `${scan.id}.json`));
+      } catch {
+        // Ignore missing files
+      }
+    }
+
+    index.scans = kept;
+    await this.saveIndex(index);
+
+    return toRemove.length;
+  }
+}

package/src/history/types.ts

@@ -0,0 +1,40 @@
+import type { AnalysisReport } from '../types/index.js';
+
+export interface ScanRecord {
+  id: string;
+  timestamp: string;
+  projectPath: string;
+  gitCommit?: string | undefined;
+  gitBranch?: string | undefined;
+  report: AnalysisReport;
+  score: number;
+}
+
+export interface HistoricalComparison {
+  previousScan: ScanRecord;
+  currentScan: ScanRecord;
+  newIssues: string[];      // fingerprints
+  resolvedIssues: string[]; // fingerprints
+  ongoingIssues: string[];  // fingerprints
+  scoreDelta: number;
+  trend: 'improving' | 'declining' | 'stable';
+}
+
+export interface TrendReport {
+  scans: Array<{ id: string; timestamp: string; score: number }>;
+  overallTrend: 'improving' | 'declining' | 'stable';
+  averageScore: number;
+  bestScore: number;
+  worstScore: number;
+}
+
+export interface ScanIndex {
+  scans: Array<{
+    id: string;
+    timestamp: string;
+    projectPath: string;
+    score: number;
+    gitCommit?: string | undefined;
+    gitBranch?: string | undefined;
+  }>;
+}