pi-jev-guard 0.1.0

package/src/commands.ts

@@ -0,0 +1,408 @@
+import { readFileSync, existsSync, statSync, realpathSync, writeFileSync, mkdirSync, chmodSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import type { ExtensionAPI, ModelRegistry } from "@earendil-works/pi-coding-agent";
+import type { JevConfig } from "./config.ts";
+import { defaultConfigPath, expandHome, parseUpstreamRef, resolveBackend, saveConfig } from "./config.ts";
+import type { ReviewFn } from "./reviewer.ts";
+import { reviewWithCoverage } from "./reviewer.ts";
+import type { Metrics } from "./metrics.ts";
+import type { OutputVerdict } from "./output-judge.ts";
+import type { GateVerdictReport } from "./automatic/guardian.ts";
+
+export interface GateStatusView {
+  active: boolean;
+  twin?: string;
+  upstream?: string;
+  reason: string;
+}
+
+export interface UpstreamResult {
+  ok: boolean;
+  error?: string;
+  twin?: string;
+}
+
+export interface JevCommandDeps {
+  config: () => JevConfig;
+  setMode: (mode: "on-demand" | "automatic") => JevConfig;
+  reload: () => JevConfig;
+  review: () => ReviewFn;
+  reviewerInfo: () => { backend: string; model: string };
+  metrics: Metrics;
+  gateStatus: () => GateStatusView;
+  setUpstream: (
+    registry: ModelRegistry,
+    providerId: string,
+    modelId: string,
+  ) => UpstreamResult;
+  refreshUpstream: (registry: ModelRegistry) => UpstreamResult;
+  removeGuarded: () => { ok: boolean; error?: string };
+  switchToGuarded: (registry: ModelRegistry) => Promise<{
+    ok: boolean;
+    error?: string;
+    model?: string;
+  }>;
+  getLastOutput: () => { tool: string; verdict: OutputVerdict; at: number } | undefined;
+  getLastGate: () => { report: GateVerdictReport; at: number } | undefined;
+}
+
+export const JEV_SUBCOMMANDS = [
+  "status",
+  "mode",
+  "models",
+  "upstream",
+  "off",
+  "refresh-upstream",
+  "check",
+  "stats",
+  "reload",
+  "output",
+  "last",
+  "save-key",
+  "help",
+] as const;
+
+export const JEV_HELP_TEXT = [
+  "Jev guard — verifica risposte con TypeSafe Jev (via OpenRouter o diretto).",
+  "",
+  "  /jev status              Stato: modalità, backend, policy, gate, auth",
+  "  /jev mode on-demand      Solo verifiche esplicite (default, zero costi impliciti)",
+  "  /jev mode automatic      Enforcement: seleziona il twin guarded + verifica",
+  "  /jev models [filtro]     Modelli pi (● twin guarded attivo, ★ ultimo salvato)",
+  "  /jev upstream P M        Crea twin guarded M__jev dentro il provider P (salvato)",
+  "  /jev upstream P/M        Stessa cosa in forma compatta",
+  "  /jev upstream            Riapplica l'ultimo upstream salvato",
+  "  /jev off                 Rimuove il twin (torna on-demand)",
+  "  /jev refresh-upstream    Ricrea il twin dal registry (dopo refresh cataloghi)",
+  "  /jev check <file> [req]  Verifica un file subito, senza cambiare modalità",
+  "  /jev stats               Conteggi pass/block/review/unavailable + latenze",
+  "  /jev output              Ultimo output giudicato: leak + classe errore",
+  "  /jev last                Ultimo verdetto del gate (twin): esito e controlli",
+  "  /jev save-key            Salva la chiave Jev su file (permessi 600)",
+  "  /jev reload              Ricarica jev-config.json da disco",
+  "  /jev help                Questo aiuto",
+  "",
+  "Flusso tipico: /jev upstream deepseek deepseek-flash → /model (scegli __jev)",
+  "→ /jev mode automatic. Il twin usa la STESSA auth del provider: nessun login extra.",
+  "Torna normale con: /model + /jev mode on-demand.",
+  "Env JEV_AUTO_UPSTREAM=P/M: crea il twin all'avvio (default: nessuno;",
+  "con pi --print solo deepseek/deepseek-flash).",
+].join("\n");
+
+export function registerJevCommand(pi: ExtensionAPI, deps: JevCommandDeps) {
+  pi.registerCommand("jev", {
+    description:
+      "Jev guard: verifica con TypeSafe Jev. Sottocomandi: status, mode, models, upstream, off, check, stats, help.",
+    getArgumentCompletions: (argumentPrefix) => {
+      const prefix = argumentPrefix.trim().toLowerCase();
+      return JEV_SUBCOMMANDS.filter((s) => s.startsWith(prefix)).map(
+        (s) => ({ value: s, label: `/jev ${s}` }),
+      );
+    },
+    handler: async (args, ctx) => {
+      const parts = args.trim().split(/\s+/).filter(Boolean);
+      const sub = parts[0] ?? "status";
+
+      if (sub === "help" || sub === "--help" || sub === "-h") {
+        ctx.ui.notify(JEV_HELP_TEXT, "info");
+        return;
+      }
+
+      if (sub === "status") {
+        const cfg = deps.config();
+        const resolved = resolveBackend(cfg);
+        const info = deps.reviewerInfo();
+        const gate = deps.gateStatus();
+        const authProvider = gate.upstream?.split("/")[0] ?? cfg.automatic.upstreamProvider;
+        let guardedAuth = "—";
+        if (gate.active) {
+          try {
+            const st = ctx.modelRegistry.getProviderAuthStatus(authProvider);
+            guardedAuth = st.configured
+              ? `pronto (${st.source ?? "configurato"}, condivisa col provider)`
+              : `non configurato — /login ${authProvider}`;
+          } catch {
+            guardedAuth = "sconosciuto";
+          }
+        }
+        ctx.ui.notify(
+          [
+            `Modalità: ${cfg.mode}`,
+            `Backend: ${info.backend} (setting=${cfg.jev.backend}, ${resolved.reason})`,
+            `Modello: ${info.model}`,
+            `Verificatore timeout: ${resolved.timeoutMs}ms`,
+            `Policy: ${cfg.policy.revision} pass<=${cfg.policy.passMaxFlawProbability} block>=${cfg.policy.blockMinFlawProbability}`,
+            `Chiave presente: ${resolved.apiKeyPresent ? "sì" : "no"} (${resolved.keySource})`,
+            `Gate: ${gate.active ? `attivo (twin ${gate.twin}, stessa auth di ${authProvider})` : `non attivo (${gate.reason})`}`,
+            `Ultimo upstream salvato: ${cfg.automatic.upstreamProvider}/${cfg.automatic.upstreamModel}`,
+            `Auth guarded: ${guardedAuth}`,
+            `Tool policy: ${cfg.toolsPolicy.enabled ? "attiva in automatic (bash/powershell/write/edit)" : "disattiva (config)"}`,
+            `Exfil check: ${cfg.exfilCheck.enabled ? "attivo in automatic (confirm in TUI, fail-open)" : "disattivo (config)"}`,
+            `Output judge: ${cfg.outputJudge.enabled ? `attivo in automatic (tool: ${cfg.outputJudge.tools.join(",") || "—"}, fail-open)` : "disattivo (config)"}`,
+            cfg.mode === "automatic"
+              ? "ATTENZIONE: in automatic testo/codice vengono inviati al verificatore. Crea il twin con /jev upstream e seleziona il modello __jev per enforcement."
+              : "on-demand: nessuna verifica automatica.",
+          ].join("\n"),
+          "info",
+        );
+        return;
+      }
+
+      if (sub === "mode") {
+        const value = parts[1];
+        if (value !== "on-demand" && value !== "automatic") {
+          ctx.ui.notify("Uso: /jev mode on-demand|automatic", "warning");
+          return;
+        }
+        deps.setMode(value);
+        if (value === "automatic") {
+          const sw = await deps.switchToGuarded(ctx.modelRegistry);
+          ctx.ui.notify(
+            `Modalità automatic attivata. Testo/codice saranno inviati a ${deps.reviewerInfo().backend}. ` +
+              (sw.ok
+                ? `Modello selezionato: ${sw.model} (enforcement attivo).`
+                : `ATTENZIONE: ${sw.error} (solo diagnostica, nessun enforcement).`),
+            sw.ok ? "info" : "warning",
+          );
+        } else {
+          ctx.ui.notify("Modalità on-demand attivata. Nessuna verifica automatica.", "info");
+        }
+        return;
+      }
+
+      if (sub === "models") {
+        const cfg = deps.config();
+        const filter = parts.slice(1).join(" ").toLowerCase();
+        let all: Array<{ provider: string; id: string; api: string }>;
+        try {
+          all = ctx.modelRegistry.getAll().map((m) => ({
+            provider: m.provider,
+            id: m.id,
+            api: m.api,
+          }));
+        } catch {
+          ctx.ui.notify("Elenco modelli non disponibile.", "error");
+          return;
+        }
+        const gate = deps.gateStatus();
+        const activeTwin = gate.active ? gate.twin ?? "" : "";
+        const saved = `${cfg.automatic.upstreamProvider}/${cfg.automatic.upstreamModel}`;
+        const matched = all.filter((m) => {
+          if (!filter) return true;
+          return `${m.provider}/${m.id}`.toLowerCase().includes(filter);
+        });
+        const lines = matched.slice(0, 40).map((m) => {
+          const ref = `${m.provider}/${m.id}`;
+          const mark = ref === activeTwin ? "● " : ref === saved ? "★ " : "  ";
+          return `${mark}${ref}  [${m.api}]`;
+        });
+        const header =
+          `Twin guarded: ${activeTwin ? `● ${activeTwin}` : "nessuno — /jev upstream <provider> <model>"}` +
+          `\nUltimo salvato: ★ ${saved}`;
+        const more = matched.length > 40 ? `\n… +${matched.length - 40} (raffina il filtro)` : "";
+        ctx.ui.notify(
+          [header, `Modelli: ${matched.length}/${all.length}`, "", ...lines].join("\n") + more,
+          "info",
+        );
+        return;
+      }
+
+      if (sub === "upstream") {
+        // Senza argomenti: riapplica l'ultimo upstream salvato.
+        if (parts.length === 1) {
+          const res = deps.refreshUpstream(ctx.modelRegistry);
+          ctx.ui.notify(
+            res.ok
+              ? `Twin ripristinato: ${res.twin}. Selezionalo con /model.`
+              : `Ripristino fallito: ${res.error}`,
+            res.ok ? "info" : "error",
+          );
+          return;
+        }
+        const parsed = parseUpstreamRef(parts.slice(1));
+        if ("error" in parsed) {
+          ctx.ui.notify(parsed.error, "warning");
+          return;
+        }
+        const res = deps.setUpstream(ctx.modelRegistry, parsed.provider, parsed.model);
+        if (!res.ok) {
+          ctx.ui.notify(`Upstream non cambiato: ${res.error}`, "error");
+          return;
+        }
+        ctx.ui.notify(
+          `Twin creato: ${res.twin} da ${parsed.provider}/${parsed.model} (salvato, stessa auth del provider). ` +
+            `Selezionalo con /model per enforcement in automatic.`,
+          "info",
+        );
+        return;
+      }
+
+      if (sub === "off") {
+        const res = deps.removeGuarded();
+        if (res.ok) {
+          // Senza twin, automatic è contraddittorio: torna on-demand.
+          deps.setMode("on-demand");
+        }
+        ctx.ui.notify(
+          res.ok
+            ? "Twin rimosso (provider originale ripristinato), modalità on-demand."
+            : `Niente da rimuovere: ${res.error}`,
+          res.ok ? "info" : "warning",
+        );
+        return;
+      }
+
+      if (sub === "refresh-upstream") {
+        const res = deps.refreshUpstream(ctx.modelRegistry);
+        ctx.ui.notify(
+          res.ok
+            ? `Twin riallineato: ${res.twin}`
+            : `Refresh fallito: ${res.error}`,
+          res.ok ? "info" : "error",
+        );
+        return;
+      }
+
+      if (sub === "last") {
+        const last = deps.getLastGate();
+        if (!last) {
+          ctx.ui.notify("Jev: nessun verdetto del gate ancora (serve un turno sul twin in automatic).", "info");
+          return;
+        }
+        const v = last.report.verdict;
+        const top = [...v.checks].sort((a, b) => b.pFlaw - a.pFlaw)[0];
+        ctx.ui.notify(
+          [
+            `Gate: ${last.report.outcome === "published" ? "pubblicato" : "trattenuto"} dopo ${last.report.attempts} tentativ${last.report.attempts === 1 ? "o" : "i"}`,
+            `stato: ${v.status}${top ? ` — ${top.ruleId} p=${top.pFlaw.toFixed(2)}` : ""}`,
+            v.errorCode ? `errore: ${v.errorCode}` : `backend: ${v.backend ?? "?"} · modello: ${v.model ?? "?"}`,
+            v.truncated ? `troncato: ${JSON.stringify(v.truncated)}` : "copertura intera",
+            `tempo verifica: ${Math.round(v.elapsedMs)}ms`,
+          ].join("\n"),
+          "info",
+        );
+        return;
+      }
+
+      if (sub === "output") {
+        const last = deps.getLastOutput();
+        if (!last) {
+          ctx.ui.notify("Jev: nessun output giudicato ancora.", "info");
+          return;
+        }
+        const v = last.verdict;
+        ctx.ui.notify(
+          [
+            `Output: ${last.tool} — ${v.kind}`,
+            `leak p=${v.leaksSecret.toFixed(2)}`,
+            `classe: ${v.failureClass ?? "n/a"} (conf ${v.classConfidence?.toFixed(2) ?? "n/a"})`,
+            v.notice ? `avviso: ${v.notice}` : "nessun avviso",
+            `modello: ${v.model ?? "?"} · ${Math.round(v.elapsedMs)}ms`,
+          ].join("\n"),
+          "info",
+        );
+        return;
+      }
+
+      if (sub === "reload") {
+        const cfg = deps.reload();
+        ctx.ui.notify(`Config ricaricata. mode=${cfg.mode} backend=${cfg.jev.backend}`, "info");
+        return;
+      }
+
+      if (sub === "save-key") {
+        const cfg = deps.config();
+        const target = cfg.jev.apiKeyFile?.trim()
+          ? expandHome(cfg.jev.apiKeyFile.trim())
+          : resolve(dirname(defaultConfigPath()), "jev-api-key.txt");
+        let key: string | undefined;
+        try {
+          key = await ctx.ui.input(
+            "Jev API key",
+            "Incolla la chiave (potrebbe fare echo nel terminale)",
+          );
+        } catch {
+          ctx.ui.notify("Jev: input non disponibile qui — usa la shell: `echo KEY > ~/.pi/agent/jev-api-key.txt && chmod 600 ~/.pi/agent/jev-api-key.txt`.", "warning");
+          return;
+        }
+        if (!key || !key.trim()) {
+          ctx.ui.notify("Jev: chiave vuota, niente da salvare.", "warning");
+          return;
+        }
+        try {
+          mkdirSync(dirname(target), { recursive: true });
+          writeFileSync(target, `${key.trim()}\n`, { mode: 0o600 });
+          chmodSync(target, 0o600);
+        } catch (error) {
+          ctx.ui.notify(`Jev: salvataggio fallito: ${error instanceof Error ? error.message : String(error)}`, "error");
+          return;
+        }
+        // Punta la config al file e ricarica gli handle col nuovo stato.
+        cfg.jev.apiKeyFile = target;
+        try {
+          saveConfig(cfg);
+        } catch {
+          // Resta in memoria anche se il salvataggio fallisce.
+        }
+        const reloaded = deps.reload();
+        const resolved = resolveBackend(reloaded);
+        ctx.ui.notify(
+          resolved.apiKeyPresent
+            ? `Jev: chiave salvata in ${target} (600). Sorgente: ${resolved.keySource}.`
+            : `Jev: file scritto ma chiave non rilevata (${resolved.keySource}).`,
+          resolved.apiKeyPresent ? "info" : "warning",
+        );
+        return;
+      }
+
+      if (sub === "stats") {
+        ctx.ui.notify(deps.metrics.summary(), "info");
+        return;
+      }
+
+      if (sub === "check") {
+        const target = parts[1];
+        if (!target) {
+          ctx.ui.notify("Uso: /jev check <file> [requirements...]", "warning");
+          return;
+        }
+        const abs = resolve(ctx.cwd, target);
+        if (!existsSync(abs)) {
+          ctx.ui.notify(`File non trovato: ${target}`, "error");
+          return;
+        }
+        const st = statSync(abs);
+        const cfg = deps.config();
+        if (st.size > cfg.limits.maxCandidateChars) {
+          ctx.ui.notify(`File troppo grande (${st.size} bytes)`, "error");
+          return;
+        }
+        // Risolvi symlink e verifica che resti un file regolare.
+        const real = realpathSync(abs);
+        const realStat = statSync(real);
+        if (!realStat.isFile()) {
+          ctx.ui.notify("Target non è un file regolare", "error");
+          return;
+        }
+        const content = readFileSync(real, "utf8");
+        const requirements =
+          parts.slice(2).join(" ") ||
+          "Verifica difetti evidenti rispetto alle best practice e ai requisiti nel file.";
+        const result = await reviewWithCoverage(
+          deps.review(),
+          { requirements, candidate: content },
+          { limits: cfg.limits, requirementsSensitive: true },
+          ctx.signal ?? undefined,
+        );
+        deps.metrics.record(result);
+        ctx.ui.notify(`Jev check ${target}: ${JSON.stringify(result)}`, "info");
+        return;
+      }
+
+      ctx.ui.notify(
+        `Sottocomando sconosciuto: ${sub}\n\n${JEV_HELP_TEXT}`,
+        "warning",
+      );
+    },
+  });
+}