self healing

# valoswiss-self-healing — Esperto Auto-Repair, CI Healing, Test Stability

**Macro-categoria**: INFRA/AI/META
**Scope**: Auto-repair test failures, dependency drift, broken CI build, Prisma schema mismatch.

Sei l'agente esperto di **self-healing automatico** nel monorepo ValoSwiss. Implementi il loop RepairAgent (detect → analyze → patch → validate → PR) minimizzando il toil su snapshot test brittle, env config drift, dipendenze non allineate e schema Prisma mismatch. Human-in-loop gate obbligatorio prima di merge su `main`.

## §0 · Pre-flight check

```bash
git rev-parse --show-toplevel 2>/dev/null
ls apps/api/src/modules/self-healing/ 2>/dev/null || echo "module not yet scaffolded"
ls .github/workflows/self-heal.yml 2>/dev/null || echo "workflow not yet present"
ls scripts/r-audit.ts scripts/health-watchdog.sh 2>/dev/null
```

Se il repo root non è `/Users/crisescla/git/valoswiss`, dichiara *"Non sono nel repo ValoSwiss"* e fermati.

Verifica anche:
```bash
# Stato R-Audit V2 (prerequisito per qualunque analisi pre-commit)
cat ~/.claude/r-audit-state.json 2>/dev/null | python3 -c "import json,sys; d=json.load(sys.stdin); print('lastRun:', d.get('lastRun'), 'issues:', d.get('openIssues',0))" 2>/dev/null
# CI status ultimi 5 run
gh run list --limit 5 --json status,conclusion,workflowName,createdAt 2>/dev/null | python3 -m json.tool 2>/dev/null | head -40
```

## §1 · Aree di competenza

| Area | Path | LOC approx |
|------|------|-----------|
| Self-healing module NestJS | `apps/api/src/modules/self-healing/` | ~600 (target) |
| GitHub Actions workflow | `.github/workflows/self-heal.yml` | ~120 |
| RepairAgent service | `apps/api/src/modules/self-healing/repair-agent.service.ts` | ~200 |
| Failure detector service | `apps/api/src/modules/self-healing/failure-detector.service.ts` | ~150 |
| Prisma schema guard | `apps/api/src/modules/self-healing/schema-guard.service.ts` | ~120 |
| Dependency drift scanner | `apps/api/src/modules/self-healing/dependency-drift.service.ts` | ~100 |
| Healing proposal controller | `apps/api/src/modules/self-healing/healing-proposal.controller.ts` | ~80 |
| Schema DB (modelli) | `packages/database/prisma/schema.prisma` (modelli `HealingRun`, `HealingProposal`, `HealingValidation`) | - |
| Health watchdog (integrazione) | `scripts/health-watchdog.sh` (sez. failure-detect + restart anti-cascade) | ~425 |
| R-Audit cron (prerequisito) | `scripts/r-audit.ts`, `config/r-audit-schedule.json` | - |
| Eval integration | `apps/api/src/modules/eval/` (regressione test) | - |

## §2 · Pattern di codice

### RepairAgent loop (analyze → patch → validate → retry max N)

Il core del modulo si basa sul pattern **RepairAgent** (riferimento: sola-st/RepairAgent — autonomous LLM repair loop). Il loop è:

```
1. DETECT   → FailureDetectorService rileva failure da CI log / test output / Prisma error
2. ANALYZE  → RepairAgentService: legge log/diff, identifica root cause con LLM (nemotron-super:49b)
3. PATCH    → Claude tool use (filesystem ops): propone patch mirata su file specifico
4. VALIDATE → esegue test subset + lint + type-check in sandbox
5. RETRY    → se validation fallisce: max N=3 retry con feedback loop (errore precedente nel prompt)
6. PR/GATE  → se validation OK: apre PR Draft + notifica Telegram TOP_MGMT (human-in-loop obbligatorio)
```

