infernoflow 0.10.7 → 0.10.8

package/lib/commands/run.mjs

@@ -0,0 +1,227 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { execFileSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { generateWithLocalModel } from "../ai/localProvider.mjs";
+import {
+  buildPrompt,
+  loadSuggestContext,
+  parseSuggestionJson,
+  validateSuggestion,
+  detectSuggestionConflicts,
+  applyChanges,
+} from "./suggest.mjs";
+import { header, section, ok, warn, fail, info, gray } from "../ui/output.mjs";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const binPath = path.resolve(__dirname, "..", "..", "bin", "infernoflow.mjs");
+
+function runCliJson(args) {
+  try {
+    const out = execFileSync(process.execPath, [binPath, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+    return { ok: true, data: JSON.parse(out) };
+  } catch (err) {
+    const stdout = err?.stdout?.toString?.() || "";
+    try {
+      return { ok: false, data: JSON.parse(stdout) };
+    } catch {
+      return { ok: false, data: { ok: false, errors: ["command_failed"] } };
+    }
+  }
+}
+
+function stageEvent(asJson, events, stage, status, details = {}) {
+  const ev = { ts: new Date().toISOString(), stage, status, ...details };
+  events.push(ev);
+  if (asJson) return;
+  const text = `${stage}: ${status}`;
+  if (status === "ok") ok(text);
+  else if (status === "warn") warn(text);
+  else if (status === "fail") fail(text);
+  else info(text);
+}
+
+function snapshotInferno(cwd) {
+  const infernoDir = path.join(cwd, "inferno");
+  const targets = [];
+  const walk = (dir) => {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const p = path.join(dir, entry.name);
+      if (entry.isDirectory()) walk(p);
+      else targets.push(p);
+    }
+  };
+  if (fs.existsSync(infernoDir)) walk(infernoDir);
+  const snapshot = new Map();
+  targets.forEach((filePath) => snapshot.set(filePath, fs.readFileSync(filePath, "utf8")));
+  return snapshot;
+}
+
+function restoreSnapshot(cwd, snapshot) {
+  const infernoDir = path.join(cwd, "inferno");
+  if (fs.existsSync(infernoDir)) {
+    const existing = [];
+    const walk = (dir) => {
+      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const p = path.join(dir, entry.name);
+        if (entry.isDirectory()) walk(p);
+        else existing.push(p);
+      }
+    };
+    walk(infernoDir);
+    existing.forEach((filePath) => {
+      if (!snapshot.has(filePath)) fs.unlinkSync(filePath);
+    });
+  }
+  for (const [filePath, content] of snapshot.entries()) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, content, "utf8");
+  }
+}
+
+function writeRunArtifact(cwd, artifact) {
+  const runsDir = path.join(cwd, "inferno", "runs");
+  fs.mkdirSync(runsDir, { recursive: true });
+  const filePath = path.join(runsDir, `${Date.now()}.json`);
+  fs.writeFileSync(filePath, JSON.stringify(artifact, null, 2) + "\n", "utf8");
+  return path.relative(cwd, filePath);
+}
+
+export async function runCommand(args = []) {
+  const asJson = args.includes("--json");
+  const dryRun = args.includes("--dry-run");
+  const noRollback = args.includes("--no-rollback");
+  const task = args.filter((a) => !a.startsWith("-")).slice(1).join(" ").trim() || "sync check";
+  const cwd = process.cwd();
+  const events = [];
+
+  if (!asJson) header("run");
+  stageEvent(asJson, events, "init", "info", { task, dryRun, noRollback });
+
+  // detect
+  const impact = runCliJson(["pr-impact", "--json"]);
+  stageEvent(asJson, events, "detect", impact.data?.ok ? "ok" : "warn", { confidence: impact.data?.confidence || "low" });
+
+  const ctx = loadSuggestContext(cwd);
+  if (!ctx?.contract) {
+    const payload = { ok: false, error: "inferno_missing", events };
+    if (asJson) console.log(JSON.stringify(payload, null, 2));
+    else fail("inferno/ missing or invalid");
+    process.exit(1);
+  }
+
+  // propose
+  const prompt = buildPrompt({
+    description: task,
+    contract: ctx.contract,
+    capabilities: ctx.capabilities,
+    scenarios: ctx.scenarios,
+  });
+  let suggestion;
+  try {
+    const raw = await generateWithLocalModel(prompt);
+    suggestion = parseSuggestionJson(raw);
+  } catch (err) {
+    const payload = { ok: false, error: "local_model_failed", reason: String(err.message || err), events };
+    if (asJson) console.log(JSON.stringify(payload, null, 2));
+    else fail(`local model failed`, err.message);
+    process.exit(1);
+  }
+  stageEvent(asJson, events, "propose", "ok", {
+    newCapabilities: (suggestion.newCapabilities || []).length,
+    removedCapabilities: (suggestion.removedCapabilities || []).length,
+  });
+
+  const schemaErrors = validateSuggestion(suggestion);
+  const conflictErrors = detectSuggestionConflicts(ctx.contract, suggestion);
+  if (schemaErrors.length || conflictErrors.length) {
+    const payload = {
+      ok: false,
+      error: "invalid_suggestion",
+      issues: [...schemaErrors, ...conflictErrors],
+      events,
+    };
+    if (asJson) console.log(JSON.stringify(payload, null, 2));
+    else fail("suggestion invalid", payload.issues[0]);
+    process.exit(1);
+  }
+
+  const snapshot = snapshotInferno(cwd);
+  let rolledBack = false;
+  let applyChanged = false;
+  let validationPassed = false;
+
+  try {
+    if (dryRun) {
+      stageEvent(asJson, events, "apply", "info", { dryRun: true });
+    } else {
+      applyChanged = applyChanges({
+        cwd,
+        contract: ctx.contract,
+        capabilities: ctx.capabilities,
+        suggestion,
+        version: ctx.version,
+        quiet: asJson,
+      });
+      stageEvent(asJson, events, "apply", "ok", { changed: applyChanged });
+    }
+
+    let check = runCliJson(["check", "--json"]);
+    if (process.env.INFERNO_TEST_FORCE_VALIDATE_FAIL === "1") {
+      check = { ok: false, data: { ok: false, errors: ["forced_validation_failure"] } };
+    }
+    if (!check.ok || !check.data?.ok) {
+      throw new Error(`validation_failed:${(check.data?.errors || []).join(",")}`);
+    }
+    validationPassed = true;
+    stageEvent(asJson, events, "validate", "ok");
+  } catch (err) {
+    stageEvent(asJson, events, "validate", "fail", { reason: String(err.message || err) });
+    if (!dryRun && !noRollback) {
+      restoreSnapshot(cwd, snapshot);
+      rolledBack = true;
+      stageEvent(asJson, events, "rollback", "ok");
+    }
+  }
+
+  const artifact = {
+    task,
+    dryRun,
+    noRollback,
+    rolledBack,
+    applyChanged,
+    suggestionSummary: suggestion.summary || "",
+    touchedCapabilities: [
+      ...(suggestion.newCapabilities || []).map((c) => c.id),
+      ...(suggestion.removedCapabilities || []),
+    ],
+    events,
+  };
+  const artifactPath = writeRunArtifact(cwd, artifact);
+
+  const payload = {
+    ok: validationPassed,
+    mode: "run",
+    task,
+    dryRun,
+    rolledBack,
+    applyChanged,
+    artifactPath,
+    events,
+  };
+
+  if (asJson) {
+    console.log(JSON.stringify(payload, null, 2));
+    process.exit(payload.ok ? 0 : 1);
+  }
+
+  section("Result");
+  info(`task: ${gray(task)}`);
+  info(`artifact: ${gray(artifactPath)}`);
+  if (payload.ok) ok("run completed");
+  else warn("run rolled back after failed validation");
+  console.log();
+  process.exit(payload.ok ? 0 : 1);
+}
+

