@menteeai/menteeswe 0.1.19 → 0.1.21

package/dist/cli.js

@@ -751,39 +751,93 @@ function recentFile(cwd) {
   const hash = crypto3.createHash("sha1").update(cwd).digest("hex").slice(0, 16);
   return path8.join(sessionsDir(), `${hash}.files.json`);
 }
-function saveRecentFiles(cwd, reads, writes) {
-  try {
-    let prev = { reads: [], writes: [] };
-    try {
-      const parsed = JSON.parse(fs9.readFileSync(recentFile(cwd), "utf8"));
-      if (parsed && Array.isArray(parsed.reads) && Array.isArray(parsed.writes)) prev = parsed;
-    } catch {
+function fileHash(content) {
+  return crypto3.createHash("sha1").update(content).digest("hex").slice(0, 12);
+}
+function normalizeRecords(value) {
+  if (!Array.isArray(value)) return [];
+  const out = [];
+  for (const item of value) {
+    if (typeof item === "string") out.push({ path: item });
+    else if (item && typeof item === "object" && typeof item.path === "string") {
+      out.push(item);
     }
-    const merge = (known, fresh) => [.../* @__PURE__ */ new Set([...fresh, ...known])].slice(0, 15);
-    fs9.writeFileSync(
-      recentFile(cwd),
-      JSON.stringify({ reads: merge(prev.reads, reads), writes: merge(prev.writes, writes) }, null, 2)
-    );
-  } catch {
   }
+  return out;
 }
-function formatRecentFiles(cwd) {
+function loadRecentFiles(cwd) {
   try {
     const parsed = JSON.parse(fs9.readFileSync(recentFile(cwd), "utf8"));
-    const writes = (parsed.writes ?? []).slice(0, 10);
-    const reads = (parsed.reads ?? []).filter((f) => !writes.includes(f)).slice(0, 10);
-    if (reads.length === 0 && writes.length === 0) return "";
-    const lines = ["# Known files from earlier tasks in this project"];
-    if (writes.length > 0) lines.push(`Modified recently: ${writes.join(", ")}`);
-    if (reads.length > 0) lines.push(`Read recently: ${reads.join(", ")}`);
-    lines.push(
-      "Reuse this knowledge \u2014 do not re-search or re-read these files unless you suspect they changed. If you read a file earlier and it is unchanged, you may apply_patch directly."
+    return { reads: normalizeRecords(parsed.reads), writes: normalizeRecords(parsed.writes) };
+  } catch {
+    return { reads: [], writes: [] };
+  }
+}
+function saveRecentFiles(cwd, reads, writes, hashes) {
+  try {
+    const prev = loadRecentFiles(cwd);
+    const absHash = (rel) => hashes?.get(path8.resolve(cwd, rel));
+    const merge = (known, fresh) => {
+      const byPath = /* @__PURE__ */ new Map();
+      for (const rel of fresh) {
+        byPath.set(rel, { path: rel, hash: absHash(rel) });
+      }
+      for (const rec of known) {
+        if (!byPath.has(rec.path)) byPath.set(rec.path, rec);
+      }
+      return [...byPath.values()].slice(0, 15);
+    };
+    fs9.writeFileSync(
+      recentFile(cwd),
+      JSON.stringify({ reads: merge(prev.reads, reads), writes: merge(prev.writes, writes) }, null, 2)
     );
-    return lines.join("\n");
   } catch {
-    return "";
   }
 }
+function formatRecentFiles(cwd, prewarm) {
+  const stored = loadRecentFiles(cwd);
+  if (stored.reads.length === 0 && stored.writes.length === 0) return "";
+  const verify = (records) => {
+    const unchanged = [];
+    const changed = [];
+    const legacy = [];
+    for (const rec of records.slice(0, 15)) {
+      if (!rec.hash) {
+        legacy.push(rec);
+        continue;
+      }
+      try {
+        const content = fs9.readFileSync(path8.resolve(cwd, rec.path), "utf8");
+        const current = fileHash(content);
+        if (current === rec.hash) {
+          unchanged.push(rec);
+          prewarm?.set(path8.resolve(cwd, rec.path), current);
+        } else {
+          changed.push(rec);
+        }
+      } catch {
+        changed.push(rec);
+      }
+    }
+    return { unchanged, changed, legacy };
+  };
+  const w = verify(stored.writes);
+  const writePaths = new Set(stored.writes.map((r2) => r2.path));
+  const r = verify(stored.reads.filter((rec) => !writePaths.has(rec.path)));
+  const lines = ["# Known files from earlier tasks in this project"];
+  const join = (list) => list.map((rec) => rec.path).join(", ");
+  if (w.unchanged.length > 0) lines.push(`Modified recently, verified unchanged on disk: ${join(w.unchanged)}`);
+  if (r.unchanged.length > 0) lines.push(`Read recently, verified unchanged on disk: ${join(r.unchanged)}`);
+  const stale = [...w.changed, ...r.changed];
+  if (stale.length > 0) lines.push(`Changed (or missing) on disk since then \u2014 re-read before editing: ${join(stale)}`);
+  for (const rec of [...w.legacy, ...r.legacy]) {
+    lines.push(`Known from earlier tasks (state unknown): ${rec.path}`);
+  }
+  lines.push(
+    "For files verified unchanged you may apply_patch directly without re-reading; the harness validates the hash and will tell you if the file changed. Do not re-search or re-read verified files unless needed."
+  );
+  return lines.join("\n");
+}
 var init_conversation = __esm({
   "src/agent/conversation.ts"() {
     "use strict";
@@ -843,13 +897,15 @@ function isRateLimitError(error) {
   }
   return /\b429\b|max rpm|rate limit|too many requests/i.test(error.message);
 }
-async function generateWithRetry(provider, model, system, messages, tools, bus, onToken) {
+async function generateWithRetry(provider, model, system, messages, tools, bus, onToken, signal) {
   let lastError = null;
   for (let attempt = 0; attempt <= RATE_LIMIT_MAX_ATTEMPTS; attempt++) {
+    if (signal?.aborted) throw new Error("Aborted by user");
     try {
-      return await provider.generate({ system, messages, tools: tools.schemas(), onToken }, model);
+      return await provider.generate({ system, messages, tools: tools.schemas(), onToken, signal }, model);
     } catch (error) {
       lastError = error;
+      if (signal?.aborted) throw lastError;
       if (attempt >= RATE_LIMIT_MAX_ATTEMPTS || !isRateLimitError(lastError)) {
         throw lastError;
       }
@@ -935,8 +991,9 @@ async function runAgent(options) {
     signal
   } = options;
   const state = createAgentState(task, maxIterations);
+  const fileState = /* @__PURE__ */ new Map();
   const prior = formatConversationContext(cwd);
-  const knownFiles = formatRecentFiles(cwd);
+  const knownFiles = formatRecentFiles(cwd, fileState);
   const system = buildSystemPrompt(cwd) + (knownFiles ? `
 
 ${knownFiles}` : "") + (prior ? `
@@ -951,7 +1008,7 @@ ${systemExtra}` : "");
   const toolCtx = {
     cwd,
     approval,
-    fileState: /* @__PURE__ */ new Map(),
+    fileState,
     emit: (type, message, data) => {
       bus.emit(type, message, data);
     }
@@ -990,9 +1047,13 @@ ${systemExtra}` : "");
     };
     let response;
     try {
-      response = await generateWithRetry(provider, model, system, messages, tools, bus, onToken);
+      response = await generateWithRetry(provider, model, system, messages, tools, bus, onToken, signal);
     } catch (error) {
       flushThink();
+      if (signal?.aborted) {
+        finalText = "Task cancelled.";
+        break;
+      }
       const message = error.message;
       let hint = "";
       if (/insufficient balance|no resource package|recharge/i.test(message)) {
@@ -1003,7 +1064,7 @@ ${systemExtra}` : "");
       bus.emit("error", message + hint);
       finalText = `Model request failed: ${message}`;
       appendTurn(cwd, task, finalText);
-      saveRecentFiles(cwd, state.readFiles, state.modifiedFiles);
+      saveRecentFiles(cwd, state.readFiles, state.modifiedFiles, fileState);
       bus.emit("task_completed", finalText.slice(0, 400), {
         success: false,
         finalText,
@@ -1076,6 +1137,7 @@ Investigate the root cause, fix it, then finish with a final answer.`
       bus.emit("info", response.content.trim().slice(0, 300));
     }
     for (const call of response.toolCalls) {
+      if (signal?.aborted) break;
       const tool = tools.get(call.function.name);
       if (!tool) {
         messages.push({
@@ -1208,7 +1270,7 @@ Investigate the root cause, fix it, then finish with a final answer.`
   const success = sawFinish && state.errors.length === 0;
   if (finalText && !signal?.aborted) {
     appendTurn(cwd, task, finalText);
-    saveRecentFiles(cwd, state.readFiles, state.modifiedFiles);
+    saveRecentFiles(cwd, state.readFiles, state.modifiedFiles, fileState);
   }
   bus.emit("task_completed", finalText.slice(0, 400), {
     success,
@@ -1244,7 +1306,7 @@ var init_loop = __esm({
 var version;
 var init_package = __esm({
   "package.json"() {
-    version = "0.1.19";
+    version = "0.1.21";
   }
 });
 
@@ -2197,16 +2259,20 @@ var OpenAICompatProvider = class {
       ...request.temperature !== void 0 ? { temperature: request.temperature } : {},
       ...request.maxTokens ? { max_tokens: request.maxTokens } : {}
     };
+    const reqOptions = request.signal ? { signal: request.signal } : void 0;
     if (!request.onToken) {
-      const response2 = await this.client.chat.completions.create(baseParams);
+      const response2 = await this.client.chat.completions.create(baseParams, reqOptions);
       return parseResponse(response2);
     }
     const streamOnce = async (withUsage) => {
-      const stream = await this.client.chat.completions.create({
-        ...baseParams,
-        stream: true,
-        ...withUsage ? { stream_options: { include_usage: true } } : {}
-      });
+      const stream = await this.client.chat.completions.create(
+        {
+          ...baseParams,
+          stream: true,
+          ...withUsage ? { stream_options: { include_usage: true } } : {}
+        },
+        reqOptions
+      );
       let content = "";
       let finishReason = "stop";
       let usage;
@@ -2257,7 +2323,7 @@ var OpenAICompatProvider = class {
       } catch {
       }
     }
-    const response = await this.client.chat.completions.create(baseParams);
+    const response = await this.client.chat.completions.create(baseParams, reqOptions);
     const parsed = parseResponse(response);
     if (parsed.content) {
       for (let i = 0; i < parsed.content.length; i += 3) {
@@ -3838,7 +3904,8 @@ program.argument("[task...]", "the software task to perform (omit to type it int
         yes: options.yes === true,
         maxIterations
       }
-    )
+    ),
+    { exitOnCtrlC: false }
   );
   await waitUntilExit();
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@menteeai/menteeswe",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "description": "MenteE SWE — a model-agnostic autonomous software-engineering agent CLI. Bring your own intelligence: Kimi, GLM/Z.ai, and more.",
   "type": "module",
   "license": "MIT",