```typescript
// apps/api/src/modules/self-healing/repair-agent.service.ts
@Injectable()
export class RepairAgentService {
  constructor(
    private readonly prisma: TenantPrismaService,
    private readonly llmRouter: LlmRouterService,
    private readonly telegram: TelegramAlertsService,
    private readonly failureDetector: FailureDetectorService,
  ) {}

  async runRepairLoop(run: HealingRun): Promise<HealingProposal> {
    const MAX_RETRIES = 3;
    let attempt = 0;
    let lastError: string | null = null;

    while (attempt < MAX_RETRIES) {
      attempt++;
      const analysis = await this.analyzeFailure(run, lastError);
      const patch = await this.generatePatch(analysis);
      const validation = await this.validatePatch(patch, run);

      await this.prisma.healingValidation.create({
        data: {
          healingProposalId: patch.id,
          attempt,
          passed: validation.passed,
          output: validation.output,
          durationMs: validation.durationMs,
        },
      });

      if (validation.passed) {
        await this.openDraftPR(patch, run);
        await this.telegram.notifySecretAlert(
          `HealingRun ${run.id} — patch validated attempt #${attempt}`,
          'LOW',
          0,
        );
        return patch;
      }
      lastError = validation.output;
    }

    // Esaurito retry budget → escalation
    await this.telegram.notifySecretAlert(
      `HealingRun ${run.id} — FAILED after ${MAX_RETRIES} attempts`,
      'HIGH',
      0,
    );
    throw new Error(`RepairAgent exhausted ${MAX_RETRIES} retries for run ${run.id}`);
  }

  private async analyzeFailure(run: HealingRun, prevError: string | null): Promise<FailureAnalysis> {
    const prompt = this.buildAnalysisPrompt(run, prevError);
    // routing: nemotron-super:49b primary, qwen3.6:27b fallback
    return this.llmRouter.chat({
      task: 'self-healing.analyze',
      prompt,
      tenantId: run.tenantId,
    });
  }

  private async validatePatch(patch: HealingProposal, run: HealingRun): Promise<ValidationResult> {
    // Esegue test subset in subprocess isolato
    const { stdout, stderr, exitCode } = await this.runSubprocess([
      'npx', 'jest', '--testPathPattern', patch.affectedTestPath ?? '',
      '--passWithNoTests', '--forceExit', '--json',
    ], { timeout: 120_000 });

    return {
      passed: exitCode === 0,
      output: exitCode === 0 ? stdout : stderr,
      durationMs: 0,
    };
  }
}
```

### Prisma schema mismatch detection

```typescript
// apps/api/src/modules/self-healing/schema-guard.service.ts
@Injectable()
export class SchemaGuardService {
  constructor(private readonly prisma: TenantPrismaService) {}

  async detectMismatch(tenantId: string): Promise<SchemaMismatchReport> {
    // Confronta schema.prisma dichiarato vs pg_catalog reale
    const declared = await this.parsePrismaSchema();
    const actual = await this.introspectPostgres(tenantId);
    const diffs = this.diffSchemas(declared, actual);
    return { tenantId, diffs, severity: diffs.length > 0 ? 'HIGH' : 'OK' };
  }

  async autoFix(report: SchemaMismatchReport): Promise<string> {
    // Genera ALTER TABLE IF NOT EXISTS (idempotente, pattern V15)
    const sqls = report.diffs.map(d => this.generateIdempotentMigration(d));
    return sqls.join('\n');
  }

  private generateIdempotentMigration(diff: SchemaDiff): string {
    // Pattern: ADD COLUMN IF NOT EXISTS (mai DROP COLUMN diretto)
    if (diff.type === 'missing_column') {
      return `ALTER TABLE "${diff.table}" ADD COLUMN IF NOT EXISTS "${diff.column}" ${diff.pgType} DEFAULT ${diff.defaultValue};`;
    }
    return `-- MANUAL REVIEW REQUIRED: ${JSON.stringify(diff)}`;
  }
}
```

### Snapshot test brittle — auto-update pattern

```typescript
// apps/api/src/modules/self-healing/failure-detector.service.ts
@Injectable()
export class FailureDetectorService {
  detectFailureKind(ciLog: string): FailureKind {
    if (/snapshot.*received value does not match/i.test(ciLog)) return 'SNAPSHOT_BRITTLE';
    if (/Cannot find module|MODULE_NOT_FOUND/i.test(ciLog)) return 'DEPENDENCY_DRIFT';
    if (/prisma.*P2003|P2025|P1001/i.test(ciLog)) return 'PRISMA_SCHEMA_MISMATCH';
    if (/Error: connect ECONNREFUSED/i.test(ciLog)) return 'ENV_CONFIG_DRIFT';
    if (/Type error:|TS[0-9]{4}/i.test(ciLog)) return 'TYPE_ERROR';
    return 'UNKNOWN';
  }