package/lib/commands/suggest.mjs

@@ -5,7 +5,7 @@ import { header, ok, fail, warn, info, done, section, nextSteps, bold, cyan, gra
 
 // ── Helpers ──────────────────────────────────────────────────────────────────
 
-function readJson(filePath) {
+export function readJson(filePath) {
   try { return JSON.parse(fs.readFileSync(filePath, "utf8")); }
   catch { return null; }
 }
@@ -25,7 +25,7 @@ function toCapabilityId(str) {
     .join("");
 }
 
-function buildPrompt({ description, contract, capabilities, scenarios }) {
+export function buildPrompt({ description, contract, capabilities, scenarios }) {
   const capsIds = contract.capabilities || [];
   const capsDetail = (capabilities?.capabilities || [])
     .map(c => `  - ${c.id}: ${c.title || c.id}`)
@@ -87,7 +87,7 @@ Rules:
 - Keep it minimal and accurate`;
 }
 
-function validateSuggestion(suggestion) {
+export function validateSuggestion(suggestion) {
   const errors = [];
   if (!suggestion || typeof suggestion !== "object") {
     return ["AI response must be a JSON object."];
@@ -146,7 +146,7 @@ function validateSuggestion(suggestion) {
   return errors;
 }
 
-function detectSuggestionConflicts(contract, suggestion) {
+export function detectSuggestionConflicts(contract, suggestion) {
   const issues = [];
   const existing = new Set(contract.capabilities || []);
   const newIds = new Set((suggestion.newCapabilities || []).map((c) => c.id));
@@ -170,7 +170,7 @@ function detectSuggestionConflicts(contract, suggestion) {
   return issues;
 }
 
-function applyChanges({ cwd, contract, capabilities, suggestion, version }) {
+export function applyChanges({ cwd, contract, capabilities, suggestion, version, quiet = false }) {
   const infernoDir = path.join(cwd, "inferno");
   const contractPath = path.join(infernoDir, "contract.json");
   const capsPath = path.join(infernoDir, "capabilities.json");
@@ -195,7 +195,7 @@ function applyChanges({ cwd, contract, capabilities, suggestion, version }) {
     const nextVersion = Number(contract.policyVersion || 1) + 1;
     const contractUpdated = { ...contract, capabilities: updatedCaps, policyVersion: nextVersion };
     queueWrite(contractPath, JSON.stringify(contractUpdated, null, 2) + "\n");
-    ok(`contract.json updated → policyVersion: v${nextVersion}`);
+    if (!quiet) ok(`contract.json updated → policyVersion: v${nextVersion}`);
     changed = true;
   }
 
@@ -209,7 +209,7 @@ function applyChanges({ cwd, contract, capabilities, suggestion, version }) {
       }
     }
     queueWrite(capsPath, JSON.stringify(reg, null, 2) + "\n");
-    ok(`capabilities.json updated`);
+    if (!quiet) ok(`capabilities.json updated`);
   }
 
   // ── scenarios ─────────────────────────────────────────────────────────────
@@ -225,7 +225,7 @@ function applyChanges({ cwd, contract, capabilities, suggestion, version }) {
         steps: us.stepsToAdd || []
       };
       queueWrite(filePath, JSON.stringify(scenario, null, 2) + "\n");
-      ok(`Created scenario: ${cyan(us.file)}`);
+      if (!quiet) ok(`Created scenario: ${cyan(us.file)}`);
     } else {
       scenario = readJson(filePath);
       const existingCaps = new Set(scenario.capabilitiesCovered || []);
@@ -233,7 +233,7 @@ function applyChanges({ cwd, contract, capabilities, suggestion, version }) {
       scenario.capabilitiesCovered = [...existingCaps];
       scenario.steps = [...(scenario.steps || []), ...(us.stepsToAdd || [])];
       queueWrite(filePath, JSON.stringify(scenario, null, 2) + "\n");
-      ok(`Updated scenario: ${cyan(us.file)}`);
+      if (!quiet) ok(`Updated scenario: ${cyan(us.file)}`);
     }
     changed = true;
   }
@@ -244,7 +244,7 @@ function applyChanges({ cwd, contract, capabilities, suggestion, version }) {
     if (/##\s+Unreleased/i.test(txt)) {
       txt = txt.replace(/(##\s+Unreleased[^\n]*\n)/i, `$1\n${changelogEntry}\n`);
       queueWrite(changelogPath, txt);
-      ok(`CHANGELOG.md updated`);
+      if (!quiet) ok(`CHANGELOG.md updated`);
       changed = true;
     }
   }
@@ -275,6 +275,37 @@ function applyChanges({ cwd, contract, capabilities, suggestion, version }) {
   return changed;
 }
 
+export function parseSuggestionJson(rawInput) {
+  const clean = String(rawInput || "").trim().replace(/^```json?\n?/, "").replace(/\n?```$/, "");
+  return JSON.parse(clean);
+}
+
+export function loadSuggestContext(cwd) {
+  const infernoDir = path.join(cwd, "inferno");
+  const contractPath = path.join(infernoDir, "contract.json");
+  const capsPath = path.join(infernoDir, "capabilities.json");
+  const scenariosDir = path.join(infernoDir, "scenarios");
+
+  const contract = readJson(contractPath);
+  const capabilities = readJson(capsPath);
+  const scenarios = [];
+  if (fs.existsSync(scenariosDir)) {
+    for (const f of fs.readdirSync(scenariosDir).filter((name) => name.endsWith(".json"))) {
+      const s = readJson(path.join(scenariosDir, f));
+      if (s) scenarios.push({ ...s, _file: f });
+    }
+  }
+
+  let version = "0.1.0";
+  const pkgPath = path.join(cwd, "package.json");
+  if (fs.existsSync(pkgPath)) {
+    const pkg = readJson(pkgPath);
+    if (pkg?.version) version = pkg.version;
+  }
+
+  return { contract, capabilities, scenarios, version };
+}
+
 // ── Main ─────────────────────────────────────────────────────────────────────
 
 export async function suggestCommand(args) {
@@ -375,8 +406,7 @@ export async function suggestCommand(args) {
   // ── Parse response ────────────────────────────────────────────────────────
   let suggestion;
   try {
-    const clean = jsonInput.trim().replace(/^```json?\n?/, "").replace(/\n?```$/, "");
-    suggestion = JSON.parse(clean);
+    suggestion = parseSuggestionJson(jsonInput);
   } catch {
     errorAndExit(
       "Could not parse the AI response as JSON",

package/lib/commands/syncAuto.mjs

@@ -1,96 +1,96 @@
-import { execFileSync } from "node:child_process";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-import { header, section, ok, warn, yellow, gray } from "../ui/output.mjs";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const binPath = path.resolve(__dirname, "..", "..", "bin", "infernoflow.mjs");
-
-function runCliJson(args) {
-  const out = execFileSync(process.execPath, [binPath, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
-  return JSON.parse(out);
-}
-
-function tryRunCliJson(args) {
-  try {
-    return { ok: true, data: runCliJson(args) };
-  } catch (err) {
-    const stdout = err?.stdout?.toString?.() || "";
-    try {
-      return { ok: false, data: JSON.parse(stdout) };
-    } catch {
-      return { ok: false, data: { ok: false, errors: ["command_failed"] } };
-    }
-  }
-}
-
-export async function syncCommand(args = []) {
-  const auto = args.includes("--auto");
-  const asJson = args.includes("--json");
-  const dryRun = args.includes("--dry-run");
-
-  if (!auto) {
-    const payload = { ok: false, error: "missing_required_flag", hint: "Use: infernoflow sync --auto" };
-    if (asJson) {
-      console.log(JSON.stringify(payload, null, 2));
-      process.exit(1);
-    }
-    header("sync");
-    warn("missing --auto flag");
-    console.log(`  ${yellow("→")} infernoflow sync --auto`);
-    console.log();
-    process.exit(1);
-  }
-
-  const impact = tryRunCliJson(["pr-impact", "--json"]);
-  const needsSync = !impact.data?.ok;
-  const confidence = impact.data?.confidence || "low";
-  const policyDecision = confidence === "high" ? "auto" : confidence === "medium" ? "ask" : "block";
-  const actions = needsSync
-    ? ["Generate inferno update proposal (suggest)", "Review changes", "Validate with check --json"]
-    : ["No inferno drift detected", "Validate with check --json"];
-
-  const check = tryRunCliJson(["check", "--json"]);
-  const payload = {
-    ok: impact.ok && check.ok && !!check.data?.ok,
-    mode: "auto-skeleton",
-    dryRun,
-    needsSync,
-    didApply: false,
-    confidence,
-    policyDecision,
-    actions,
-    prImpact: impact.data,
-    postCheck: check.data,
-    reasonCodes: [
-      ...(needsSync ? ["DRIFT_DETECTED"] : ["NO_DRIFT"]),
-      `POLICY_${policyDecision.toUpperCase()}`,
-      ...(policyDecision === "auto" ? ["AUTO_APPLY_DISABLED_IN_SKELETON"] : []),
-    ],
-  };
-
-  if (asJson) {
-    console.log(JSON.stringify(payload, null, 2));
-    process.exit(payload.ok ? 0 : 1);
-  }
-
-  header("sync --auto");
-  section("State");
-  if (needsSync) warn("Inferno drift detected");
-  else ok("No inferno drift detected");
-  ok(`Confidence: ${gray(confidence)}`);
-  ok(`Policy decision: ${gray(policyDecision)}`);
-  ok(`Apply mode: ${gray("skeleton (no file writes)")}`);
-  if (dryRun) ok("Dry run enabled");
-
-  section("Plan");
-  actions.forEach((a) => console.log(`  ${yellow("→")} ${a}`));
-
-  section("Validation");
-  if (check.ok && check.data?.ok) ok("Post-check passed");
-  else warn("Post-check failed; see infernoflow check --json");
-  console.log();
-  process.exit(payload.ok ? 0 : 1);
-}
-
+import { execFileSync } from "node:child_process";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { header, section, ok, warn, yellow, gray } from "../ui/output.mjs";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const binPath = path.resolve(__dirname, "..", "..", "bin", "infernoflow.mjs");
+
+function runCliJson(args) {
+  const out = execFileSync(process.execPath, [binPath, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+  return JSON.parse(out);
+}
+
+function tryRunCliJson(args) {
+  try {
+    return { ok: true, data: runCliJson(args) };
+  } catch (err) {
+    const stdout = err?.stdout?.toString?.() || "";
+    try {
+      return { ok: false, data: JSON.parse(stdout) };
+    } catch {
+      return { ok: false, data: { ok: false, errors: ["command_failed"] } };
+    }
+  }
+}
+
+export async function syncCommand(args = []) {
+  const auto = args.includes("--auto");
+  const asJson = args.includes("--json");
+  const dryRun = args.includes("--dry-run");
+
+  if (!auto) {
+    const payload = { ok: false, error: "missing_required_flag", hint: "Use: infernoflow sync --auto" };
+    if (asJson) {
+      console.log(JSON.stringify(payload, null, 2));
+      process.exit(1);
+    }
+    header("sync");
+    warn("missing --auto flag");
+    console.log(`  ${yellow("→")} infernoflow sync --auto`);
+    console.log();
+    process.exit(1);
+  }
+
+  const impact = tryRunCliJson(["pr-impact", "--json"]);
+  const needsSync = !impact.data?.ok;
+  const confidence = impact.data?.confidence || "low";
+  const policyDecision = confidence === "high" ? "auto" : confidence === "medium" ? "ask" : "block";
+  const actions = needsSync
+    ? ["Generate inferno update proposal (suggest)", "Review changes", "Validate with check --json"]
+    : ["No inferno drift detected", "Validate with check --json"];
+
+  const check = tryRunCliJson(["check", "--json"]);
+  const payload = {
+    ok: impact.ok && check.ok && !!check.data?.ok,
+    mode: "auto-skeleton",
+    dryRun,
+    needsSync,
+    didApply: false,
+    confidence,
+    policyDecision,
+    actions,
+    prImpact: impact.data,
+    postCheck: check.data,
+    reasonCodes: [
+      ...(needsSync ? ["DRIFT_DETECTED"] : ["NO_DRIFT"]),
+      `POLICY_${policyDecision.toUpperCase()}`,
+      ...(policyDecision === "auto" ? ["AUTO_APPLY_DISABLED_IN_SKELETON"] : []),
+    ],
+  };
+
+  if (asJson) {
+    console.log(JSON.stringify(payload, null, 2));
+    process.exit(payload.ok ? 0 : 1);
+  }
+
+  header("sync --auto");
+  section("State");
+  if (needsSync) warn("Inferno drift detected");
+  else ok("No inferno drift detected");
+  ok(`Confidence: ${gray(confidence)}`);
+  ok(`Policy decision: ${gray(policyDecision)}`);
+  ok(`Apply mode: ${gray("skeleton (no file writes)")}`);
+  if (dryRun) ok("Dry run enabled");
+
+  section("Plan");
+  actions.forEach((a) => console.log(`  ${yellow("→")} ${a}`));
+
+  section("Validation");
+  if (check.ok && check.data?.ok) ok("Post-check passed");
+  else warn("Post-check failed; see infernoflow check --json");
+  console.log();
+  process.exit(payload.ok ? 0 : 1);
+}
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infernoflow",
-  "version": "0.10.7",
+  "version": "0.10.8",
   "description": "The forge for liquid code — keep capabilities, contracts, and docs in sync.",
   "type": "module",
   "bin": {
@@ -16,7 +16,7 @@
     "README.md"
   ],
   "scripts": {
-    "test": "node scripts/smoke.mjs && node scripts/json-smoke.mjs && node scripts/json-negative-smoke.mjs && node scripts/implement-smoke.mjs && node scripts/adopt-smoke.mjs && node scripts/pr-impact-smoke.mjs && node scripts/sync-smoke.mjs",
+    "test": "node scripts/smoke.mjs && node scripts/json-smoke.mjs && node scripts/json-negative-smoke.mjs && node scripts/implement-smoke.mjs && node scripts/adopt-smoke.mjs && node scripts/pr-impact-smoke.mjs && node scripts/sync-smoke.mjs && node scripts/run-smoke.mjs",
     "test:help": "node bin/infernoflow.mjs --help"
   },
   "keywords": [

package/templates/ci/github-inferno-check.yml

@@ -1,36 +1,33 @@
-name: infernoflow-check
-
-on:
-  pull_request:
-  push:
-    branches: [main, master]
-
-jobs:
-  inferno:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Setup Node
-        uses: actions/setup-node@v4
-        with:
-          node-version: "20"
-
-      - name: Install dependencies
-        run: npm ci --ignore-scripts || npm install --ignore-scripts
-
-      - name: Inferno PR impact
-        run: npx infernoflow pr-impact --json
-        env:
-          BASE_SHA: ${{ github.event.pull_request.base.sha || github.event.before }}
-          HEAD_SHA: ${{ github.event.pull_request.head.sha || github.sha }}
-
-      - name: Inferno check
-        run: npx infernoflow check --json
-        env:
-          BASE_SHA: ${{ github.event.pull_request.base.sha || github.event.before }}
-          HEAD_SHA: ${{ github.event.pull_request.head.sha || github.sha }}
-
+name: infernoflow-check
+
+on:
+  pull_request:
+  push:
+    branches: [main, master]
+
+jobs:
+  inferno:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+
+      - name: Install dependencies
+        run: npm ci --ignore-scripts || npm install --ignore-scripts
+
+      - name: Inferno one-command run
+        run: npx infernoflow run "sync check" --json
+        env:
+          INFERNO_LOCAL_PROVIDER: ollama
+          INFERNO_LOCAL_ENDPOINT: http://127.0.0.1:11434/api/generate
+          INFERNO_LOCAL_MODEL: llama3.1:8b
+          BASE_SHA: ${{ github.event.pull_request.base.sha || github.event.before }}
+          HEAD_SHA: ${{ github.event.pull_request.head.sha || github.sha }}
+