pi-jev-guard 0.1.0

package/src/tools-policy.ts

@@ -0,0 +1,128 @@
+/**
+ * Policy deterministica pre-esecuzione tool (zero costo, sincrona).
+ * Applicata solo in modalità automatic (on-demand = uso normale invariato).
+ * Blocca solo pattern chiaramente distruttivi o path sensibili; tutto il
+ * resto passa. Non sostituisce la revisione umana dei comandi rischiosi.
+ */
+
+export const TOOL_POLICY_REVISION = "2026-09-19.1";
+
+export interface ToolBlock {
+  blocked: true;
+  ruleId: string;
+  reason: string;
+}
+
+export interface ToolAllow {
+  blocked: false;
+}
+
+export type ToolVerdict = ToolBlock | ToolAllow;
+
+const BASH_RULES: Array<{ ruleId: string; pattern: RegExp; reason: string }> = [
+  {
+    ruleId: "bash-rm-root",
+    pattern: /\brm\s+(-[a-zA-Z]*r[a-zA-Z]*f|-[a-zA-Z]*f[a-zA-Z]*r)\s+(\/\*|\/)\s*(--no-preserve-root)?\s*([;&|]|$)/,
+    reason: "rm ricorsivo forzato su / o /*",
+  },
+  {
+    ruleId: "bash-forkbomb",
+    pattern: /:\(\)\s*\{\s*:\s*\|\s*:\s*&\s*\}\s*;\s*:/,
+    reason: "fork bomb",
+  },
+  {
+    ruleId: "bash-mkfs",
+    pattern: /(^|[;&|]\s*|\bsudo\s+)mkfs(\s|[.]|$)/,
+    reason: "mkfs (formattazione filesystem)",
+  },
+  {
+    ruleId: "bash-dd-device",
+    pattern: /\bdd\b[^;&|]*\bof=\/dev\//,
+    reason: "dd con output su device",
+  },
+  {
+    ruleId: "bash-overwrite-disk",
+    pattern: />\s*\/dev\/(sd[a-z]+|hd[a-z]+|nvme\d+n\d+|vd[a-z]+|mmcblk\d+)/,
+    reason: "scrittura diretta su disco",
+  },
+  {
+    ruleId: "bash-chmod-root",
+    pattern: /\bchmod\b[^;&|]*-R[^;&|]*\b777\b[^;&|]*\s\/(\s|[;&|]|$)/,
+    reason: "chmod -R 777 su /",
+  },
+  {
+    ruleId: "bash-git-clean-root",
+    pattern: /\bgit\s+clean\b[^;&|]*\s\/(\s|[;&|]|$)/,
+    reason: "git clean su /",
+  },
+];
+
+const POWERSHELL_RULES: Array<{ ruleId: string; pattern: RegExp; reason: string }> = [
+  {
+    ruleId: "ps-format-volume",
+    pattern: /\bFormat-Volume\b/i,
+    reason: "Format-Volume",
+  },
+  {
+    ruleId: "ps-format-drive",
+    pattern: /(^|[;&|]\s*)format\s+[a-z]:/i,
+    reason: "format su drive",
+  },
+  {
+    ruleId: "ps-remove-root",
+    pattern: /\bRemove-Item\b[^;&|]*C:\\?(\s|[;&|]|$)[^;&|]*-Recurse/i,
+    reason: "Remove-Item ricorsivo su C:\\",
+  },
+];
+
+function stripSudoPrefix(command: string): string {
+  return command.replace(/^\s*sudo\s+(-[^\s]+\s+)*/i, "");
+}
+
+export function checkShellCommand(
+  command: unknown,
+  shell: "bash" | "powershell",
+): ToolVerdict {
+  if (typeof command !== "string" || command.trim() === "") {
+    return { blocked: false };
+  }
+  const candidates = [command, stripSudoPrefix(command)];
+  const rules = shell === "bash" ? BASH_RULES : POWERSHELL_RULES;
+  for (const rule of rules) {
+    if (candidates.some((c) => rule.pattern.test(c))) {
+      return { blocked: true, ruleId: rule.ruleId, reason: rule.reason };
+    }
+  }
+  // powershell -Command "..." annidato in bash: controlla anche il contenuto quotato.
+  if (shell === "bash" && /powershell/i.test(command)) {
+    for (const rule of POWERSHELL_RULES) {
+      if (rule.pattern.test(command)) {
+        return { blocked: true, ruleId: rule.ruleId, reason: rule.reason };
+      }
+    }
+  }
+  return { blocked: false };
+}
+
+export function checkFilePath(path: unknown): ToolVerdict {
+  if (typeof path !== "string" || path.trim() === "") {
+    return { blocked: false };
+  }
+  const normalized = path.replace(/\\/g, "/");
+  const segments = normalized.split("/").filter(Boolean);
+  const basename = segments[segments.length - 1] ?? "";
+
+  if (basename === ".env") {
+    return { blocked: true, ruleId: "path-dotenv", reason: "scrittura su file .env" };
+  }
+  if (segments.includes(".ssh")) {
+    return { blocked: true, ruleId: "path-ssh", reason: "scrittura sotto .ssh/" };
+  }
+  if (basename.toLowerCase().endsWith(".pem")) {
+    return { blocked: true, ruleId: "path-pem", reason: "scrittura su chiave .pem" };
+  }
+  if (segments.includes("node_modules")) {
+    return { blocked: true, ruleId: "path-node-modules", reason: "scrittura sotto node_modules/" };
+  }
+  return { blocked: false };
+}

package/src/tools.ts

@@ -0,0 +1,43 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import type { JevConfig } from "./config.ts";
+import type { ReviewFn } from "./reviewer.ts";
+import { reviewWithCoverage } from "./reviewer.ts";
+import type { Metrics } from "./metrics.ts";
+
+export function registerJevTool(
+  pi: ExtensionAPI,
+  deps: { review: () => ReviewFn; config: () => JevConfig; metrics: Metrics },
+) {
+  pi.registerTool({
+    name: "jev_validate",
+    label: "Jev validation",
+    description:
+      "Check code or a decision against explicit requirements. " +
+      "Returns pass, block, review, or unavailable.",
+    promptSnippet: "Validate a specific code fragment or decision with Jev.",
+    promptGuidelines: [
+      "Use jev_validate when an independent targeted check is useful.",
+      "Do not describe review or unavailable as successful validation.",
+      "Jev validation does not replace compilation or tests.",
+    ],
+    parameters: Type.Object({
+      requirements: Type.String({ minLength: 1, maxLength: 16000 }),
+      candidate: Type.String({ minLength: 1, maxLength: 100000 }),
+    }),
+    async execute(_toolCallId, params, signal, _onUpdate, _ctx) {
+      const cfg = deps.config();
+      const result = await reviewWithCoverage(
+        deps.review(),
+        { requirements: params.requirements, candidate: params.candidate },
+        { limits: cfg.limits, requirementsSensitive: true },
+        signal ?? undefined,
+      );
+      deps.metrics.record(result);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }],
+        details: result,
+      };
+    },
+  });
+}