@codacy/gate-cli 0.14.1 → 0.14.3

package/bin/gate.js

@@ -10355,6 +10355,9 @@ var ITERATION_FILE = `${GATE_DIR}/.iteration-count`;
 var HASH_FILE = `${GATE_DIR}/.last-pass-hash`;
 var INTENT_FILE = `${GATE_DIR}/.last-intent`;
 var CACHE_DIR = `${GATE_DIR}/.cache`;
+var DEBUG_LOG_DIR = `${GATE_DIR}/.logs`;
+var DEBUG_LOG_FILE = `${DEBUG_LOG_DIR}/cli.log`;
+var DEBUG_LOG_MAX_BYTES = 1048576;
 var GATE_MD_FILE = "GATE.md";
 var CLAUDE_SETTINGS_FILE = ".claude/settings.json";
 var STANDARD_FILE = `${GATE_DIR}/standard.yaml`;
@@ -10588,9 +10591,54 @@ function printVerbose(msg, verbose) {
   }
 }
 
+// src/lib/debug-log.ts
+var import_node_fs = require("node:fs");
+function isEnabled() {
+  const v = process.env.GATE_DEBUG;
+  if (v === "0" || v === "false" || v === "off") return false;
+  return true;
+}
+function logHttpCall(entry) {
+  if (!isEnabled()) return;
+  writeLine({ ts: (/* @__PURE__ */ new Date()).toISOString(), kind: "http", ...entry });
+}
+function logEvent(event, data) {
+  if (!isEnabled()) return;
+  writeLine({ ts: (/* @__PURE__ */ new Date()).toISOString(), kind: "event", event, ...data ?? {} });
+}
+function writeLine(obj) {
+  try {
+    const dir = projectPath(DEBUG_LOG_DIR);
+    const file = projectPath(DEBUG_LOG_FILE);
+    (0, import_node_fs.mkdirSync)(dir, { recursive: true });
+    rotateIfNeeded(file);
+    (0, import_node_fs.appendFileSync)(file, JSON.stringify(obj) + "\n");
+  } catch {
+  }
+}
+function rotateIfNeeded(file) {
+  try {
+    const s = (0, import_node_fs.statSync)(file);
+    if (s.size < DEBUG_LOG_MAX_BYTES) return;
+    (0, import_node_fs.renameSync)(file, `${file}.1`);
+  } catch {
+  }
+}
+
 // src/lib/api-client.ts
 async function apiRequest(options) {
-  const { method, path, serviceUrl, token, body, verbose, timeout = 9e4 } = options;
+  const {
+    method,
+    path,
+    serviceUrl,
+    token,
+    body,
+    verbose,
+    timeout = 9e4,
+    cmd = "unknown",
+    retry = false,
+    encodeBody = false
+  } = options;
   const url = `${serviceUrl}${path}`;
   const headers = {
     "Content-Type": "application/json"
@@ -10599,36 +10647,74 @@ async function apiRequest(options) {
     headers["Authorization"] = `Bearer ${token}`;
   }
   printVerbose(`${method} ${url}`, verbose);
-  if (body) {
-    printVerbose(`Body: ${JSON.stringify(body).slice(0, 500)}`, verbose);
+  let serializedBody;
+  if (body !== void 0 && body !== null) {
+    const innerJson = JSON.stringify(body);
+    if (encodeBody) {
+      const payload = Buffer.from(innerJson, "utf8").toString("base64");
+      serializedBody = JSON.stringify({ encoding: "base64", payload });
+    } else {
+      serializedBody = innerJson;
+    }
+    printVerbose(`Body: ${serializedBody.slice(0, 500)}`, verbose);
   }
+  const startedAt = Date.now();
+  const bodyBytes = serializedBody ? Buffer.byteLength(serializedBody) : 0;
+  const logBase = { cmd, method, url, body_bytes: bodyBytes, retry, encoded: encodeBody };
   let response;
   try {
     response = await fetch(url, {
       method,
       headers,
-      body: body ? JSON.stringify(body) : void 0,
+      body: serializedBody,
       signal: AbortSignal.timeout(timeout)
     });
   } catch (err) {
-    if (err instanceof DOMException && err.name === "TimeoutError") {
-      return { ok: false, error: `Request timed out after ${timeout}ms` };
-    }
-    return { ok: false, error: `Network error: ${err.message}` };
+    const duration2 = Date.now() - startedAt;
+    const isTimeout = err instanceof DOMException && err.name === "TimeoutError";
+    const category = isTimeout ? "timeout" : "network";
+    const error = isTimeout ? `Request timed out after ${timeout}ms` : `Network error: ${err.message}`;
+    logHttpCall({ ...logBase, duration_ms: duration2, http_status: null, category, error });
+    return { ok: false, error, category };
   }
   let data;
   try {
     data = await response.json();
   } catch {
-    return { ok: false, error: `Invalid JSON response (HTTP ${response.status})` };
+    const duration2 = Date.now() - startedAt;
+    const error = `Invalid JSON response (HTTP ${response.status})`;
+    logHttpCall({
+      ...logBase,
+      duration_ms: duration2,
+      http_status: response.status,
+      category: "invalid_json",
+      error
+    });
+    return { ok: false, error, category: "invalid_json" };
   }
   printVerbose(`Response ${response.status}: ${JSON.stringify(data).slice(0, 500)}`, verbose);
+  const duration = Date.now() - startedAt;
   if (!response.ok) {
     const apiErr = data;
     const code = apiErr?.error?.code ?? "UNKNOWN";
     const message = apiErr?.error?.message ?? `HTTP ${response.status}`;
-    return { ok: false, error: `${code}: ${message}` };
+    const category = response.status >= 500 ? "http_5xx" : "http_4xx";
+    const error = `${code}: ${message}`;
+    logHttpCall({
+      ...logBase,
+      duration_ms: duration,
+      http_status: response.status,
+      category,
+      error
+    });
+    return { ok: false, error, category };
   }
+  logHttpCall({
+    ...logBase,
+    duration_ms: duration,
+    http_status: response.status,
+    category: "ok"
+  });
   return { ok: true, data };
 }
 
@@ -10858,7 +10944,7 @@ function registerHooksCommands(program2) {
 
 // src/lib/conversation-buffer.ts
 var import_promises5 = require("node:fs/promises");
-var import_node_fs = require("node:fs");
+var import_node_fs2 = 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]");
@@ -10890,7 +10976,7 @@ async function appendToConversationBuffer(prompt, sessionId) {
 }
 async function readAndClearConversationBuffer() {
   try {
-    if ((0, import_node_fs.existsSync)(CONVERSATION_BUFFER_FILE)) {
+    if ((0, import_node_fs2.existsSync)(CONVERSATION_BUFFER_FILE)) {
       const entries = await readBufferEntries();
       await (0, import_promises5.unlink)(CONVERSATION_BUFFER_FILE).catch(() => {
       });
@@ -10901,7 +10987,7 @@ async function readAndClearConversationBuffer() {
         };
       }
     }
-    if ((0, import_node_fs.existsSync)(INTENT_FILE)) {
+    if ((0, import_node_fs2.existsSync)(INTENT_FILE)) {
       try {
         const content = await (0, import_promises5.readFile)(INTENT_FILE, "utf-8");
         await (0, import_promises5.unlink)(INTENT_FILE).catch(() => {
@@ -10957,12 +11043,12 @@ function getRecentCommitMessages() {
 }
 
 // src/commands/intent.ts
-var import_node_fs2 = require("node:fs");
+var import_node_fs3 = 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_fs2.existsSync)(GATE_DIR)) {
+      if (!(0, import_node_fs3.existsSync)(GATE_DIR)) {
         process.exit(0);
       }
       const chunks = [];
@@ -11301,17 +11387,17 @@ function registerFeedbackCommand(program2) {
 
 // src/lib/git.ts
 var import_node_child_process5 = require("node:child_process");
-var import_node_fs3 = require("node:fs");
+var import_node_fs4 = require("node:fs");
 var import_node_path4 = require("node:path");
 function resolveFile(relpath) {
-  if ((0, import_node_fs3.existsSync)(relpath)) return relpath;
-  if ((0, import_node_fs3.existsSync)(".claude/worktrees")) {
+  if ((0, import_node_fs4.existsSync)(relpath)) return relpath;
+  if ((0, import_node_fs4.existsSync)(".claude/worktrees")) {
     try {
-      const entries = (0, import_node_fs3.readdirSync)(".claude/worktrees", { withFileTypes: true });
+      const entries = (0, import_node_fs4.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_fs3.existsSync)(candidate)) return candidate;
+        if ((0, import_node_fs4.existsSync)(candidate)) return candidate;
       }
     } catch {
     }
@@ -11363,10 +11449,10 @@ function getChangedFiles() {
 function getWorktreeFiles() {
   const result = [];
   const worktreeDir = ".claude/worktrees";
-  if (!(0, import_node_fs3.existsSync)(worktreeDir)) return result;
+  if (!(0, import_node_fs4.existsSync)(worktreeDir)) return result;
   try {
     const fiveMinAgo = Date.now() - 5 * 60 * 1e3;
-    const entries = (0, import_node_fs3.readdirSync)(worktreeDir, { withFileTypes: true });
+    const entries = (0, import_node_fs4.readdirSync)(worktreeDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       const wtDir = (0, import_node_path4.join)(worktreeDir, entry.name);
@@ -11378,7 +11464,7 @@ function getWorktreeFiles() {
 }
 function scanDir(baseDir, dir, minMtime, result) {
   try {
-    const entries = (0, import_node_fs3.readdirSync)(dir, { withFileTypes: true });
+    const entries = (0, import_node_fs4.readdirSync)(dir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = (0, import_node_path4.join)(dir, entry.name);
       if (entry.isDirectory()) {
@@ -11388,7 +11474,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_fs3.statSync)(fullPath);
+          const stat = (0, import_node_fs4.statSync)(fullPath);
           if (stat.mtimeMs >= minMtime) {
             const relPath = fullPath.slice(baseDir.length + 1);
             result.push(relPath);
@@ -11427,7 +11513,7 @@ function getCurrentCommit() {
 }
 
 // src/lib/files.ts
-var import_node_fs4 = require("node:fs");
+var import_node_fs5 = require("node:fs");
 var import_node_path5 = require("node:path");
 var LANG_MAP = {
   // Analyzable (static analysis + Gemini)
@@ -11504,7 +11590,7 @@ function sortByMtime(files) {
     const resolved = resolveFile(f);
     if (!resolved) return null;
     try {
-      const stat = (0, import_node_fs4.statSync)(resolved);
+      const stat = (0, import_node_fs5.statSync)(resolved);
       return { path: f, resolved, mtime: stat.mtimeMs };
     } catch {
       return null;
@@ -11526,7 +11612,7 @@ function collectCodeDelta(files, opts) {
     if (!resolved) continue;
     let size;
     try {
-      size = (0, import_node_fs4.statSync)(resolved).size;
+      size = (0, import_node_fs5.statSync)(resolved).size;
     } catch {
       continue;
     }
@@ -11534,7 +11620,7 @@ function collectCodeDelta(files, opts) {
     if (totalSize + size > maxTotalBytes) break;
     let content;
     try {
-      content = (0, import_node_fs4.readFileSync)(resolved, "utf-8");
+      content = (0, import_node_fs5.readFileSync)(resolved, "utf-8");
     } catch {
       continue;
     }
@@ -11557,12 +11643,12 @@ function collectCodeDelta(files, opts) {
 }
 
 // src/lib/debounce.ts
-var import_node_fs5 = require("node:fs");
+var import_node_fs6 = require("node:fs");
 var import_node_crypto = require("node:crypto");
 function checkDebounce(debounceSeconds = DEBOUNCE_SECONDS) {
-  if (!(0, import_node_fs5.existsSync)(DEBOUNCE_FILE)) return null;
+  if (!(0, import_node_fs6.existsSync)(DEBOUNCE_FILE)) return null;
   try {
-    const lastTs = parseInt((0, import_node_fs5.readFileSync)(DEBOUNCE_FILE, "utf-8").trim(), 10);
+    const lastTs = parseInt((0, import_node_fs6.readFileSync)(DEBOUNCE_FILE, "utf-8").trim(), 10);
     const nowTs = Math.floor(Date.now() / 1e3);
     const elapsed = nowTs - lastTs;
     if (elapsed < debounceSeconds) {
@@ -11574,10 +11660,10 @@ function checkDebounce(debounceSeconds = DEBOUNCE_SECONDS) {
 }
 function checkMtime(files, bypassForRecentCommits) {
   if (bypassForRecentCommits) return null;
-  if (!(0, import_node_fs5.existsSync)(DEBOUNCE_FILE)) return null;
+  if (!(0, import_node_fs6.existsSync)(DEBOUNCE_FILE)) return null;
   let debounceTime;
   try {
-    debounceTime = (0, import_node_fs5.statSync)(DEBOUNCE_FILE).mtimeMs;
+    debounceTime = (0, import_node_fs6.statSync)(DEBOUNCE_FILE).mtimeMs;
   } catch {
     return null;
   }
@@ -11585,7 +11671,7 @@ function checkMtime(files, bypassForRecentCommits) {
     const resolved = resolveFile(f);
     if (!resolved) continue;
     try {
-      const stat = (0, import_node_fs5.statSync)(resolved);
+      const stat = (0, import_node_fs6.statSync)(resolved);
       if (stat.mtimeMs > debounceTime) {
         return null;
       }
@@ -11601,8 +11687,8 @@ function computeContentHash(files) {
   for (const f of sorted) {
     const resolved = resolveFile(f) ?? f;
     try {
-      if ((0, import_node_fs5.existsSync)(resolved)) {
-        hash.update((0, import_node_fs5.readFileSync)(resolved));
+      if ((0, import_node_fs6.existsSync)(resolved)) {
+        hash.update((0, import_node_fs6.readFileSync)(resolved));
       }
     } catch {
     }
@@ -11611,9 +11697,9 @@ function computeContentHash(files) {
 }
 function checkContentHash(files) {
   const hash = computeContentHash(files);
-  if ((0, import_node_fs5.existsSync)(HASH_FILE)) {
+  if ((0, import_node_fs6.existsSync)(HASH_FILE)) {
     try {
-      const storedHash = (0, import_node_fs5.readFileSync)(HASH_FILE, "utf-8").trim();
+      const storedHash = (0, import_node_fs6.readFileSync)(HASH_FILE, "utf-8").trim();
       if (hash === storedHash) {
         return { skip: "No source changes since last analysis", hash };
       }
@@ -11623,23 +11709,23 @@ function checkContentHash(files) {
   return { skip: null, hash };
 }
 function recordAnalysisStart() {
-  (0, import_node_fs5.mkdirSync)(GATE_DIR, { recursive: true });
-  (0, import_node_fs5.writeFileSync)(DEBOUNCE_FILE, String(Math.floor(Date.now() / 1e3)));
+  (0, import_node_fs6.mkdirSync)(GATE_DIR, { recursive: true });
+  (0, import_node_fs6.writeFileSync)(DEBOUNCE_FILE, String(Math.floor(Date.now() / 1e3)));
 }
 function recordPassHash(hash) {
-  (0, import_node_fs5.writeFileSync)(HASH_FILE, hash);
+  (0, import_node_fs6.writeFileSync)(HASH_FILE, hash);
 }
 function narrowToRecent(files) {
-  if (!(0, import_node_fs5.existsSync)(DEBOUNCE_FILE)) return files;
+  if (!(0, import_node_fs6.existsSync)(DEBOUNCE_FILE)) return files;
   let debounceTime;
   try {
-    debounceTime = (0, import_node_fs5.statSync)(DEBOUNCE_FILE).mtimeMs;
+    debounceTime = (0, import_node_fs6.statSync)(DEBOUNCE_FILE).mtimeMs;
   } catch {
     return files;
   }
   const recent = files.filter((f) => {
     try {
-      return (0, import_node_fs5.existsSync)(f) && (0, import_node_fs5.statSync)(f).mtimeMs > debounceTime;
+      return (0, import_node_fs6.existsSync)(f) && (0, import_node_fs6.statSync)(f).mtimeMs > debounceTime;
     } catch {
       return false;
     }
@@ -11647,9 +11733,9 @@ function narrowToRecent(files) {
   return recent.length > 0 ? recent : files;
 }
 function readIteration(currentCommit, _contentHash) {
-  if (!(0, import_node_fs5.existsSync)(ITERATION_FILE)) return 1;
+  if (!(0, import_node_fs6.existsSync)(ITERATION_FILE)) return 1;
   try {
-    const stored = (0, import_node_fs5.readFileSync)(ITERATION_FILE, "utf-8").trim();
+    const stored = (0, import_node_fs6.readFileSync)(ITERATION_FILE, "utf-8").trim();
     const parts = stored.split(":");
     const iter = parseInt(parts[0], 10);
     const storedCommit = parts[1] ?? "";
@@ -11677,14 +11763,14 @@ function checkMaxIterations(currentCommit, maxIterations = MAX_ITERATIONS, conte
   return { skip: null, iteration };
 }
 function writeIteration(iteration, commit, _contentHash) {
-  (0, import_node_fs5.mkdirSync)(GATE_DIR, { recursive: true });
+  (0, import_node_fs6.mkdirSync)(GATE_DIR, { recursive: true });
   const ts = Math.floor(Date.now() / 1e3);
-  (0, import_node_fs5.writeFileSync)(ITERATION_FILE, `${iteration}:${commit}:${ts}`);
+  (0, import_node_fs6.writeFileSync)(ITERATION_FILE, `${iteration}:${commit}:${ts}`);
 }
 
 // src/lib/static-analysis.ts
 var import_node_child_process6 = require("node:child_process");
-var import_node_fs6 = require("node:fs");
+var import_node_fs7 = require("node:fs");
 var SEVERITY_ORDER = {
   Error: 0,
   Critical: 0,
@@ -11711,7 +11797,7 @@ function runCodacyAnalysis(files) {
   if (files.length === 0) return empty;
   const existingFiles = files.filter((f) => {
     try {
-      return (0, import_node_fs6.existsSync)(f);
+      return (0, import_node_fs7.existsSync)(f);
     } catch {
       return false;
     }
@@ -11773,7 +11859,7 @@ function runCodacyAnalysis(files) {
 }
 
 // src/lib/specs.ts
-var import_node_fs7 = require("node:fs");
+var import_node_fs8 = require("node:fs");
 var import_node_path6 = require("node:path");
 var SPEC_CANDIDATES = [
   "CLAUDE.md",
@@ -11798,15 +11884,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_fs7.existsSync)(specPath)) return true;
+    if (!(0, import_node_fs8.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_fs7.openSync)(specPath, "r");
-      const bytesRead = (0, import_node_fs7.readSync)(fd, buf, 0, readBytes, 0);
-      (0, import_node_fs7.closeSync)(fd);
+      const fd = (0, import_node_fs8.openSync)(specPath, "r");
+      const bytesRead = (0, import_node_fs8.readSync)(fd, buf, 0, readBytes, 0);
+      (0, import_node_fs8.closeSync)(fd);
       const content = buf.slice(0, bytesRead).toString("utf-8");
       if (!content) return true;
       result.push({ path: specPath, content });
@@ -11819,7 +11905,7 @@ function discoverSpecs() {
     if (!addSpec(candidate)) break;
   }
   for (const dir of ["spec", "docs"]) {
-    if (!(0, import_node_fs7.existsSync)(dir)) continue;
+    if (!(0, import_node_fs8.existsSync)(dir)) continue;
     try {
       const mdFiles = findMdFiles(dir, 2).sort();
       for (const mdFile of mdFiles) {
@@ -11834,7 +11920,7 @@ function findMdFiles(dir, maxDepth, depth = 0) {
   if (depth >= maxDepth) return [];
   const result = [];
   try {
-    const entries = (0, import_node_fs7.readdirSync)(dir, { withFileTypes: true });
+    const entries = (0, import_node_fs8.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")) {
@@ -11853,14 +11939,14 @@ function discoverPlans() {
   const candidates = [];
   const seen = /* @__PURE__ */ new Set();
   for (const plansDir of [localPlansDir, homePlansDir]) {
-    if (!(0, import_node_fs7.existsSync)(plansDir)) continue;
+    if (!(0, import_node_fs8.existsSync)(plansDir)) continue;
     try {
-      for (const f of (0, import_node_fs7.readdirSync)(plansDir)) {
+      for (const f of (0, import_node_fs8.readdirSync)(plansDir)) {
         if (!f.endsWith(".md") || seen.has(f)) continue;
         seen.add(f);
         const fullPath = (0, import_node_path6.join)(plansDir, f);
         try {
-          const stat = (0, import_node_fs7.statSync)(fullPath);
+          const stat = (0, import_node_fs8.statSync)(fullPath);
           candidates.push({ name: f, path: fullPath, mtime: stat.mtimeMs, size: stat.size });
         } catch {
         }
@@ -11873,7 +11959,7 @@ function discoverPlans() {
   for (const entry of candidates.slice(0, MAX_PLAN_FILES)) {
     if (entry.size > MAX_PLAN_FILE_BYTES) continue;
     try {
-      const content = (0, import_node_fs7.readFileSync)(entry.path, "utf-8");
+      const content = (0, import_node_fs8.readFileSync)(entry.path, "utf-8");
       result.push({ name: entry.name, content });
     } catch {
     }
@@ -11882,19 +11968,19 @@ function discoverPlans() {
 }
 
 // src/lib/snapshot.ts
-var import_node_fs8 = require("node:fs");
+var import_node_fs9 = 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)) {
+  if (!(0, import_node_fs9.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 ((0, import_node_fs9.existsSync)(snapshotPath)) {
+      const oldContent = (0, import_node_fs9.readFileSync)(snapshotPath, "utf-8");
       if (oldContent === file.content) continue;
       const diff = computeDiff(oldContent, file.content, file.path);
       if (diff) {
@@ -11920,8 +12006,8 @@ function saveSnapshots(files) {
   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);
+    (0, import_node_fs9.mkdirSync)((0, import_node_path7.dirname)(snapshotPath), { recursive: true });
+    (0, import_node_fs9.writeFileSync)(snapshotPath, file.content);
   }
   cleanStaleSnapshots(SNAPSHOT_DIR, snapshotPaths);
 }
@@ -11929,9 +12015,9 @@ 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);
+    (0, import_node_fs9.mkdirSync)(SNAPSHOT_DIR, { recursive: true });
+    (0, import_node_fs9.writeFileSync)(tmpOld, oldContent);
+    (0, import_node_fs9.writeFileSync)(tmpNew, newContent);
     const result = (0, import_node_child_process7.execSync)(
       `git diff --no-index --unified=10 -- "${tmpOld}" "${tmpNew}"`,
       { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
@@ -11945,32 +12031,32 @@ function computeDiff(oldContent, newContent, filePath) {
     return null;
   } finally {
     try {
-      (0, import_node_fs8.unlinkSync)(tmpOld);
+      (0, import_node_fs9.unlinkSync)(tmpOld);
     } catch {
     }
     try {
-      (0, import_node_fs8.unlinkSync)(tmpNew);
+      (0, import_node_fs9.unlinkSync)(tmpNew);
     } catch {
     }
   }
 }
 function cleanStaleSnapshots(dir, keepSet) {
-  if (!(0, import_node_fs8.existsSync)(dir)) return;
+  if (!(0, import_node_fs9.existsSync)(dir)) return;
   try {
-    const entries = (0, import_node_fs8.readdirSync)(dir, { withFileTypes: true });
+    const entries = (0, import_node_fs9.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);
+          const remaining = (0, import_node_fs9.readdirSync)(fullPath);
+          if (remaining.length === 0) (0, import_node_fs9.rmdirSync)(fullPath);
         } catch {
         }
       } else if (!keepSet.has(fullPath)) {
         try {
-          (0, import_node_fs8.unlinkSync)(fullPath);
+          (0, import_node_fs9.unlinkSync)(fullPath);
         } catch {
         }
       }
@@ -11980,14 +12066,14 @@ function cleanStaleSnapshots(dir, keepSet) {
 }
 
 // src/lib/offline.ts
-var import_node_fs9 = require("node:fs");
+var import_node_fs10 = require("node:fs");
 var import_node_crypto2 = require("node:crypto");
 function cacheRequest(body) {
   try {
-    (0, import_node_fs9.mkdirSync)(CACHE_DIR, { recursive: true });
+    (0, import_node_fs10.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_fs9.writeFileSync)(`${CACHE_DIR}/${filename}`, JSON.stringify(body));
+    (0, import_node_fs10.writeFileSync)(`${CACHE_DIR}/${filename}`, JSON.stringify(body));
   } catch {
   }
 }
@@ -12070,7 +12156,7 @@ function detectAnalysisMode(noFilesChanged, assistantResponse, conversationPromp
 }
 
 // src/lib/transcript.ts
-var import_node_fs10 = require("node:fs");
+var import_node_fs11 = require("node:fs");
 var MAX_READ_BYTES = 256 * 1024;
 var SMALL_FILE_BYTES = 64 * 1024;
 var MAX_FILES_LIST = 20;
@@ -12092,14 +12178,14 @@ async function extractActionSummary(transcriptPath) {
 function readTurnLines(transcriptPath) {
   let size;
   try {
-    size = (0, import_node_fs10.statSync)(transcriptPath).size;
+    size = (0, import_node_fs11.statSync)(transcriptPath).size;
   } catch {
     return null;
   }
   if (size === 0) return null;
   let raw;
   if (size <= SMALL_FILE_BYTES) {
-    raw = (0, import_node_fs10.readFileSync)(transcriptPath, "utf-8");
+    raw = (0, import_node_fs11.readFileSync)(transcriptPath, "utf-8");
   } else {
     const buf = Buffer.alloc(Math.min(MAX_READ_BYTES, size));
     const fd = require("node:fs").openSync(transcriptPath, "r");
@@ -12463,19 +12549,46 @@ async function runAnalyze(opts, globals) {
     }
     requestBody.intent_context = intentContext;
   }
-  const result = await apiRequest({
+  const ANALYZE_TIMEOUT_MS = 1e5;
+  let result = await apiRequest({
     method: "POST",
     path: "/analyze",
     serviceUrl: urlResult.data,
     token: tokenResult.data.token,
     body: requestBody,
     verbose: globals.verbose,
-    timeout: 12e4
+    timeout: ANALYZE_TIMEOUT_MS,
+    cmd: "analyze",
+    encodeBody: true
   });
+  if (!result.ok && (result.category === "network" || result.category === "timeout")) {
+    logEvent("analyze_warm_retry", { first_error: result.error, category: result.category });
+    await apiRequest({
+      method: "GET",
+      path: "/memory",
+      serviceUrl: urlResult.data,
+      token: tokenResult.data.token,
+      verbose: globals.verbose,
+      timeout: 15e3,
+      cmd: "analyze_warmup"
+    });
+    result = await apiRequest({
+      method: "POST",
+      path: "/analyze",
+      serviceUrl: urlResult.data,
+      token: tokenResult.data.token,
+      body: requestBody,
+      verbose: globals.verbose,
+      timeout: ANALYZE_TIMEOUT_MS,
+      cmd: "analyze",
+      retry: true,
+      encodeBody: true
+    });
+  }
   if (!result.ok) {
     cacheRequest(requestBody);
     const fallback = buildOfflineFallback(
-      `GATE.md service error \u2014 offline mode`,
+      `GATE.md offline \u2014 ${result.error}`,
       staticResults
     );
     printJsonCompact(fallback);
@@ -12587,7 +12700,7 @@ async function runAnalyze(opts, globals) {
 }
 
 // src/commands/review.ts
-var import_node_fs11 = require("node:fs");
+var import_node_fs12 = 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();
@@ -12606,7 +12719,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_fs11.existsSync)(f) || resolveFile(f) !== null);
+    const scannable = Array.from(/* @__PURE__ */ new Set([...analyzable, ...securityFiles])).filter((f) => (0, import_node_fs12.existsSync)(f) || resolveFile(f) !== null);
     staticResults = runCodacyAnalysis(scannable);
   } else {
     staticResults = {
@@ -12631,7 +12744,7 @@ 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_fs11.existsSync)(p)) continue;
+      if (!(0, import_node_fs12.existsSync)(p)) continue;
       try {
         const { readFileSync: readFileSync6 } = await import("node:fs");
         const content = readFileSync6(p, "utf-8");
@@ -12692,7 +12805,7 @@ async function runReview(opts, globals) {
 }
 
 // src/commands/init.ts
-var import_node_fs12 = require("node:fs");
+var import_node_fs13 = require("node:fs");
 var import_promises8 = require("node:fs/promises");
 var import_node_path8 = require("node:path");
 var import_node_child_process8 = require("node:child_process");
@@ -12706,7 +12819,7 @@ function resolveDataDir() {
     // local dev: running from repo root
   ];
   for (const candidate of candidates) {
-    if ((0, import_node_fs12.existsSync)((0, import_node_path8.join)(candidate, "skills"))) {
+    if ((0, import_node_fs13.existsSync)((0, import_node_path8.join)(candidate, "skills"))) {
       return candidate;
     }
   }
@@ -12722,7 +12835,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_fs12.existsSync)(m));
+    const isProject = projectMarkers.some((m) => (0, import_node_fs13.existsSync)(m));
     if (!isProject) {
       printError("No project detected in the current directory.");
       printInfo('Run "gate init" from your project root.');
@@ -12782,14 +12895,14 @@ function registerInitCommand(program2) {
     for (const skill of skills) {
       const src = (0, import_node_path8.join)(skillsSource, skill);
       const dest = (0, import_node_path8.join)(skillsDest, skill);
-      if (!(0, import_node_fs12.existsSync)(src)) {
+      if (!(0, import_node_fs13.existsSync)(src)) {
         printWarn(`  Skill data not found: ${skill}`);
         continue;
       }
-      if ((0, import_node_fs12.existsSync)(dest) && !force) {
+      if ((0, import_node_fs13.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_fs12.existsSync)(destSkill)) {
+        if ((0, import_node_fs13.existsSync)(destSkill)) {
           try {
             const srcContent = await (0, import_promises8.readFile)(srcSkill, "utf-8");
             const destContent = await (0, import_promises8.readFile)(destSkill, "utf-8");
@@ -12835,7 +12948,7 @@ function registerInitCommand(program2) {
 }
 
 // src/cli.ts
-program.name("gate").description("CLI for GATE.md quality gate service").version("0.14.1").option("--token <token>", "Override authentication token").option("--service-url <url>", "Override service URL").option("--verbose", "Log HTTP requests/responses to stderr");
+program.name("gate").description("CLI for GATE.md quality gate service").version("0.14.3").option("--token <token>", "Override authentication token").option("--service-url <url>", "Override service URL").option("--verbose", "Log HTTP requests/responses to stderr");
 registerAuthCommands(program);
 registerHooksCommands(program);
 registerIntentCommands(program);

package/package.json

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