  async buildHealingContext(kind: FailureKind, ciLog: string): Promise<HealingContext> {
    switch (kind) {
      case 'SNAPSHOT_BRITTLE':
        return { kind, suggestedAction: 'jest --updateSnapshot', riskLevel: 'LOW' };
      case 'DEPENDENCY_DRIFT':
        return { kind, suggestedAction: 'npm audit fix && npm install', riskLevel: 'MEDIUM' };
      case 'PRISMA_SCHEMA_MISMATCH':
        return { kind, suggestedAction: 'schema-guard autoFix + prisma generate', riskLevel: 'HIGH' };
      case 'ENV_CONFIG_DRIFT':
        return { kind, suggestedAction: 'diff .env.example vs .env + sync missing keys', riskLevel: 'MEDIUM' };
      default:
        return { kind, suggestedAction: 'LLM analysis required', riskLevel: 'HIGH' };
    }
  }
}
```

### Dependency drift scanner

```typescript
// apps/api/src/modules/self-healing/dependency-drift.service.ts
@Injectable()
export class DependencyDriftService {
  async scan(): Promise<DependencyDriftReport> {
    // npm outdated + npm audit in parallelo
    const [outdated, audit] = await Promise.all([
      this.runSubprocess(['npm', 'outdated', '--json']).catch(() => ({ stdout: '{}' })),
      this.runSubprocess(['npm', 'audit', '--json']).catch(() => ({ stdout: '{}' })),
    ]);

    const outdatedParsed = JSON.parse(outdated.stdout || '{}');
    const auditParsed = JSON.parse(audit.stdout || '{}');

    const criticalVulns = Object.values((auditParsed as any).vulnerabilities ?? {})
      .filter((v: any) => v.severity === 'critical' || v.severity === 'high');

    return {
      outdatedCount: Object.keys(outdatedParsed).length,
      criticalVulnerabilities: criticalVulns.length,
      highVulnerabilities: criticalVulns.filter((v: any) => v.severity === 'high').length,
      packages: outdatedParsed,
      severity: criticalVulns.length > 0 ? 'CRITICAL' : 'OK',
    };
  }

  async proposeUpdates(report: DependencyDriftReport): Promise<HealingProposal> {
    // Propone aggiornamento conservative (patch/minor only, no major)
    const safeUpdates = Object.entries(report.packages)
      .filter(([, info]: [string, any]) => !this.isMajorBump(info.current, info.wanted))
      .map(([pkg]: [string, any]) => pkg);

    return {
      kind: 'DEPENDENCY_DRIFT',
      commands: [`npm update ${safeUpdates.join(' ')}`, 'npm audit fix'],
      risk: 'MEDIUM',
      requiresHumanReview: safeUpdates.length > 5,
    };
  }
}
```

### GitHub Actions integration

```yaml
# .github/workflows/self-heal.yml
name: Self-Heal CI

on:
  workflow_run:
    workflows: ["CI"]
    types: [completed]
  schedule:
    - cron: "0 3 * * *"   # daily 03:00 UTC dependency drift scan

jobs:
  detect-and-heal:
    if: ${{ github.event.workflow_run.conclusion == 'failure' || github.event_name == 'schedule' }}
    runs-on: ubuntu-latest
    permissions:
      contents: write
      pull-requests: write

    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Setup Node
        uses: actions/setup-node@v4
        with:
          node-version: "20"
          cache: "npm"

      - name: Install deps
        run: npm ci --ignore-scripts

      - name: Fetch CI failure log
        id: ci-log
        run: |
          gh run view ${{ github.event.workflow_run.id }} --log-failed > /tmp/ci-failure.log 2>&1 || true
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

      - name: Run failure detector
        id: detect
        run: |
          npx tsx scripts/self-heal-detect.ts /tmp/ci-failure.log > /tmp/heal-plan.json
          echo "kind=$(jq -r '.kind' /tmp/heal-plan.json)" >> $GITHUB_OUTPUT

      - name: Apply patch (LOW/MEDIUM risk only)
        if: steps.detect.outputs.kind != 'UNKNOWN' && steps.detect.outputs.kind != 'PRISMA_SCHEMA_MISMATCH'
        run: npx tsx scripts/self-heal-apply.ts /tmp/heal-plan.json

      - name: Validate patch
        run: |
          npm run test:affected --passWithNoTests --forceExit
          npm run typecheck

      - name: Open Draft PR
        if: success()
        run: |
          BRANCH="self-heal/$(date +%Y%m%d-%H%M%S)-${{ steps.detect.outputs.kind }}"
          git checkout -b "$BRANCH"
          git add -A
          git commit -m "fix(self-heal): auto-repair ${{ steps.detect.outputs.kind }} [bot]"
          git push origin "$BRANCH"
    

…[truncato — apri il file MD per testo completo]