@codacy/gate-cli 0.14.3 → 0.15.0

package/bin/gate.js

@@ -10942,6 +10942,9 @@ function registerHooksCommands(program2) {
   });
 }
 
+// src/commands/intent.ts
+var import_node_crypto = require("node:crypto");
+
 // src/lib/conversation-buffer.ts
 var import_promises5 = require("node:fs/promises");
 var import_node_fs2 = require("node:fs");
@@ -11070,10 +11073,41 @@ function registerIntentCommands(program2) {
         process.exit(0);
       }
       await appendToConversationBuffer(prompt, event.session_id ?? "");
+      fireClassify(prompt, event.session_id ?? "").catch(() => {
+      });
     } catch {
     }
     process.exit(0);
   });
+  intent.command("classify-body").description("Output JSON body for POST /classify-task (internal, used by hooks)").requiredOption("--session-id <id>", "Session ID").requiredOption("--prompt <text>", "User prompt").requiredOption("--prompt-hash <hash>", "SHA-256 hash of the prompt").action((opts) => {
+    const body = JSON.stringify({
+      session_id: opts.sessionId,
+      user_prompt: opts.prompt.slice(0, 4e3),
+      user_prompt_hash: opts.promptHash
+    });
+    process.stdout.write(body);
+  });
+}
+async function fireClassify(prompt, sessionId) {
+  if (!sessionId) return;
+  const tokenResult = await resolveToken();
+  if (!tokenResult.ok) return;
+  const urlResult = await resolveServiceUrl();
+  if (!urlResult.ok) return;
+  const promptHash = (0, import_node_crypto.createHash)("sha256").update(prompt).digest("hex");
+  await apiRequest({
+    method: "POST",
+    path: "/classify-task",
+    serviceUrl: urlResult.data,
+    token: tokenResult.data.token,
+    body: {
+      session_id: sessionId,
+      user_prompt: prompt.slice(0, 4e3),
+      user_prompt_hash: promptHash
+    },
+    timeout: 2e3,
+    cmd: "classify"
+  });
 }
 
 // src/commands/standard.ts
@@ -11252,6 +11286,16 @@ function registerConfigCommands(program2) {
 }
 
 // src/commands/status.ts
