@blockrun/runcode 2.5.7 → 2.5.8

package/dist/agent/context.d.ts

@@ -4,5 +4,8 @@
  */
 /**
  * Build the full system instructions array for a session.
+ * Result is memoized per workingDir for the process lifetime.
  */
 export declare function assembleInstructions(workingDir: string): string[];
+/** Invalidate cache for a workingDir (call after /clear or session reset). */
+export declare function invalidateInstructionCache(workingDir: string): void;

package/dist/agent/context.js

@@ -53,10 +53,17 @@ The user can type these shortcuts: /commit, /review, /test, /fix, /debug, /expla
 /log, /branch, /stash, /plan, /ultraplan, /execute, /compact, /retry, /sessions, /resume,
 /tasks, /context, /doctor, /tokens, /model, /cost, /dump, /ultrathink [query], /clear,
 /help, /exit.`;
+// Cache assembled instructions per workingDir — avoids re-running git commands
+// when sub-agents are spawned (common in parallel tool use patterns).
+const _instructionCache = new Map();
 /**
  * Build the full system instructions array for a session.
+ * Result is memoized per workingDir for the process lifetime.
  */
 export function assembleInstructions(workingDir) {
+    const cached = _instructionCache.get(workingDir);
+    if (cached)
+        return cached;
     const parts = [BASE_INSTRUCTIONS];
     // Read RUNCODE.md or CLAUDE.md from the project
     const projectConfig = readProjectConfig(workingDir);
@@ -70,8 +77,13 @@ export function assembleInstructions(workingDir) {
     if (gitInfo) {
         parts.push(`# Git Context\n\n${gitInfo}`);
     }
+    _instructionCache.set(workingDir, parts);
     return parts;
 }
+/** Invalidate cache for a workingDir (call after /clear or session reset). */
+export function invalidateInstructionCache(workingDir) {
+    _instructionCache.delete(workingDir);
+}
 // ─── Project Config ────────────────────────────────────────────────────────
 /**
  * Look for RUNCODE.md, then CLAUDE.md in the working directory and parents.
@@ -114,6 +126,8 @@ function buildEnvironmentSection(workingDir) {
 }
 // ─── Git Context ───────────────────────────────────────────────────────────
 const GIT_TIMEOUT_MS = 5_000;
+// Max chars for git log output — long commit messages can bloat the system prompt
+const MAX_GIT_LOG_CHARS = 2_000;
 function getGitContext(workingDir) {
     try {
         const isGit = execSync('git rev-parse --is-inside-work-tree', {
@@ -154,15 +168,18 @@ function getGitContext(workingDir) {
             }
         }
         catch { /* ignore */ }
