@codacy/gate-cli 0.4.1 → 0.6.0

package/bin/gate.js

@@ -10373,6 +10373,10 @@ var MAX_TOTAL_SPEC_BYTES = 30720;
 var MAX_PLAN_FILES = 3;
 var MAX_PLAN_FILE_BYTES = 10240;
 var MAX_INTENT_CHARS = 2e3;
+var SNAPSHOT_DIR = `${GATE_DIR}/.snapshot`;
+var CONVERSATION_BUFFER_FILE = `${GATE_DIR}/.conversation-buffer`;
+var CONVERSATION_MAX_ENTRIES = 10;
+var CONVERSATION_WINDOW_MINUTES = 15;
 var MAX_FINDINGS = 25;
 var ANALYZABLE_EXTENSIONS = /* @__PURE__ */ new Set([
   "ts",
@@ -10852,41 +10856,113 @@ function registerHooksCommands(program2) {
   });
 }
 
-// src/lib/intent.ts
+// src/lib/conversation-buffer.ts
 var import_promises5 = require("node:fs/promises");
-async function writeIntent(prompt, sessionId) {
+var import_node_fs = require("node:fs");
+var import_node_child_process4 = require("node:child_process");
+function stripImageReferences(text) {
+  return text.replace(/\[Image #\d+\]/g, "[screenshot \u2014 not available for review]");
+}
+async function appendToConversationBuffer(prompt, sessionId) {
   try {
     await (0, import_promises5.mkdir)(GATE_DIR, { recursive: true });
-    const truncated = prompt.length > MAX_INTENT_CHARS ? prompt.slice(0, MAX_INTENT_CHARS) : prompt;
-    const data = {
-      prompt: truncated,
+    let sanitized = prompt.length > MAX_INTENT_CHARS ? prompt.slice(0, MAX_INTENT_CHARS) : prompt;
+    sanitized = stripImageReferences(sanitized);
+    const entry = {
+      prompt: sanitized,
       session_id: sessionId,
       captured_at: (/* @__PURE__ */ new Date()).toISOString()
     };
-    const tmpFile = `${INTENT_FILE}.tmp`;
-    await (0, import_promises5.writeFile)(tmpFile, JSON.stringify(data) + "\n");
-    await (0, import_promises5.rename)(tmpFile, INTENT_FILE);
+    const entries = await readBufferEntries();
+    const cutoff = Date.now() - CONVERSATION_WINDOW_MINUTES * 60 * 1e3;
+    const recent = entries.filter((e) => {
+      const ts = new Date(e.captured_at).getTime();
+      return !isNaN(ts) && ts > cutoff;
+    });
+    recent.push(entry);
+    const capped = recent.slice(-CONVERSATION_MAX_ENTRIES);
+    const content = capped.map((e) => JSON.stringify(e)).join("\n") + "\n";
+    const tmpFile = `${CONVERSATION_BUFFER_FILE}.tmp`;
+    await (0, import_promises5.writeFile)(tmpFile, content);
+    await (0, import_promises5.rename)(tmpFile, CONVERSATION_BUFFER_FILE);
   } catch {
   }
 }
-async function readAndClearIntent() {
+async function readAndClearConversationBuffer() {
   try {
-    const content = await (0, import_promises5.readFile)(INTENT_FILE, "utf-8");
-    await (0, import_promises5.unlink)(INTENT_FILE).catch(() => {
-    });
-    return JSON.parse(content);
+    if ((0, import_node_fs.existsSync)(CONVERSATION_BUFFER_FILE)) {
+      const entries = await readBufferEntries();
+      await (0, import_promises5.unlink)(CONVERSATION_BUFFER_FILE).catch(() => {
+      });
+      if (entries.length > 0) {
+        return {
+          prompts: entries,
+          recent_commits: getRecentCommitMessages()
+        };
+      }
+    }
+    if ((0, import_node_fs.existsSync)(INTENT_FILE)) {
+      try {
+        const content = await (0, import_promises5.readFile)(INTENT_FILE, "utf-8");
+        await (0, import_promises5.unlink)(INTENT_FILE).catch(() => {
+        });
+        const data = JSON.parse(content);
+        if (data.prompt) {
+          return {
+            prompts: [{
+              prompt: stripImageReferences(data.prompt),
+              session_id: data.session_id ?? "",
+              captured_at: data.captured_at ?? (/* @__PURE__ */ new Date()).toISOString()
+            }],
+            recent_commits: getRecentCommitMessages()
+          };
+        }
+      } catch {
+      }
+    }
+    return null;
   } catch {
     return null;
   }
 }
+async function readBufferEntries() {
+  try {
+    const content = await (0, import_promises5.readFile)(CONVERSATION_BUFFER_FILE, "utf-8");
+    const entries = [];
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (parsed.prompt) entries.push(parsed);
+      } catch {
+      }
+    }
+    return entries;
+  } catch {
+    return [];
+  }
+}
+function getRecentCommitMessages() {
+  try {
+    const output = (0, import_node_child_process4.execSync)(
+      'git log --since="30 minutes ago" --format="%s" -5',
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    ).trim();
+    if (!output) return [];
+    return output.split("\n").filter((l) => l.length > 0);
+  } catch {
+    return [];
+  }
+}
 
 // src/commands/intent.ts
-var import_node_fs = require("node:fs");
+var import_node_fs2 = require("node:fs");
 function registerIntentCommands(program2) {
   const intent = program2.command("intent").description("Manage intent capture");
   intent.command("capture").description("Capture user intent from stdin (used by UserPromptSubmit hook)").action(async () => {
     try {
-      if (!(0, import_node_fs.existsSync)(GATE_DIR)) {
+      if (!(0, import_node_fs2.existsSync)(GATE_DIR)) {
         process.exit(0);
       }
       const chunks = [];
@@ -10907,7 +10983,7 @@ function registerIntentCommands(program2) {
       if (!prompt) {
         process.exit(0);
       }
-      await writeIntent(prompt, event.session_id ?? "");
+      await appendToConversationBuffer(prompt, event.session_id ?? "");
     } catch {
     }
     process.exit(0);
@@ -11224,18 +11300,18 @@ function registerFeedbackCommand(program2) {
 }
 
 // src/lib/git.ts
-var import_node_child_process4 = require("node:child_process");
-var import_node_fs2 = require("node:fs");
+var import_node_child_process5 = require("node:child_process");
+var import_node_fs3 = require("node:fs");
 var import_node_path4 = require("node:path");
 function resolveFile(relpath) {
-  if ((0, import_node_fs2.existsSync)(relpath)) return relpath;
-  if ((0, import_node_fs2.existsSync)(".claude/worktrees")) {
+  if ((0, import_node_fs3.existsSync)(relpath)) return relpath;
+  if ((0, import_node_fs3.existsSync)(".claude/worktrees")) {
     try {
-      const entries = (0, import_node_fs2.readdirSync)(".claude/worktrees", { withFileTypes: true });
+      const entries = (0, import_node_fs3.readdirSync)(".claude/worktrees", { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         const candidate = (0, import_node_path4.join)(".claude/worktrees", entry.name, relpath);
-        if ((0, import_node_fs2.existsSync)(candidate)) return candidate;
+        if ((0, import_node_fs3.existsSync)(candidate)) return candidate;
       }
     } catch {
     }
@@ -11244,7 +11320,7 @@ function resolveFile(relpath) {
 }
 function execGit(cmd) {
   try {
-    return (0, import_node_child_process4.execSync)(cmd, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    return (0, import_node_child_process5.execSync)(cmd, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
   } catch {
     return "";
   }
@@ -11254,6 +11330,7 @@ function splitLines(s) {
 }
 function getChangedFiles() {
   const sets = /* @__PURE__ */ new Set();
+  let hasRecentCommitFiles = false;
   for (const f of splitLines(execGit("git diff --name-only HEAD"))) {
     sets.add(f);
   }
@@ -11269,22 +11346,26 @@ function getChangedFiles() {
   const hasUnstaged = splitLines(execGit("git diff --name-only HEAD")).length > 0;
   const hasStaged = splitLines(execGit("git diff --name-only --cached")).length > 0;
   if (commitAge < 120 && !hasUnstaged && !hasStaged) {
-    for (const f of splitLines(execGit("git diff --name-only HEAD~1..HEAD"))) {
-      sets.add(f);
+    const recentFiles = splitLines(execGit("git diff --name-only HEAD~1..HEAD"));
+    if (recentFiles.length > 0) {
+      hasRecentCommitFiles = true;
+      for (const f of recentFiles) {
+        sets.add(f);
+      }
     }
   }
   for (const f of getWorktreeFiles()) {
     sets.add(f);
   }
-  return Array.from(sets);
+  return { files: Array.from(sets), hasRecentCommitFiles };
 }
 function getWorktreeFiles() {
   const result = [];
   const worktreeDir = ".claude/worktrees";
-  if (!(0, import_node_fs2.existsSync)(worktreeDir)) return result;
+  if (!(0, import_node_fs3.existsSync)(worktreeDir)) return result;
   try {
     const fiveMinAgo = Date.now() - 5 * 60 * 1e3;
-    const entries = (0, import_node_fs2.readdirSync)(worktreeDir, { withFileTypes: true });
+    const entries = (0, import_node_fs3.readdirSync)(worktreeDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       const wtDir = (0, import_node_path4.join)(worktreeDir, entry.name);
@@ -11296,7 +11377,7 @@ function getWorktreeFiles() {
 }
 function scanDir(baseDir, dir, minMtime, result) {
   try {
-    const entries = (0, import_node_fs2.readdirSync)(dir, { withFileTypes: true });
+    const entries = (0, import_node_fs3.readdirSync)(dir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = (0, import_node_path4.join)(dir, entry.name);
       if (entry.isDirectory()) {
@@ -11306,7 +11387,7 @@ function scanDir(baseDir, dir, minMtime, result) {
         const ext = (0, import_node_path4.extname)(entry.name).slice(1);
         if (!ANALYZABLE_EXTENSIONS.has(ext)) continue;
         try {
-          const stat = (0, import_node_fs2.statSync)(fullPath);
+          const stat = (0, import_node_fs3.statSync)(fullPath);
           if (stat.mtimeMs >= minMtime) {
             const relPath = fullPath.slice(baseDir.length + 1);
             result.push(relPath);
@@ -11345,7 +11426,7 @@ function getCurrentCommit() {
 }
 
 // src/lib/files.ts
-var import_node_fs3 = require("node:fs");
+var import_node_fs4 = require("node:fs");
 var import_node_path5 = require("node:path");
 var LANG_MAP = {
   // Analyzable (static analysis + Gemini)
@@ -11422,7 +11503,7 @@ function sortByMtime(files) {
     const resolved = resolveFile(f);
     if (!resolved) return null;
     try {
-      const stat = (0, import_node_fs3.statSync)(resolved);
+      const stat = (0, import_node_fs4.statSync)(resolved);
       return { path: f, resolved, mtime: stat.mtimeMs };
     } catch {
       return null;
@@ -11444,7 +11525,7 @@ function collectCodeDelta(files, opts) {
     if (!resolved) continue;
     let size;
     try {
-      size = (0, import_node_fs3.statSync)(resolved).size;
+      size = (0, import_node_fs4.statSync)(resolved).size;
     } catch {
       continue;
     }
@@ -11452,7 +11533,7 @@ function collectCodeDelta(files, opts) {
     if (totalSize + size > maxTotalBytes) break;
     let content;
     try {
-      content = (0, import_node_fs3.readFileSync)(resolved, "utf-8");
+      content = (0, import_node_fs4.readFileSync)(resolved, "utf-8");
     } catch {
       continue;
     }
@@ -11475,12 +11556,12 @@ function collectCodeDelta(files, opts) {
 }
 
 // src/lib/debounce.ts
-var import_node_fs4 = require("node:fs");
+var import_node_fs5 = require("node:fs");
 var import_node_crypto = require("node:crypto");
 function checkDebounce(debounceSeconds = DEBOUNCE_SECONDS) {
-  if (!(0, import_node_fs4.existsSync)(DEBOUNCE_FILE)) return null;
+  if (!(0, import_node_fs5.existsSync)(DEBOUNCE_FILE)) return null;
   try {
-    const lastTs = parseInt((0, import_node_fs4.readFileSync)(DEBOUNCE_FILE, "utf-8").trim(), 10);
+    const lastTs = parseInt((0, import_node_fs5.readFileSync)(DEBOUNCE_FILE, "utf-8").trim(), 10);
     const nowTs = Math.floor(Date.now() / 1e3);
     const elapsed = nowTs - lastTs;
     if (elapsed < debounceSeconds) {
@@ -11490,11 +11571,12 @@ function checkDebounce(debounceSeconds = DEBOUNCE_SECONDS) {
   }
   return null;
 }
-function checkMtime(files) {
-  if (!(0, import_node_fs4.existsSync)(DEBOUNCE_FILE)) return null;
+function checkMtime(files, bypassForRecentCommits) {
+  if (bypassForRecentCommits) return null;
+  if (!(0, import_node_fs5.existsSync)(DEBOUNCE_FILE)) return null;
   let debounceTime;
   try {
-    debounceTime = (0, import_node_fs4.statSync)(DEBOUNCE_FILE).mtimeMs;
+    debounceTime = (0, import_node_fs5.statSync)(DEBOUNCE_FILE).mtimeMs;
   } catch {
     return null;
   }
@@ -11502,7 +11584,7 @@ function checkMtime(files) {
     const resolved = resolveFile(f);
     if (!resolved) continue;
     try {
-      const stat = (0, import_node_fs4.statSync)(resolved);
+      const stat = (0, import_node_fs5.statSync)(resolved);
       if (stat.mtimeMs > debounceTime) {
         return null;
       }
@@ -11518,8 +11600,8 @@ function computeContentHash(files) {
   for (const f of sorted) {
     const resolved = resolveFile(f) ?? f;
     try {
-      if ((0, import_node_fs4.existsSync)(resolved)) {
-        hash.update((0, import_node_fs4.readFileSync)(resolved));
+      if ((0, import_node_fs5.existsSync)(resolved)) {
+        hash.update((0, import_node_fs5.readFileSync)(resolved));
       }
     } catch {
     }
@@ -11528,9 +11610,9 @@ function computeContentHash(files) {
 }
 function checkContentHash(files) {
   const hash = computeContentHash(files);
-  if ((0, import_node_fs4.existsSync)(HASH_FILE)) {
+  if ((0, import_node_fs5.existsSync)(HASH_FILE)) {
     try {
-      const storedHash = (0, import_node_fs4.readFileSync)(HASH_FILE, "utf-8").trim();
+      const storedHash = (0, import_node_fs5.readFileSync)(HASH_FILE, "utf-8").trim();
       if (hash === storedHash) {
         return { skip: "No source changes since last analysis", hash };
       }
@@ -11540,46 +11622,49 @@ function checkContentHash(files) {
   return { skip: null, hash };
 }
 function recordAnalysisStart() {
-  (0, import_node_fs4.mkdirSync)(GATE_DIR, { recursive: true });
-  (0, import_node_fs4.writeFileSync)(DEBOUNCE_FILE, String(Math.floor(Date.now() / 1e3)));
+  (0, import_node_fs5.mkdirSync)(GATE_DIR, { recursive: true });
+  (0, import_node_fs5.writeFileSync)(DEBOUNCE_FILE, String(Math.floor(Date.now() / 1e3)));
 }
 function recordPassHash(hash) {
-  (0, import_node_fs4.writeFileSync)(HASH_FILE, hash);
+  (0, import_node_fs5.writeFileSync)(HASH_FILE, hash);
 }
 function narrowToRecent(files) {
-  if (!(0, import_node_fs4.existsSync)(DEBOUNCE_FILE)) return files;
+  if (!(0, import_node_fs5.existsSync)(DEBOUNCE_FILE)) return files;
   let debounceTime;
   try {
-    debounceTime = (0, import_node_fs4.statSync)(DEBOUNCE_FILE).mtimeMs;
+    debounceTime = (0, import_node_fs5.statSync)(DEBOUNCE_FILE).mtimeMs;
   } catch {
     return files;
   }
   const recent = files.filter((f) => {
     try {
-      return (0, import_node_fs4.existsSync)(f) && (0, import_node_fs4.statSync)(f).mtimeMs > debounceTime;
+      return (0, import_node_fs5.existsSync)(f) && (0, import_node_fs5.statSync)(f).mtimeMs > debounceTime;
     } catch {
       return false;
     }
   });
   return recent.length > 0 ? recent : files;
 }
-function readIteration(currentCommit) {
-  if (!(0, import_node_fs4.existsSync)(ITERATION_FILE)) return 1;
+function readIteration(currentCommit, contentHash) {
+  if (!(0, import_node_fs5.existsSync)(ITERATION_FILE)) return 1;
   try {
-    const stored = (0, import_node_fs4.readFileSync)(ITERATION_FILE, "utf-8").trim();
-    const [iterStr, storedCommit] = stored.split(":");
-    const iter = parseInt(iterStr, 10);
+    const stored = (0, import_node_fs5.readFileSync)(ITERATION_FILE, "utf-8").trim();
+    const parts = stored.split(":");
+    const iter = parseInt(parts[0], 10);
+    const storedCommit = parts[1] ?? "";
+    const storedContentHash = parts[2] ?? "";
     if (isNaN(iter)) return 1;
-    if (storedCommit === currentCommit) return iter;
-    return 1;
+    if (storedCommit !== currentCommit) return 1;
+    if (contentHash && storedContentHash && storedContentHash !== contentHash) return 1;
+    return iter;
   } catch {
     return 1;
   }
 }
-function checkMaxIterations(currentCommit, maxIterations = MAX_ITERATIONS) {
-  const iteration = readIteration(currentCommit);
+function checkMaxIterations(currentCommit, maxIterations = MAX_ITERATIONS, contentHash) {
+  const iteration = readIteration(currentCommit, contentHash);
   if (iteration > maxIterations) {
-    (0, import_node_fs4.writeFileSync)(ITERATION_FILE, `1:${currentCommit}`);
+    writeIteration(1, currentCommit, contentHash);
     return {
       skip: `Max gate iterations (${maxIterations}) reached \u2014 accepting to prevent infinite loop. Human review required before deploying.`,
       iteration
@@ -11587,14 +11672,14 @@ function checkMaxIterations(currentCommit, maxIterations = MAX_ITERATIONS) {
   }
   return { skip: null, iteration };
 }
-function writeIteration(iteration, commit) {
-  (0, import_node_fs4.mkdirSync)(GATE_DIR, { recursive: true });
-  (0, import_node_fs4.writeFileSync)(ITERATION_FILE, `${iteration}:${commit}`);
+function writeIteration(iteration, commit, contentHash) {
+  (0, import_node_fs5.mkdirSync)(GATE_DIR, { recursive: true });
+  (0, import_node_fs5.writeFileSync)(ITERATION_FILE, `${iteration}:${commit}:${contentHash ?? ""}`);
 }
 
 // src/lib/static-analysis.ts
-var import_node_child_process5 = require("node:child_process");
-var import_node_fs5 = require("node:fs");
+var import_node_child_process6 = require("node:child_process");
+var import_node_fs6 = require("node:fs");
 var SEVERITY_ORDER = {
   Error: 0,
   Critical: 0,
@@ -11606,7 +11691,7 @@ var SEVERITY_ORDER = {
 };
 function isCodacyAvailable() {
   try {
-    (0, import_node_child_process5.execSync)("which codacy-analysis", { stdio: "pipe" });
+    (0, import_node_child_process6.execSync)("which codacy-analysis", { stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -11621,7 +11706,7 @@ function runCodacyAnalysis(files) {
   if (files.length === 0) return empty;
   const existingFiles = files.filter((f) => {
     try {
-      return (0, import_node_fs5.existsSync)(f);
+      return (0, import_node_fs6.existsSync)(f);
     } catch {
       return false;
     }
@@ -11630,7 +11715,7 @@ function runCodacyAnalysis(files) {
   const fileArgs = existingFiles.join(" ");
   let output;
   try {
-    output = (0, import_node_child_process5.execSync)(
+    output = (0, import_node_child_process6.execSync)(
       `codacy-analysis analyze --install-dependencies --files ${fileArgs} --output-format json --log-level error --parallel-tools 3`,
       { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], maxBuffer: 10 * 1024 * 1024 }
     );
@@ -11683,7 +11768,7 @@ function runCodacyAnalysis(files) {
 }
 
 // src/lib/specs.ts
-var import_node_fs6 = require("node:fs");
+var import_node_fs7 = require("node:fs");
 var import_node_path6 = require("node:path");
 var SPEC_CANDIDATES = [
   "CLAUDE.md",
@@ -11708,15 +11793,15 @@ function discoverSpecs() {
     if (result.length >= MAX_SPEC_FILES) return false;
     if (totalBytes >= MAX_TOTAL_SPEC_BYTES) return false;
     if (seen.has(specPath)) return true;
-    if (!(0, import_node_fs6.existsSync)(specPath)) return true;
+    if (!(0, import_node_fs7.existsSync)(specPath)) return true;
     seen.add(specPath);
     const remaining = MAX_TOTAL_SPEC_BYTES - totalBytes;
     const readBytes = Math.min(MAX_SPEC_FILE_BYTES, remaining);
     try {
       const buf = Buffer.alloc(readBytes);
-      const fd = (0, import_node_fs6.openSync)(specPath, "r");
-      const bytesRead = (0, import_node_fs6.readSync)(fd, buf, 0, readBytes, 0);
-      (0, import_node_fs6.closeSync)(fd);
+      const fd = (0, import_node_fs7.openSync)(specPath, "r");
+      const bytesRead = (0, import_node_fs7.readSync)(fd, buf, 0, readBytes, 0);
+      (0, import_node_fs7.closeSync)(fd);
       const content = buf.slice(0, bytesRead).toString("utf-8");
       if (!content) return true;
       result.push({ path: specPath, content });
@@ -11729,7 +11814,7 @@ function discoverSpecs() {
     if (!addSpec(candidate)) break;
   }
   for (const dir of ["spec", "docs"]) {
-    if (!(0, import_node_fs6.existsSync)(dir)) continue;
+    if (!(0, import_node_fs7.existsSync)(dir)) continue;
     try {
       const mdFiles = findMdFiles(dir, 2).sort();
       for (const mdFile of mdFiles) {
@@ -11744,7 +11829,7 @@ function findMdFiles(dir, maxDepth, depth = 0) {
   if (depth >= maxDepth) return [];
   const result = [];
   try {
-    const entries = (0, import_node_fs6.readdirSync)(dir, { withFileTypes: true });
+    const entries = (0, import_node_fs7.readdirSync)(dir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = (0, import_node_path6.join)(dir, entry.name);
       if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -11759,13 +11844,13 @@ function findMdFiles(dir, maxDepth, depth = 0) {
 }
 function discoverPlans() {
   const plansDir = ".claude/plans";
-  if (!(0, import_node_fs6.existsSync)(plansDir)) return [];
+  if (!(0, import_node_fs7.existsSync)(plansDir)) return [];
   const result = [];
   try {
-    const entries = (0, import_node_fs6.readdirSync)(plansDir).filter((f) => f.endsWith(".md")).map((f) => {
+    const entries = (0, import_node_fs7.readdirSync)(plansDir).filter((f) => f.endsWith(".md")).map((f) => {
       const fullPath = (0, import_node_path6.join)(plansDir, f);
       try {
-        const stat = (0, import_node_fs6.statSync)(fullPath);
+        const stat = (0, import_node_fs7.statSync)(fullPath);
         return { name: f, path: fullPath, mtime: stat.mtimeMs, size: stat.size };
       } catch {
         return null;
@@ -11774,7 +11859,7 @@ function discoverPlans() {
     for (const entry of entries) {
       if (entry.size > MAX_PLAN_FILE_BYTES) continue;
       try {
-        const content = (0, import_node_fs6.readFileSync)(entry.path, "utf-8");
+        const content = (0, import_node_fs7.readFileSync)(entry.path, "utf-8");
         result.push({ name: entry.name, content });
       } catch {
       }
@@ -11784,15 +11869,113 @@ function discoverPlans() {
   return result;
 }
 
+// src/lib/snapshot.ts
+var import_node_fs8 = require("node:fs");
+var import_node_path7 = require("node:path");
+var import_node_child_process7 = require("node:child_process");
+function generateSnapshotDiffs(files) {
+  if (!(0, import_node_fs8.existsSync)(SNAPSHOT_DIR)) {
+    return { diffs: [], has_snapshots: false };
+  }
+  const diffs = [];
+  for (const file of files) {
+    const snapshotPath = (0, import_node_path7.join)(SNAPSHOT_DIR, file.path);
+    const language = file.language ?? detectLanguage(file.path);
+    if ((0, import_node_fs8.existsSync)(snapshotPath)) {
+      const oldContent = (0, import_node_fs8.readFileSync)(snapshotPath, "utf-8");
+      if (oldContent === file.content) continue;
+      const diff = computeDiff(oldContent, file.content, file.path);
+      if (diff) {
+        diffs.push({ path: file.path, language, diff, status: "modified" });
+      }
+    } else {
+      const addedLines = file.content.split("\n").map((l) => `+${l}`).join("\n");
+      diffs.push({
+        path: file.path,
+        language,
+        diff: `--- /dev/null
++++ b/${file.path}
+@@ -0,0 +1,${file.content.split("\n").length} @@
+${addedLines}`,
+        status: "added"
+      });
+    }
+  }
+  return { diffs, has_snapshots: true };
+}
+function saveSnapshots(files) {
+  const snapshotPaths = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const snapshotPath = (0, import_node_path7.join)(SNAPSHOT_DIR, file.path);
+    snapshotPaths.add(snapshotPath);
+    (0, import_node_fs8.mkdirSync)((0, import_node_path7.dirname)(snapshotPath), { recursive: true });
+    (0, import_node_fs8.writeFileSync)(snapshotPath, file.content);
+  }
+  cleanStaleSnapshots(SNAPSHOT_DIR, snapshotPaths);
+}
+function computeDiff(oldContent, newContent, filePath) {
+  const tmpOld = (0, import_node_path7.join)(SNAPSHOT_DIR, ".diff-old.tmp");
+  const tmpNew = (0, import_node_path7.join)(SNAPSHOT_DIR, ".diff-new.tmp");
+  try {
+    (0, import_node_fs8.mkdirSync)(SNAPSHOT_DIR, { recursive: true });
+    (0, import_node_fs8.writeFileSync)(tmpOld, oldContent);
+    (0, import_node_fs8.writeFileSync)(tmpNew, newContent);
+    const result = (0, import_node_child_process7.execSync)(
+      `git diff --no-index --unified=3 -- "${tmpOld}" "${tmpNew}"`,
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    );
+    return result || null;
+  } catch (err) {
+    const error = err;
+    if (error.status === 1 && error.stdout) {
+      return error.stdout.replace(/^diff --git a\/.*$/m, `diff --git a/${filePath} b/${filePath}`).replace(/^--- a\/.*$/m, `--- a/${filePath}`).replace(/^\+\+\+ b\/.*$/m, `+++ b/${filePath}`);
+    }
+    return null;
+  } finally {
+    try {
+      (0, import_node_fs8.unlinkSync)(tmpOld);
+    } catch {
+    }
+    try {
+      (0, import_node_fs8.unlinkSync)(tmpNew);
+    } catch {
+    }
+  }
+}
+function cleanStaleSnapshots(dir, keepSet) {
+  if (!(0, import_node_fs8.existsSync)(dir)) return;
+  try {
+    const entries = (0, import_node_fs8.readdirSync)(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".")) continue;
+      const fullPath = (0, import_node_path7.join)(dir, entry.name);
+      if (entry.isDirectory()) {
+        cleanStaleSnapshots(fullPath, keepSet);
+        try {
+          const remaining = (0, import_node_fs8.readdirSync)(fullPath);
+          if (remaining.length === 0) (0, import_node_fs8.rmdirSync)(fullPath);
+        } catch {
+        }
+      } else if (!keepSet.has(fullPath)) {
+        try {
+          (0, import_node_fs8.unlinkSync)(fullPath);
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+}
+
 // src/lib/offline.ts
-var import_node_fs7 = require("node:fs");
+var import_node_fs9 = require("node:fs");
 var import_node_crypto2 = require("node:crypto");
 function cacheRequest(body) {
   try {
-    (0, import_node_fs7.mkdirSync)(CACHE_DIR, { recursive: true });
+    (0, import_node_fs9.mkdirSync)(CACHE_DIR, { recursive: true });
     const suffix = (0, import_node_crypto2.randomBytes)(4).toString("hex");
     const filename = `pending-${Math.floor(Date.now() / 1e3)}-${suffix}.json`;
-    (0, import_node_fs7.writeFileSync)(`${CACHE_DIR}/${filename}`, JSON.stringify(body));
+    (0, import_node_fs9.writeFileSync)(`${CACHE_DIR}/${filename}`, JSON.stringify(body));
   } catch {
   }
 }
@@ -11821,7 +12004,7 @@ function registerAnalyzeCommand(program2) {
   });
 }
 async function runAnalyze(opts, globals) {
-  const allChanged = getChangedFiles();
+  const { files: allChanged, hasRecentCommitFiles } = getChangedFiles();
   const analyzable = filterAnalyzable(allChanged);
   const reviewable = filterReviewable(allChanged);
   const securityFiles = filterSecurity(allChanged);
@@ -11833,13 +12016,13 @@ async function runAnalyze(opts, globals) {
   const debounceSkip = checkDebounce(debounceSeconds);
   if (debounceSkip) passAndExit(debounceSkip);
   const allCheckable = Array.from(/* @__PURE__ */ new Set([...analyzable, ...reviewable, ...securityFiles]));
-  const mtimeSkip = checkMtime(allCheckable);
+  const mtimeSkip = checkMtime(allCheckable, hasRecentCommitFiles);
   if (mtimeSkip) passAndExit(mtimeSkip);
   recordAnalysisStart();
   const { skip: hashSkip, hash: contentHash } = checkContentHash(allCheckable);
   if (hashSkip) passAndExit(hashSkip);
   const recentForReview = narrowToRecent(allForReview);
-  const intent = await readAndClearIntent();
+  const conversation = await readAndClearConversationBuffer();
   const specs = discoverSpecs();
   const plans = discoverPlans();
   let staticResults;
@@ -11861,6 +12044,7 @@ async function runAnalyze(opts, globals) {
   if (codeDelta.files.length === 0 && staticResults.findings.length === 0) {
     passAndExit("No files within size limits to analyze");
   }
+  const snapshotResult = generateSnapshotDiffs(codeDelta.files);
   const tokenResult = await resolveToken(globals.token);
   if (!tokenResult.ok) {
     passAndExit("Not configured yet \u2014 run /gate-setup in Claude Code to enable quality gates.");
@@ -11871,7 +12055,7 @@ async function runAnalyze(opts, globals) {
   }
   const currentCommit = getCurrentCommit();
   const maxIterations = parseInt(opts.maxIterations, 10);
-  const { skip: iterSkip, iteration } = checkMaxIterations(currentCommit, maxIterations);
+  const { skip: iterSkip, iteration } = checkMaxIterations(currentCommit, maxIterations, contentHash ?? void 0);
   if (iterSkip) passAndExit(iterSkip);
   const requestBody = {
     static_results: staticResults,
@@ -11885,13 +12069,23 @@ async function runAnalyze(opts, globals) {
       iteration
     }
   };
-  const hasIntent = intent?.prompt || specs.length > 0 || plans.length > 0;
+  if (snapshotResult.has_snapshots && snapshotResult.diffs.length > 0) {
+    requestBody.snapshot_diffs = snapshotResult.diffs;
+  }
+  const hasIntent = (conversation?.prompts?.length ?? 0) > 0 || specs.length > 0 || plans.length > 0;
   if (hasIntent) {
     const intentContext = {};
-    if (intent?.prompt) {
-      intentContext.user_prompt = intent.prompt;
-      intentContext.session_id = intent.session_id || void 0;
-      intentContext.prompt_captured_at = intent.captured_at || void 0;
+    if (conversation && conversation.prompts.length > 0) {
+      const latest = conversation.prompts[conversation.prompts.length - 1];
+      intentContext.user_prompt = latest.prompt;
+      intentContext.session_id = latest.session_id || void 0;
+      intentContext.prompt_captured_at = latest.captured_at || void 0;
+      if (conversation.prompts.length > 1) {
+        intentContext.conversation = conversation.prompts;
+      }
+      if (conversation.recent_commits.length > 0) {
+        intentContext.recent_commits = conversation.recent_commits;
+      }
     }
     if (specs.length > 0) intentContext.specs = specs;
     if (plans.length > 0) intentContext.plans = plans;
@@ -11920,9 +12114,10 @@ async function runAnalyze(opts, globals) {
   }
   const response = result.data;
   const decision = response.gate_decision ?? "PASS";
+  saveSnapshots(codeDelta.files.map((f) => ({ path: f.path, content: f.content })));
   switch (decision) {
     case "FAIL": {
-      writeIteration(iteration + 1, currentCommit);
+      writeIteration(iteration + 1, currentCommit, contentHash ?? void 0);
       const assessment = response.assessment;
       const narrative = assessment?.narrative ?? "";
       const findings = response.findings ?? [];
@@ -11979,7 +12174,7 @@ async function runAnalyze(opts, globals) {
       break;
     }
     case "PASS": {
-      writeIteration(1, currentCommit);
+      writeIteration(1, currentCommit, contentHash ?? void 0);
       if (contentHash) recordPassHash(contentHash);
       let userSummary = response.user_summary ?? "GATE.md: PASS";
       const viewUrl = response.view_url ?? "";
@@ -12005,7 +12200,7 @@ async function runAnalyze(opts, globals) {
 }
 
 // src/commands/review.ts
-var import_node_fs8 = require("node:fs");
+var import_node_fs10 = require("node:fs");
 function registerReviewCommand(program2) {
   program2.command("review").description("Run on-demand GATE.md analysis (advisory, never blocks)").requiredOption("--files <paths>", "Comma-separated file list").option("--changed <paths>", "Subset of --files that were modified").option("--intent <text>", "User intent description (max 2000 chars)").option("--specs <paths>", "Comma-separated spec file paths").option("--json", "Output raw JSON response").action(async (opts) => {
     const globals = program2.opts();
@@ -12024,7 +12219,7 @@ async function runReview(opts, globals) {
   const securityFiles = filterSecurity(allFiles);
   let staticResults;
   if (isCodacyAvailable()) {
-    const scannable = Array.from(/* @__PURE__ */ new Set([...analyzable, ...securityFiles])).filter((f) => (0, import_node_fs8.existsSync)(f) || resolveFile(f) !== null);
+    const scannable = Array.from(/* @__PURE__ */ new Set([...analyzable, ...securityFiles])).filter((f) => (0, import_node_fs10.existsSync)(f) || resolveFile(f) !== null);
     staticResults = runCodacyAnalysis(scannable);
   } else {
     staticResults = {
@@ -12049,10 +12244,10 @@ async function runReview(opts, globals) {
     const specPaths = opts.specs.split(",").map((f) => f.trim()).filter(Boolean);
     specs = [];
     for (const p of specPaths) {
-      if (!(0, import_node_fs8.existsSync)(p)) continue;
+      if (!(0, import_node_fs10.existsSync)(p)) continue;
       try {
-        const { readFileSync: readFileSync4 } = await import("node:fs");
-        const content = readFileSync4(p, "utf-8");
+        const { readFileSync: readFileSync5 } = await import("node:fs");
+        const content = readFileSync5(p, "utf-8");
         specs.push({ path: p, content: content.slice(0, 10240) });
       } catch {
       }
@@ -12110,21 +12305,21 @@ async function runReview(opts, globals) {
 }
 
 // src/commands/init.ts
-var import_node_fs9 = require("node:fs");
+var import_node_fs11 = require("node:fs");
 var import_promises8 = require("node:fs/promises");
-var import_node_path7 = require("node:path");
-var import_node_child_process6 = require("node:child_process");
+var import_node_path8 = require("node:path");
+var import_node_child_process8 = require("node:child_process");
 function resolveDataDir() {
   const candidates = [
-    (0, import_node_path7.join)(__dirname, "..", "data"),
+    (0, import_node_path8.join)(__dirname, "..", "data"),
     // installed: node_modules/@codacy/gate-cli/data
-    (0, import_node_path7.join)(__dirname, "..", "..", "data"),
+    (0, import_node_path8.join)(__dirname, "..", "..", "data"),
     // edge case: nested resolution
-    (0, import_node_path7.join)(process.cwd(), "cli", "data")
+    (0, import_node_path8.join)(process.cwd(), "cli", "data")
     // local dev: running from repo root
   ];
   for (const candidate of candidates) {
-    if ((0, import_node_fs9.existsSync)((0, import_node_path7.join)(candidate, "skills"))) {
+    if ((0, import_node_fs11.existsSync)((0, import_node_path8.join)(candidate, "skills"))) {
       return candidate;
     }
   }
@@ -12140,7 +12335,7 @@ function registerInitCommand(program2) {
   program2.command("init").description("Initialize GATE.md in the current project").option("--force", "Overwrite existing skills and hooks").action(async (opts) => {
     const force = opts.force ?? false;
     const projectMarkers = [".git", "package.json", "pyproject.toml", "go.mod", "Cargo.toml", "Gemfile", "pom.xml", "build.gradle"];
-    const isProject = projectMarkers.some((m) => (0, import_node_fs9.existsSync)(m));
+    const isProject = projectMarkers.some((m) => (0, import_node_fs11.existsSync)(m));
     if (!isProject) {
       printError("No project detected in the current directory.");
       printInfo('Run "gate init" from your project root.');
@@ -12158,30 +12353,30 @@ function registerInitCommand(program2) {
     }
     printInfo(`  Node.js ${nodeVersion} \u2713`);
     try {
-      const gitVersion = (0, import_node_child_process6.execSync)("git --version", { encoding: "utf-8" }).trim();
+      const gitVersion = (0, import_node_child_process8.execSync)("git --version", { encoding: "utf-8" }).trim();
       printInfo(`  ${gitVersion} \u2713`);
     } catch {
       printError("git is required but not installed. Install from https://git-scm.com");
       process.exit(1);
     }
     try {
-      (0, import_node_child_process6.execSync)("which claude", { encoding: "utf-8" });
+      (0, import_node_child_process8.execSync)("which claude", { encoding: "utf-8" });
       printInfo("  Claude Code \u2713");
     } catch {
       printWarn("  Claude Code not found \u2014 hooks will be configured but need Claude Code to run.");
     }
     try {
-      (0, import_node_child_process6.execSync)("which codacy-analysis", { encoding: "utf-8", stdio: "pipe" });
+      (0, import_node_child_process8.execSync)("which codacy-analysis", { encoding: "utf-8", stdio: "pipe" });
       printInfo("  @codacy/analysis-cli \u2713");
     } catch {
       printInfo("  Installing @codacy/analysis-cli...");
       try {
-        (0, import_node_child_process6.execSync)("npm install -g @codacy/analysis-cli", { encoding: "utf-8", stdio: "pipe", timeout: 12e4 });
+        (0, import_node_child_process8.execSync)("npm install -g @codacy/analysis-cli", { encoding: "utf-8", stdio: "pipe", timeout: 12e4 });
         printInfo("  @codacy/analysis-cli installed \u2713");
       } catch {
         try {
           printWarn("  Retrying with sudo...");
-          (0, import_node_child_process6.execSync)("sudo npm install -g @codacy/analysis-cli", { encoding: "utf-8", stdio: "inherit", timeout: 12e4 });
+          (0, import_node_child_process8.execSync)("sudo npm install -g @codacy/analysis-cli", { encoding: "utf-8", stdio: "inherit", timeout: 12e4 });
           printInfo("  @codacy/analysis-cli installed \u2713");
         } catch {
           printWarn("  Could not install @codacy/analysis-cli automatically.");
@@ -12193,21 +12388,21 @@ function registerInitCommand(program2) {
     console.log("");
     printInfo("Installing skills...");
     const dataDir = resolveDataDir();
-    const skillsSource = (0, import_node_path7.join)(dataDir, "skills");
+    const skillsSource = (0, import_node_path8.join)(dataDir, "skills");
     const skillsDest = ".claude/skills";
     const skills = ["gate-setup", "gate-analyze", "gate-status", "gate-feedback"];
     let skillsInstalled = 0;
     for (const skill of skills) {
-      const src = (0, import_node_path7.join)(skillsSource, skill);
-      const dest = (0, import_node_path7.join)(skillsDest, skill);
-      if (!(0, import_node_fs9.existsSync)(src)) {
+      const src = (0, import_node_path8.join)(skillsSource, skill);
+      const dest = (0, import_node_path8.join)(skillsDest, skill);
+      if (!(0, import_node_fs11.existsSync)(src)) {
         printWarn(`  Skill data not found: ${skill}`);
         continue;
       }
-      if ((0, import_node_fs9.existsSync)(dest) && !force) {
-        const srcSkill = (0, import_node_path7.join)(src, "SKILL.md");
-        const destSkill = (0, import_node_path7.join)(dest, "SKILL.md");
-        if ((0, import_node_fs9.existsSync)(destSkill)) {
+      if ((0, import_node_fs11.existsSync)(dest) && !force) {
+        const srcSkill = (0, import_node_path8.join)(src, "SKILL.md");
+        const destSkill = (0, import_node_path8.join)(dest, "SKILL.md");
+        if ((0, import_node_fs11.existsSync)(destSkill)) {
           try {
             const srcContent = await (0, import_promises8.readFile)(srcSkill, "utf-8");
             const destContent = await (0, import_promises8.readFile)(destSkill, "utf-8");
@@ -12235,7 +12430,7 @@ function registerInitCommand(program2) {
       printInfo('  Run "gate hooks install --force" to overwrite.');
     }
     await (0, import_promises8.mkdir)(GATE_DIR, { recursive: true });
-    const globalGateDir = (0, import_node_path7.join)(process.env.HOME ?? "", ".gate");
+    const globalGateDir = (0, import_node_path8.join)(process.env.HOME ?? "", ".gate");
     await (0, import_promises8.mkdir)(globalGateDir, { recursive: true });
     console.log("");
     printInfo("GATE.md initialized!");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codacy/gate-cli",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "description": "CLI for GATE.md quality gate service",
   "bin": {
     "gate": "./bin/gate.js"