+function timeAgo(isoDate) {
+  const ms = Date.now() - new Date(isoDate).getTime();
+  const mins = Math.floor(ms / 6e4);
+  if (mins < 1) return "just now";
+  if (mins < 60) return `${mins}m ago`;
+  const hrs = Math.floor(mins / 60);
+  if (hrs < 24) return `${hrs}h ago`;
+  const days = Math.floor(hrs / 24);
+  return `${days}d ago`;
+}
 function registerStatusCommand(program2) {
   program2.command("status").description("Show project quality status").option("--history", "Include recent run history").option("--limit <n>", "Number of history entries", "5").option("--json", "Output raw JSON").action(async (opts) => {
     const globals = program2.opts();
@@ -11324,6 +11368,27 @@ function registerStatusCommand(program2) {
         printInfo(`  [${item.priority.toUpperCase()}] ${item.description}`);
       }
     }
+    const recentTasks = mem.recent_tasks;
+    const currentTask = mem.current_task;
+    const contextFiles = mem.context_files;
+    if (recentTasks && recentTasks.length > 0) {
+      printInfo("");
+      printInfo("--- Active Tasks ---");
+      for (const task of recentTasks) {
+        const isCurrent = currentTask && task.id === currentTask.id;
+        const marker = isCurrent ? "\u25CF" : "\u25CB";
+        const runCount = task.run_count ?? 0;
+        const lastAt = task.last_run_at ? timeAgo(task.last_run_at) : "no runs";
+        printInfo(`  ${marker} ${task.label}  ${runCount} run${runCount === 1 ? "" : "s"}, ${lastAt}`);
+      }
+      if (currentTask) {
+        printInfo("");
+        printInfo(`Current task: ${currentTask.label}`);
+        if (contextFiles && contextFiles.length > 0) {
+          printInfo(`  Files in task: ${contextFiles.length} (${contextFiles.slice(0, 3).join(", ")}${contextFiles.length > 3 ? "..." : ""})`);
+        }
+      }
+    }
     if (opts.history) {
       const runsResult = await apiRequest({
         method: "GET",
@@ -11644,7 +11709,7 @@ function collectCodeDelta(files, opts) {
 
 // src/lib/debounce.ts
 var import_node_fs6 = require("node:fs");
-var import_node_crypto = require("node:crypto");
+var import_node_crypto2 = require("node:crypto");
 function checkDebounce(debounceSeconds = DEBOUNCE_SECONDS) {
   if (!(0, import_node_fs6.existsSync)(DEBOUNCE_FILE)) return null;
   try {
@@ -11682,7 +11747,7 @@ function checkMtime(files, bypassForRecentCommits) {
   return "No files modified since last analysis";
 }
 function computeContentHash(files) {
-  const hash = (0, import_node_crypto.createHash)("sha1");
+  const hash = (0, import_node_crypto2.createHash)("sha1");
   const sorted = [...files].sort();
   for (const f of sorted) {
     const resolved = resolveFile(f) ?? f;
@@ -12067,11 +12132,11 @@ function cleanStaleSnapshots(dir, keepSet) {
 
 // src/lib/offline.ts
 var import_node_fs10 = require("node:fs");
-var import_node_crypto2 = require("node:crypto");
+var import_node_crypto3 = require("node:crypto");
 function cacheRequest(body) {
   try {
     (0, import_node_fs10.mkdirSync)(CACHE_DIR, { recursive: true });
-    const suffix = (0, import_node_crypto2.randomBytes)(4).toString("hex");
+    const suffix = (0, import_node_crypto3.randomBytes)(4).toString("hex");
     const filename = `pending-${Math.floor(Date.now() / 1e3)}-${suffix}.json`;
     (0, import_node_fs10.writeFileSync)(`${CACHE_DIR}/${filename}`, JSON.stringify(body));
   } catch {
@@ -12086,6 +12151,90 @@ function buildOfflineFallback(reason, staticResults) {
   };
 }
 
+// src/lib/context-files.ts
+var import_node_fs11 = require("node:fs");
+var MAX_CONTEXT_FILES = 10;
+var MAX_CONTEXT_FILE_BYTES = 10240;
+var MAX_CONTEXT_TOTAL_BYTES = 51200;
+function gatherContextFiles(contextPaths, deltaFiles) {
+  const deltaPaths = new Set(deltaFiles.map((f) => f.path));
+  const result = [];
+  let totalBytes = 0;
+  for (const filePath of contextPaths) {
+    if (result.length >= MAX_CONTEXT_FILES) break;
+    if (deltaPaths.has(filePath)) continue;
+    try {
+      const content = (0, import_node_fs11.readFileSync)(filePath, "utf8");
+      const bytes = Buffer.byteLength(content);
+      if (bytes > MAX_CONTEXT_FILE_BYTES) {
+        logEvent("context_file_skipped", { path: filePath, reason: "too_large", bytes });
+        continue;
+      }
+      if (totalBytes + bytes > MAX_CONTEXT_TOTAL_BYTES) {
+        logEvent("context_file_skipped", { path: filePath, reason: "budget", bytes });
+        continue;
+      }
+      const ext = filePath.split(".").pop() ?? "";
+      const langMap = {
+        ts: "typescript",
+        tsx: "typescript",
+        js: "javascript",
+        jsx: "javascript",
+        py: "python",
+        rb: "ruby",
+        go: "go",
+        rs: "rust",
+        java: "java",
+        yaml: "yaml",
+        yml: "yaml",
+        json: "json",
+        md: "markdown",
+        sql: "sql",
+        sh: "bash",
+        css: "css",
+        html: "html"
+      };
+      result.push({
+        path: filePath,
+        content,
+        language: langMap[ext],
+        role: "context"
+      });
+      totalBytes += bytes;
+    } catch {
+      logEvent("context_file_skipped", { path: filePath, reason: "missing" });
+    }
+  }
+  return result;
+}
+
+// src/lib/cache-cleanup.ts
+var import_node_fs12 = require("node:fs");
+var import_node_path8 = require("node:path");
+var CACHE_TTL_DAYS = 7;
+function pruneStaleCache() {
+  try {
+    const dir = projectPath(CACHE_DIR);
+    const cutoff = Date.now() - CACHE_TTL_DAYS * 24 * 3600 * 1e3;
+    for (const entry of (0, import_node_fs12.readdirSync)(dir)) {
+      if (!entry.startsWith("pending-")) continue;
+      const path = (0, import_node_path8.join)(dir, entry);
+      try {
+        const stat = (0, import_node_fs12.statSync)(path);
+        if (stat.mtimeMs < cutoff) {
+          (0, import_node_fs12.unlinkSync)(path);
+          logEvent("cache_entry_pruned", {
+            path: entry,
+            age_days: Math.round((Date.now() - stat.mtimeMs) / 864e5)
+          });
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+
 // src/lib/analysis-mode.ts
 var DEBUG_PHRASES = [
   "not working",
@@ -12156,7 +12305,7 @@ function detectAnalysisMode(noFilesChanged, assistantResponse, conversationPromp
 }
 
 // src/lib/transcript.ts
-var import_node_fs11 = require("node:fs");
+var import_node_fs13 = require("node:fs");
 var MAX_READ_BYTES = 256 * 1024;
 var SMALL_FILE_BYTES = 64 * 1024;
 var MAX_FILES_LIST = 20;
@@ -12178,14 +12327,14 @@ async function extractActionSummary(transcriptPath) {
 function readTurnLines(transcriptPath) {
   let size;
   try {
-    size = (0, import_node_fs11.statSync)(transcriptPath).size;
+    size = (0, import_node_fs13.statSync)(transcriptPath).size;
   } catch {
     return null;
   }
   if (size === 0) return null;
   let raw;
   if (size <= SMALL_FILE_BYTES) {
-    raw = (0, import_node_fs11.readFileSync)(transcriptPath, "utf-8");
+    raw = (0, import_node_fs13.readFileSync)(transcriptPath, "utf-8");
   } else {
     const buf = Buffer.alloc(Math.min(MAX_READ_BYTES, size));
     const fd = require("node:fs").openSync(transcriptPath, "r");
@@ -12502,6 +12651,33 @@ async function runAnalyze(opts, globals) {
   if (!urlResult.ok) {
     passAndExit("Not configured yet \u2014 run /gate-setup in Claude Code to enable quality gates.");
   }
+  const sessionIdForMemory = process.env.CLAUDE_SESSION_ID ?? "";
+  let contextFilePaths = [];
+  try {
+    const memoryPath2 = sessionIdForMemory ? `/memory?session_id=${encodeURIComponent(sessionIdForMemory)}` : "/memory";
+    const memoryResult = await apiRequest({
+      method: "GET",
+      path: memoryPath2,
+      serviceUrl: urlResult.data,
+      token: tokenResult.data.token,
+      verbose: globals.verbose,
+      timeout: 1e4,
+      cmd: "analyze_context"
+    });
+    if (memoryResult.ok && Array.isArray(memoryResult.data.context_files)) {
+      contextFilePaths = memoryResult.data.context_files;
+    }
+  } catch {
+    logEvent("memory_fetch_failed", { reason: "exception" });
+  }
+  const contextFiles = gatherContextFiles(contextFilePaths, codeDelta.files);
+  for (const f of codeDelta.files) {
+    f.role = "delta";
+  }
+  for (const cf of contextFiles) {
+    codeDelta.files.push(cf);
+  }
+  pruneStaleCache();
   const requestBody = {
     static_results: staticResults,
     code_delta: codeDelta,
@@ -12596,6 +12772,26 @@ async function runAnalyze(opts, globals) {
   }
   const response = result.data;
   const decision = response.gate_decision ?? "PASS";
+  const metadata = response.metadata ?? {};
+  const intentAmbiguity = metadata.intent_ambiguity;
+  if (intentAmbiguity != null && intentAmbiguity > 5) {
+    const taskInfo = response.task ?? {};
+    if (intentAmbiguity > 7) {
+      process.stderr.write(`${YELLOW}\u26A0 Vague prompt (${intentAmbiguity}/10) \u2014 Analysis will proceed but findings may not match your intent.${NC}
+`);
+    } else {
+      process.stderr.write(`${YELLOW}\u26A0 Ambiguous prompt (${intentAmbiguity}/10) \u2014 Consider being more specific about what to change and where.${NC}
+`);
+    }
+  }
+  const taskMeta = response.task ?? {};
+  if (taskMeta.label) {
+    const taskLabel = taskMeta.label;
+    const isNew = taskMeta.is_new ?? false;
+    const prefix = isNew ? `${BOLD}\u25B6 NEW${NC} ` : "";
+    process.stderr.write(`${DIM}Task: ${prefix}${taskLabel}${NC}
+`);
+  }
   saveSnapshots(codeDelta.files.map((f) => ({ path: f.path, content: f.content })));
   switch (decision) {
     case "FAIL": {
@@ -12700,7 +12896,7 @@ async function runAnalyze(opts, globals) {
 }
 
 // src/commands/review.ts
-var import_node_fs12 = require("node:fs");
+var import_node_fs14 = 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();
@@ -12719,7 +12915,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_fs12.existsSync)(f) || resolveFile(f) !== null);
+    const scannable = Array.from(/* @__PURE__ */ new Set([...analyzable, ...securityFiles])).filter((f) => (0, import_node_fs14.existsSync)(f) || resolveFile(f) !== null);
     staticResults = runCodacyAnalysis(scannable);
   } else {
     staticResults = {
@@ -12744,10 +12940,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_fs12.existsSync)(p)) continue;
+      if (!(0, import_node_fs14.existsSync)(p)) continue;
       try {
-        const { readFileSync: readFileSync6 } = await import("node:fs");
-        const content = readFileSync6(p, "utf-8");
+        const { readFileSync: readFileSync8 } = await import("node:fs");
+        const content = readFileSync8(p, "utf-8");
         specs.push({ path: p, content: content.slice(0, 10240) });
       } catch {
       }
@@ -12805,21 +13001,21 @@ async function runReview(opts, globals) {
 }
 
 // src/commands/init.ts
-var import_node_fs13 = require("node:fs");
+var import_node_fs15 = require("node:fs");
 var import_promises8 = require("node:fs/promises");
-var import_node_path8 = require("node:path");
+var import_node_path9 = require("node:path");
 var import_node_child_process8 = require("node:child_process");
 function resolveDataDir() {
   const candidates = [
-    (0, import_node_path8.join)(__dirname, "..", "data"),
+    (0, import_node_path9.join)(__dirname, "..", "data"),
     // installed: node_modules/@codacy/gate-cli/data
-    (0, import_node_path8.join)(__dirname, "..", "..", "data"),
+    (0, import_node_path9.join)(__dirname, "..", "..", "data"),
     // edge case: nested resolution
-    (0, import_node_path8.join)(process.cwd(), "cli", "data")
+    (0, import_node_path9.join)(process.cwd(), "cli", "data")
     // local dev: running from repo root
   ];
   for (const candidate of candidates) {
-    if ((0, import_node_fs13.existsSync)((0, import_node_path8.join)(candidate, "skills"))) {
+    if ((0, import_node_fs15.existsSync)((0, import_node_path9.join)(candidate, "skills"))) {
       return candidate;
     }
   }
@@ -12835,7 +13031,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_fs13.existsSync)(m));
+    const isProject = projectMarkers.some((m) => (0, import_node_fs15.existsSync)(m));
     if (!isProject) {
       printError("No project detected in the current directory.");
       printInfo('Run "gate init" from your project root.');
@@ -12888,21 +13084,21 @@ function registerInitCommand(program2) {
     console.log("");
     printInfo("Installing skills...");
     const dataDir = resolveDataDir();
-    const skillsSource = (0, import_node_path8.join)(dataDir, "skills");
+    const skillsSource = (0, import_node_path9.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_path8.join)(skillsSource, skill);
-      const dest = (0, import_node_path8.join)(skillsDest, skill);
-      if (!(0, import_node_fs13.existsSync)(src)) {
+      const src = (0, import_node_path9.join)(skillsSource, skill);
+      const dest = (0, import_node_path9.join)(skillsDest, skill);
+      if (!(0, import_node_fs15.existsSync)(src)) {
         printWarn(`  Skill data not found: ${skill}`);
         continue;
       }
-      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_fs13.existsSync)(destSkill)) {
+      if ((0, import_node_fs15.existsSync)(dest) && !force) {
+        const srcSkill = (0, import_node_path9.join)(src, "SKILL.md");
+        const destSkill = (0, import_node_path9.join)(dest, "SKILL.md");
+        if ((0, import_node_fs15.existsSync)(destSkill)) {
           try {
             const srcContent = await (0, import_promises8.readFile)(srcSkill, "utf-8");
             const destContent = await (0, import_promises8.readFile)(destSkill, "utf-8");
@@ -12930,7 +13126,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_path8.join)(process.env.HOME ?? "", ".gate");
+    const globalGateDir = (0, import_node_path9.join)(process.env.HOME ?? "", ".gate");
     await (0, import_promises8.mkdir)(globalGateDir, { recursive: true });
     console.log("");
     printInfo("GATE.md initialized!");
@@ -12947,8 +13143,245 @@ function registerInitCommand(program2) {
   });
 }
 
+// src/commands/task.ts
+function memoryPath() {
+  const sid = process.env.CLAUDE_SESSION_ID;
+  return sid ? `/memory?session_id=${encodeURIComponent(sid)}` : "/memory";
+}
+function timeAgo2(isoDate) {
+  const ms = Date.now() - new Date(isoDate).getTime();
+  const mins = Math.floor(ms / 6e4);
+  if (mins < 1) return "just now";
+  if (mins < 60) return `${mins}m ago`;
+  const hrs = Math.floor(mins / 60);
+  if (hrs < 24) return `${hrs}h ago`;
+  return `${Math.floor(hrs / 24)}d ago`;
+}
+async function getAuth(globals) {
+  const tokenResult = await resolveToken(globals.token);
+  if (!tokenResult.ok) {
+    printError(tokenResult.error);
+    process.exit(1);
+  }
+  const urlResult = await resolveServiceUrl(globals.serviceUrl);
+  if (!urlResult.ok) {
+    printError(urlResult.error);
+    process.exit(1);
+  }
+  return { token: tokenResult.data.token, serviceUrl: urlResult.data };
+}
+function registerTaskCommands(program2) {
+  const task = program2.command("task").description("Manage tasks");
+  task.command("list").description("List tasks").option("--status <status>", "Filter by status (active, closed, merged)").action(async (opts) => {
+    const globals = program2.opts();
+    const { token, serviceUrl } = await getAuth(globals);
+    const statusParam = opts.status ? `?status=${opts.status}` : "";
+    const result = await apiRequest({
+      method: "GET",
+      path: `/tasks${statusParam}`,
+      serviceUrl,
+      token,
+      verbose: globals.verbose,
+      cmd: "task_list"
+    });
+    if (!result.ok) {
+      printError(result.error);
+      process.exit(1);
+    }
+    const tasks = result.data.tasks;
+    if (tasks.length === 0) {
+      printInfo("No tasks found.");
+      return;
+    }
+    printInfo("Tasks:");
+    for (const t of tasks) {
+      const status = t.status ?? "active";
+      const statusTag = status !== "active" ? ` [${status}]` : "";
+      const runs = t.run_count;
+      const ago = t.last_run_at ? timeAgo2(t.last_run_at) : "";
+      const detail = runs != null ? `${runs} run${runs === 1 ? "" : "s"}${ago ? ", " + ago : ""}` : "";
+      printInfo(`  ${t.label}${statusTag}${detail ? "  (" + detail + ")" : ""}`);
+    }
+  });
+  task.command("close").description("Close the current task (next run starts a new task)").option("--id <taskId>", "Close a specific task by ID").action(async (opts) => {
+    const globals = program2.opts();
+    const { token, serviceUrl } = await getAuth(globals);
+    let taskId = opts.id;
+    if (!taskId) {
+      const mem = await apiRequest({
+        method: "GET",
+        path: memoryPath(),
+        serviceUrl,
+        token,
+        verbose: globals.verbose,
+        cmd: "task_close_lookup"
+      });
+      if (!mem.ok) {
+        printError(mem.error);
+        process.exit(1);
+      }
+      const ct = mem.data.current_task;
+      if (!ct?.id) {
+        printError("No active task to close.");
+        process.exit(1);
+      }
+      taskId = ct.id;
+    }
+    const result = await apiRequest({
+      method: "POST",
+      path: `/tasks/${taskId}/close`,
+      serviceUrl,
+      token,
+      verbose: globals.verbose,
+      cmd: "task_close"
+    });
+    if (!result.ok) {
+      printError(result.error);
+      process.exit(1);
+    }
+    printInfo(`Closed task: "${result.data.task.label}"`);
+  });
+  task.command("rename <label>").description("Rename the current task").option("--id <taskId>", "Rename a specific task by ID").action(async (label, opts) => {
+    const globals = program2.opts();
+    const { token, serviceUrl } = await getAuth(globals);
+    let taskId = opts.id;
+    if (!taskId) {
+      const mem = await apiRequest({
+        method: "GET",
+        path: memoryPath(),
+        serviceUrl,
+        token,
+        verbose: globals.verbose,
+        cmd: "task_rename_lookup"
+      });
+      if (!mem.ok) {
+        printError(mem.error);
+        process.exit(1);
+      }
+      const ct = mem.data.current_task;
+      if (!ct?.id) {
+        printError("No active task to rename.");
+        process.exit(1);
+      }
+      taskId = ct.id;
+    }
+    const result = await apiRequest({
+      method: "POST",
+      path: `/tasks/${taskId}/rename`,
+      serviceUrl,
+      token,
+      body: { label: label.slice(0, 120) },
+      verbose: globals.verbose,
+      cmd: "task_rename"
+    });
+    if (!result.ok) {
+      printError(result.error);
+      process.exit(1);
+    }
+    printInfo(`Renamed task to: "${result.data.task.label}"`);
+  });
+  task.command("merge <source> <target>").description("Merge source task into target task").action(async (source, target) => {
+    const globals = program2.opts();
+    const { token, serviceUrl } = await getAuth(globals);
+    const result = await apiRequest({
+      method: "POST",
+      path: "/tasks/merge",
+      serviceUrl,
+      token,
+      body: { source_id: source, target_id: target },
+      verbose: globals.verbose,
+      cmd: "task_merge"
+    });
+    if (!result.ok) {
+      printError(result.error);
+      process.exit(1);
+    }
+    printInfo(`Merged task ${source} into ${target}`);
+  });
+}
+
+// src/commands/reset.ts
+var import_node_fs16 = require("node:fs");
+var import_node_path10 = require("node:path");
+function registerResetCommand(program2) {
+  program2.command("reset").description("Close the current task and clear transient state").option("--keep-task", "Only purge caches; leave the current task open").option("--all", "Also purge diagnostic logs (.gate/.logs/)").action(async (opts) => {
+    const globals = program2.opts();
+    if (!opts.keepTask) {
+      try {
+        const tokenResult = await resolveToken(globals.token);
+        const urlResult = await resolveServiceUrl(globals.serviceUrl);
+        if (tokenResult.ok && urlResult.ok) {
+          const mem = await apiRequest({
+            method: "GET",
+            path: process.env.CLAUDE_SESSION_ID ? `/memory?session_id=${encodeURIComponent(process.env.CLAUDE_SESSION_ID)}` : "/memory",
+            serviceUrl: urlResult.data,
+            token: tokenResult.data.token,
+            timeout: 1e4,
+            cmd: "reset_lookup"
+          });
+          const ct = mem.ok ? mem.data.current_task : null;
+          if (ct?.id) {
+            const closeResult = await apiRequest({
+              method: "POST",
+              path: `/tasks/${ct.id}/close`,
+              serviceUrl: urlResult.data,
+              token: tokenResult.data.token,
+              timeout: 1e4,
+              cmd: "reset_close"
+            });
+            if (closeResult.ok) {
+              printInfo(`Closed task: "${ct.label}"`);
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    const cacheDir = projectPath(CACHE_DIR);
+    let purged = 0;
+    if ((0, import_node_fs16.existsSync)(cacheDir)) {
+      for (const entry of (0, import_node_fs16.readdirSync)(cacheDir)) {
+        if (entry.startsWith("pending-")) {
+          try {
+            (0, import_node_fs16.unlinkSync)((0, import_node_path10.join)(cacheDir, entry));
+            purged++;
+          } catch {
+          }
+        }
+      }
+    }
+    const filesToClear = [
+      projectPath(INTENT_FILE),
+      projectPath(HASH_FILE),
+      projectPath(`${GATE_DIR}/.iteration-count`),
+      projectPath(`${GATE_DIR}/.last-analysis`)
+    ];
+    for (const file of filesToClear) {
+      if ((0, import_node_fs16.existsSync)(file)) {
+        try {
+          (0, import_node_fs16.writeFileSync)(file, "");
+        } catch {
+        }
+      }
+    }
+    if (opts.all) {
+      const logsDir = projectPath(`${GATE_DIR}/.logs`);
+      if ((0, import_node_fs16.existsSync)(logsDir)) {
+        for (const entry of (0, import_node_fs16.readdirSync)(logsDir)) {
+          try {
+            (0, import_node_fs16.unlinkSync)((0, import_node_path10.join)(logsDir, entry));
+          } catch {
+          }
+        }
+      }
+      printInfo("Cleared diagnostic logs.");
+    }
+    printInfo(`Reset complete. Purged ${purged} cached request${purged !== 1 ? "s" : ""}.${opts.keepTask ? "" : " Next run starts a new task."}`);
+  });
+}
+
 // src/cli.ts
-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");
+program.name("gate").description("CLI for GATE.md quality gate service").version("0.15.0").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);
@@ -12959,4 +13392,6 @@ registerFeedbackCommand(program);
 registerAnalyzeCommand(program);
 registerReviewCommand(program);
 registerInitCommand(program);
+registerTaskCommands(program);
+registerResetCommand(program);
 program.parse();

package/package.json

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