-        // Recent commits (last 5)
+        // Recent commits (last 5) — capped to prevent huge messages bloating context
         try {
-            const log = execSync('git log --oneline -5', {
+            let log = execSync('git log --oneline -5', {
                 cwd: workingDir,
                 encoding: 'utf-8',
                 stdio: ['pipe', 'pipe', 'pipe'],
                 timeout: GIT_TIMEOUT_MS,
             }).trim();
             if (log) {
+                if (log.length > MAX_GIT_LOG_CHARS) {
+                    log = log.slice(0, MAX_GIT_LOG_CHARS) + '\n... (truncated)';
+                }
                 lines.push(`\nRecent commits:\n${log}`);
             }
         }

package/dist/tools/edit.js

@@ -3,6 +3,16 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
+import { partiallyReadFiles } from './read.js';
+/**
+ * Normalize curly/smart quotes to straight quotes.
+ * Claude Code does this to handle API-sanitized strings and editor paste artifacts.
+ */
+function normalizeQuotes(str) {
+    return str
+        .replace(/[\u201C\u201D]/g, '"') // " " → "
+        .replace(/[\u2018\u2019]/g, "'"); // ' ' → '
+}
 async function execute(input, ctx) {
     const { file_path: filePath, old_string: oldStr, new_string: newStr, replace_all: replaceAll } = input;
     if (!filePath) {
@@ -18,12 +28,25 @@ async function execute(input, ctx) {
         return { output: 'Error: old_string and new_string are identical', isError: true };
     }
     const resolved = path.isAbsolute(filePath) ? filePath : path.resolve(ctx.workingDir, filePath);
+    // Warn if the file was only partially read — editing without full context risks mistakes
+    const isPartial = partiallyReadFiles.has(resolved);
     try {
         if (!fs.existsSync(resolved)) {
             return { output: `Error: file not found: ${resolved}`, isError: true };
         }
         const content = fs.readFileSync(resolved, 'utf-8');
+        // Try exact match first, then quote-normalized fallback
+        let effectiveOldStr = oldStr;
         if (!content.includes(oldStr)) {
+            const normalized = normalizeQuotes(oldStr);
+            const contentNormalized = normalizeQuotes(content);
+            if (normalized !== oldStr && contentNormalized.includes(normalized)) {
+                // Find the original text in content that corresponds to the normalized match
+                const idx = contentNormalized.indexOf(normalized);
+                effectiveOldStr = content.slice(idx, idx + normalized.length);
+            }
+        }
+        if (!content.includes(effectiveOldStr)) {
             // Find lines containing fragments of old_string for helpful context
             const lines = content.split('\n');
             const searchTerms = oldStr.split('\n').map(l => l.trim()).filter(l => l.length > 3);
@@ -52,20 +75,17 @@ async function execute(input, ctx) {
         let updated;
         let matchCount;
         if (replaceAll) {
-            // Count occurrences
-            matchCount = content.split(oldStr).length - 1;
-            updated = content.split(oldStr).join(newStr);
+            matchCount = content.split(effectiveOldStr).length - 1;
+            updated = content.split(effectiveOldStr).join(newStr);
         }
         else {
-            // Ensure uniqueness for single replacement
-            const firstIdx = content.indexOf(oldStr);
-            const secondIdx = content.indexOf(oldStr, firstIdx + 1);
+            const firstIdx = content.indexOf(effectiveOldStr);
+            const secondIdx = content.indexOf(effectiveOldStr, firstIdx + 1);
             if (secondIdx !== -1) {
-                // Multiple matches — show where they are
                 const positions = [];
                 let searchFrom = 0;
                 while (true) {
-                    const idx = content.indexOf(oldStr, searchFrom);
+                    const idx = content.indexOf(effectiveOldStr, searchFrom);
                     if (idx === -1)
                         break;
                     const lineNum = content.slice(0, idx).split('\n').length;
@@ -79,11 +99,13 @@ async function execute(input, ctx) {
                 };
             }
             matchCount = 1;
-            updated = content.slice(0, firstIdx) + newStr + content.slice(firstIdx + oldStr.length);
+            updated = content.slice(0, firstIdx) + newStr + content.slice(firstIdx + effectiveOldStr.length);
         }
         fs.writeFileSync(resolved, updated, 'utf-8');
+        // File has been modified — remove from partial-read tracking so next read is fresh
+        partiallyReadFiles.delete(resolved);
         // Build a concise diff preview
-        const oldLines = oldStr.split('\n');
+        const oldLines = effectiveOldStr.split('\n');
         const newLines = newStr.split('\n');
         let diffPreview = '';
         if (oldLines.length <= 5 && newLines.length <= 5) {
@@ -94,8 +116,11 @@ async function execute(input, ctx) {
         else {
             diffPreview = ` (${oldLines.length} lines → ${newLines.length} lines)`;
         }
+        const partialWarning = isPartial
+            ? '\nNote: file was only partially read before this edit.'
+            : '';
         return {
-            output: `Updated ${resolved} — ${matchCount} replacement${matchCount > 1 ? 's' : ''} made.${diffPreview}`,
+            output: `Updated ${resolved} — ${matchCount} replacement${matchCount > 1 ? 's' : ''} made.${diffPreview}${partialWarning}`,
         };
     }
     catch (err) {

package/dist/tools/read.d.ts

@@ -2,4 +2,10 @@
  * Read capability — reads files with line numbers.
  */
 import type { CapabilityHandler } from '../agent/types.js';
+/**
+ * Tracks files that were only partially read (offset or limit applied).
+ * Edit tool uses this to warn when editing without full context.
+ * Exported so edit.ts can check and clear entries.
+ */
+export declare const partiallyReadFiles: Set<string>;
 export declare const readCapability: CapabilityHandler;

package/dist/tools/read.js

@@ -3,6 +3,12 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
+/**
+ * Tracks files that were only partially read (offset or limit applied).
+ * Edit tool uses this to warn when editing without full context.
+ * Exported so edit.ts can check and clear entries.
+ */
+export const partiallyReadFiles = new Set();
 async function execute(input, ctx) {
     const { file_path: filePath, offset, limit } = input;
     if (!filePath) {
@@ -37,6 +43,15 @@ async function execute(input, ctx) {
         const maxLines = limit ?? 2000;
         const endLine = Math.min(allLines.length, startLine + maxLines);
         const slice = allLines.slice(startLine, endLine);
+        // Track partial reads — file was not read from the beginning or was truncated
+        const isPartial = startLine > 0 || endLine < allLines.length;
+        if (isPartial) {
+            partiallyReadFiles.add(resolved);
+        }
+        else {
+            // Full read — clear any stale partial flag
+            partiallyReadFiles.delete(resolved);
+        }
         // Format with line numbers (cat -n style)
         const numbered = slice.map((line, i) => `${startLine + i + 1}\t${line}`);
         let result = numbered.join('\n');

package/dist/tools/webfetch.js

@@ -3,6 +3,32 @@
  */
 import { VERSION } from '../config.js';
 const MAX_BODY_BYTES = 256 * 1024; // 256KB
+// ─── Session cache ──────────────────────────────────────────────────────────
+// Avoids re-fetching the same URL within a session (common in research tasks).
+// 15-min TTL, max 50 entries.
+const CACHE_TTL_MS = 15 * 60 * 1000;
+const MAX_CACHE_ENTRIES = 50;
+const fetchCache = new Map();
+function getCached(url) {
+    const entry = fetchCache.get(url);
+    if (!entry)
+        return null;
+    if (Date.now() > entry.expiresAt) {
+        fetchCache.delete(url);
+        return null;
+    }
+    return entry.output;
+}
+function setCached(url, output) {
+    // Evict oldest entry if at capacity
+    if (fetchCache.size >= MAX_CACHE_ENTRIES) {
+        const firstKey = fetchCache.keys().next().value;
+        if (firstKey)
+            fetchCache.delete(firstKey);
+    }
+    fetchCache.set(url, { output, expiresAt: Date.now() + CACHE_TTL_MS });
+}
+// ─── Execute ────────────────────────────────────────────────────────────────
 async function execute(input, _ctx) {
     const { url, max_length } = input;
     if (!url) {
@@ -19,6 +45,11 @@ async function execute(input, _ctx) {
     if (!['http:', 'https:'].includes(parsed.protocol)) {
         return { output: `Error: only http/https URLs are supported`, isError: true };
     }
+    // Check cache first
+    const cached = getCached(url);
+    if (cached) {
+        return { output: cached + '\n\n(cached)' };
+    }
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), 30_000);
     try {
@@ -62,8 +93,8 @@ async function execute(input, _ctx) {
         // Format response based on content type
         if (contentType.includes('json')) {
             try {
-                const parsed = JSON.parse(body);
-                body = JSON.stringify(parsed, null, 2).slice(0, maxLen);
+                const parsedJson = JSON.parse(body);
+                body = JSON.stringify(parsedJson, null, 2).slice(0, maxLen);
             }
             catch { /* leave as-is if not valid JSON */ }
         }
@@ -74,6 +105,8 @@ async function execute(input, _ctx) {
         if (totalBytes >= maxLen) {
             output += '\n\n... (content truncated)';
         }
+        // Cache successful responses
+        setCached(url, output);
         return { output };
     }
     catch (err) {
@@ -118,7 +151,7 @@ function stripHtml(html) {
 export const webFetchCapability = {
     spec: {
         name: 'WebFetch',
-        description: 'Fetch a web page and return its content. HTML tags are stripped for readability.',
+        description: 'Fetch a web page and return its content. HTML tags are stripped for readability. Results are cached for 15 minutes.',
         input_schema: {
             type: 'object',
             properties: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockrun/runcode",
-  "version": "2.5.7",
+  "version": "2.5.8",
   "description": "RunCode — AI coding agent powered by 41+ models. Pay per use with USDC.",
   "type": "module",
   "bin": {