@hncode/hncode 0.5.2 → 0.5.4

package/src/tools/glob.js

@@ -4,7 +4,7 @@
 
 import fs from 'node:fs';
 import path from 'node:path';
-import { normalizeInput } from './utils.js';
+import { resolvePath } from './utils.js';
 import { walkFiles } from './ignore.js';
 import { globToRegexSource, expandBraces } from './matchers.js';
 
@@ -29,9 +29,11 @@ export const spec = {
       return 'Error: `pattern` is required (e.g. "src/**/*.ts").';
     }
     const fromDir = typeof args.path === 'string' && args.path ? args.path : '.';
-    const p = normalizeInput(fromDir);
     let base;
-    try { base = path.resolve(ctx.cwd || ctx.workspace, p); } catch (e) { return `Error: ${e.message}`; }
+    // Same workspace boundary as Read/Write/Edit. Glob resolved `path` directly,
+    // so `Glob { pattern: '**', path: 'C:\\Users\\...' }` walked any directory on
+    // disk with no permission gate at all.
+    try { base = resolvePath(fromDir, ctx); } catch (e) { return `Error: ${e.message}`; }
     if (!fs.existsSync(base)) return `Error: path does not exist: ${fromDir}`;
     if (!fs.statSync(base).isDirectory()) return `Error: --path is not a directory: ${fromDir}`;
 

package/src/tools/grep.js

@@ -5,7 +5,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import cp from 'node:child_process';
-import { normalizeInput, isProbablyTextFile, truncateBuf } from './utils.js';
+import { isProbablyTextFile, truncateBuf, resolvePath } from './utils.js';
 import { walkFiles } from './ignore.js';
 import { matchGlob } from './matchers.js';
 
@@ -33,8 +33,11 @@ export const spec = {
     required: ['pattern'],
   },
   async execute(args, ctx) {
-    const p = normalizeInput(args.path || '.');
-    const base = path.resolve(ctx.cwd || ctx.workspace, p);
+    // Same workspace boundary as Read/Write/Edit. Grep resolved `path` directly,
+    // so `Grep { pattern: 'KEY', path: 'C:/Users/...' }` searched any directory
+    // on disk — the search tools had no gate at all.
+    let base;
+    try { base = resolvePath(args.path || '.', ctx); } catch (e) { return `Error: ${e.message}`; }
     if (!fs.existsSync(base)) return `Error: path does not exist: ${args.path}`;
     if (!args.multiline && hasRg()) return await grepRg(args, base, ctx);
     return grepJs(args, base, ctx);
@@ -58,7 +61,11 @@ function hasRg() {
 }
 
 function buildRgArgs(args, base) {
-  const a = ['--no-heading', '--line-number', '--no-config', '-e', args.pattern];
+  // --crlf: an end anchor (`;$`) must match a line that ends `\r\n`, exactly as
+  // it does in an LF file — and as the JS fallback already does. Without it the
+  // rg path reported "No matches found" for patterns the user could SEE ending
+  // the line, on this repo's own CRLF files.
+  const a = ['--no-heading', '--line-number', '--no-config', '--crlf', '-e', args.pattern];
   if (args['-i']) a.push('-i');
   const before = args['-B'] || (args['-C'] || 0);
   const after = args['-A'] || (args['-C'] || 0);
@@ -99,6 +106,13 @@ function grepRg(args, base, ctx) {
     child.on('error', () => done(() => resolve(grepJs(args, base, ctx))));
     child.on('close', (code) => done(() => {
       if (code > 1 && stderr) resolve(`rg error: ${stderr.trim()}`);
+      else if (!stdout.trim() && args.pattern.includes('$')) {
+        // A zero-match END-ANCHORED query may be a LONE-CR file (old-Mac endings),
+        // which rg cannot treat as line breaks at all. The JS walker handles every
+        // ending, so it gets the final word — only for `$` patterns that found
+        // nothing, so ordinary searches never pay for the extra pass.
+        resolve(grepJs(args, base, ctx));
+      }
       else resolve(paginate(stdout, args));
     }));
     // Honour an aborted turn (Esc): kill rg instead of leaving it running.
@@ -113,7 +127,7 @@ function grepRg(args, base, ctx) {
 function grepJs(args, base, ctx) {
   const flags = 'g' + (args['-i'] ? 'i' : '') + (args.multiline ? 's' : '');
   const re = new RegExp(args.pattern, flags);
-  const files = walkFiles(base, { includeIgnored: !!args.include_ignored, includeDirs: false });
+  const files = walkFiles(base, { includeIgnored: !!args.include_ignored, includeDirs: false, limit: 0 });
   const filtered = files.filter((abs) => {
     if (args.glob) {
       const rel = path.relative(base, abs).split(path.sep).join('/');

package/src/tools/ignore.js

@@ -77,17 +77,29 @@ export function matchPattern(pat, relPath, isDir) {
 // duplication, since the information was already available as each entry was
 // visited. One stat per file now, reused for both.
 export function walkFiles(base, opts = {}) {
-  const { includeIgnored = false, includeDirs = false } = opts;
+  // `limit` caps the RESULT. Glob keeps the default (newest 100); Grep passes 0 —
+  // truncating the WALK by mtime made the search silently skip older files and
+  // report "No matches found" for text that was right there.
+  const { includeIgnored = false, includeDirs = false, limit = 1000 } = opts;
   const baseAbs = path.resolve(base);
   /** @type {{path:string, mtime:number, isFile:boolean}[]} */
   const found = [];
   _walk(baseAbs, '', [], found, { includeIgnored, includeDirs });
-  // Newest first. Sort before truncating so the newest 1000 survive the cap.
+  // Newest first. Sort before truncating so the newest entries survive the cap.
   found.sort((a, b) => b.mtime - a.mtime);
-  if (found.length > 1000) found.length = 1000;
+  if (limit > 0 && found.length > limit) found.length = limit;
   return found.filter((e) => includeDirs || e.isFile).map((e) => e.path);
 }
 
+// Directories that are never worth walking. `.git` holds the object database —
+// hundreds of thousands of files on an old repo, none of them source, and no
+// .gitignore ever lists it. `node_modules` is pruned for the JS walker unless the
+// caller explicitly asked for ignored files: walking it was a multi-second stall
+// of the event loop (everything here is readdirSync/statSync) for results nobody
+// wanted.
+const PRUNED_DIRS = new Set(['.git']);
+const PRUNED_UNLESS_IGNORED = new Set(['node_modules']);
+
 function _walk(dir, relPrefix, parentPatterns, found, opts) {
   const { includeIgnored, includeDirs } = opts;
   let entries;
@@ -98,6 +110,8 @@ function _walk(dir, relPrefix, parentPatterns, found, opts) {
     const abs = path.join(dir, ent.name);
     let isDir;
     try { isDir = ent.isDirectory(); } catch { try { isDir = fs.statSync(abs).isDirectory(); } catch { isDir = false; } }
+    if (isDir && (PRUNED_DIRS.has(ent.name)
+      || (!includeIgnored && PRUNED_UNLESS_IGNORED.has(ent.name)))) continue;
     // ignore decision
     let ignored = false;
     for (const pat of acc) {

package/src/tools/index.js

@@ -16,13 +16,13 @@ import * as gitMod from './git.js';
 import * as askUserQuestionMod from './ask-user-question.js';
 import { spec as agentSpec } from './agent.js';
 import { spec as agentSwarmSpec } from './agent-swarm.js';
-import { TaskListSpec, TaskOutputSpec, TaskStopSpec, TaskWaitSpec } from './tasks.js';
+import { TaskListSpec, TaskOutputSpec, TaskStopSpec, TaskWaitSpec, TaskInputSpec } from './tasks.js';
 import { AgentListSpec, AgentMessageSpec, AgentInterruptSpec, AgentCloseSpec } from './agent-control.js';
 import { TEAM_TOOL_SPECS } from './team.js';
 import { spec as notebookSpec } from './notebook.js';
 import { spec as diagnosticsSpec } from './diagnostics.js';
 import * as memoryMod from './memory.js';
-import { pluginTools } from '../plugin.js';
+import { pluginTools, pluginToolGeneration } from '../plugin.js';
 
 
 
@@ -47,6 +47,7 @@ const builtinTools = [
   TaskOutputSpec,
   TaskStopSpec,
   TaskWaitSpec,
+  TaskInputSpec,
   AgentListSpec,
   AgentMessageSpec,
   AgentInterruptSpec,
@@ -72,11 +73,24 @@ export { builtinTools };
 // tools are resolvable. The previous Map was built from builtinTools only,
 // so `llmTools()` advertised a plugin tool to the model but `getTool(name)`
 // returned undefined and the call failed with `unknown tool`.
+//
+// The map is keyed to a REGISTRATION GENERATION: plugin.js bumps the counter
+// whenever a tool registers or the plugin set is reloaded. Without that, a
+// server connected in the background (MCP connects after first paint) stayed
+// "unknown tool" forever, and /reload served the OLD plugin instances while
+// fresh modules were imported under new spec objects.
 let _byName = null;
+let _byNameGeneration = -1;
+function toolGeneration() {
+  // Read live from plugin.js so any registration source bumps the same counter.
+  return pluginToolGeneration();
+}
 function byNameMap() {
-  if (!_byName) {
+  const gen = toolGeneration();
+  if (!_byName || _byNameGeneration !== gen) {
     _byName = new Map();
     for (const t of combinedTools()) if (!_byName.has(t.name)) _byName.set(t.name, t);
+    _byNameGeneration = gen;
   }
   return _byName;
 }

package/src/tools/read.js

@@ -64,7 +64,8 @@ export const spec = {
     if (!isProbablyTextFile(buf)) {
       return `Cannot read: ${args.path} appears to be a binary file (use a tool suited for binary).`;
     }
-    let st;
+    let st = null;
+    try { st = fs.statSync(p); } catch { /* stat is advisory only */ }
     // NO truncation: the caller asked for the file, so the whole file is returned
     // (line ranges still work via line_offset / n_lines). The old 1000-line and
     // 128 KB caps silently cut the content, which also corrupted the

package/src/tools/shell.js

@@ -1,134 +1,145 @@
-// Shell discovery for the Bash tool.
-//
-// The tool used to hardcode `spawn('pwsh', …)`, which relies on `pwsh` being on
-// PATH. On a Windows box with only the built-in Windows PowerShell that name does
-// not resolve at all, so the spawn failed with ENOENT and the whole tool was dead —
-// no fallback, and nothing in the message said why. It only ever worked where the
-// user had installed PowerShell 7 and added it to PATH by hand.
-//
-// Mirrors Claude Code's findPowerShell (src/utils/shell/powershellDetection.ts):
-// prefer pwsh (Core 7+), fall back to powershell (Desktop 5.1), and cache the
-// answer — the probe shells out, so it must not run per command.
-//
-// The EDITION matters beyond picking a binary: 7+ supports the pipeline chain
-// operators (`&&`, `||`) and 5.1 does not, so the prompt's syntax guidance depends
-// on which one was found.
-
-import cp from 'node:child_process';
-import fs from 'node:fs';
-
-// The two PowerShell families, by the name they are invoked as.
-export const SHELL_CANDIDATES = ['pwsh', 'powershell'];
-
-// Last-resort Windows fallback. A Windows box always has cmd.exe (%COMSPEC%),
-// so when neither PowerShell exists the Bash tool must still run SOMETHING
-// rather than failing outright. `cmd` is not a PowerShell, so the syntax
-// guidance and the spawn args differ (see cmdSpawnArgs).
-export function findCmdExe() {
-  const fromEnv = process.env.COMSPEC || process.env.ComSpec;
-  if (fromEnv) {
-    try { if (fs.existsSync(fromEnv)) return fromEnv; } catch { /* fall through to the PATH probe */ }
-  }
-  if (process.platform === 'win32') {
-    return whichSync('cmd') || whichSync('cmd.exe') || 'cmd.exe';
-  }
-  return null;
-}
-
-/**
- * Resolve an executable name through PATH without spawning it.
- *
- * `where` on Windows / `which` on POSIX are the platform's own resolvers, so the
- * answer matches what a shell would do. Returns the first absolute path or null.
- */
-function whichSync(name) {
-  const probe = process.platform === 'win32' ? 'where' : 'which';
-  try {
-    const out = cp.execFileSync(probe, [name], {
-      stdio: ['ignore', 'pipe', 'ignore'],
-      encoding: 'utf8',
-      windowsHide: true,
-    });
-    // `where` can print several matches; take the first non-empty line.
-    const first = String(out).split(/\r?\n/).map((l) => l.trim()).filter(Boolean)[0];
-    return first || null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Find a usable shell: pwsh, then the built-in powershell, then (on Windows)
- * cmd.exe as a last resort. Returns { path, name, edition } or null.
- *
- * `edition` drives syntax guidance — see the header. It is inferred from the NAME
- * rather than by running the binary (a spawn per probe is not worth it, and
- * PowerShell 6, also named `pwsh`, is EOL and not a realistic target, so `pwsh`
- * safely implies 7+). `edition: 'cmd'` means neither PowerShell exists and the
- * Bash tool is running through cmd.exe: it still works, but the command syntax is
- * cmd's, not PowerShell's.
- */
-export function detectShell() {
-  for (const name of SHELL_CANDIDATES) {
-    const path = whichSync(name);
-    if (path) {
-      return { path, name, edition: name === 'pwsh' ? 'core' : 'desktop' };
-    }
-  }
-  // No PowerShell at all: on Windows, guarantee cmd.exe so the tool is not dead.
-  const cmd = findCmdExe();
-  if (cmd) return { path: cmd, name: 'cmd', edition: 'cmd' };
-  return null;
-}
-
-let cached;          // undefined = not probed yet; null = probed, none found
-let cachedEnvKey;    // re-probe if PATH changes (a /env PATH=… must take effect)
-
-/**
- * Cached detectShell(). The probe spawns a process, so it runs once per PATH.
- * Re-probing when PATH changes means an in-session PATH fix (`/env PATH=…`, which
- * is exactly what a user with a stripped PATH would do) can rescue the tool.
- */
-export function getShell() {
-  const key = String(process.env.PATH || '');
-  if (cached === undefined || cachedEnvKey !== key) {
-    cached = detectShell();
-    cachedEnvKey = key;
-  }
-  return cached;
-}
-
-/** Test seam: forget the cached probe. */
-export function resetShellCache() {
-  cached = undefined;
-  cachedEnvKey = undefined;
-}
-
-/**
- * The command + args to run `command` through the detected shell.
- *
- * `-NoProfile` and `-NonInteractive` are not cosmetic: a user profile can print a
- * banner into stdout (polluting the captured result) and can take seconds to load
- * on every single tool call, and `-NonInteractive` stops a command that prompts
- * from hanging the tool forever with no way to answer.
- *
- * When neither PowerShell exists, `edition === 'cmd'` selects cmd.exe args instead
- * (see detectShell). Throws a message naming the fix only when no shell at all
- * was found, instead of letting the caller hit a bare ENOENT.
- */
-export function shellSpawnArgs(command) {
-  const shell = getShell();
-  if (!shell) {
-    throw new Error(
-      'No shell found (tried pwsh, powershell, and cmd.exe). '
-      + 'Install PowerShell 7+ or add it to PATH, then retry.',
-    );
-  }
-  if (shell.edition === 'cmd') {
-    // cmd.exe: `/d` skips AutoRun commands, `/s` makes `/c` quoting behave
-    // predictably. The command is passed as ONE argv element, so Node does the
-    // quoting and we do not wrap it ourselves.
-    return { bin: shell.path, args: ['/d', '/s', '/c', command], shell };
-  }
-  return { bin: shell.path, args: ['-NoProfile', '-NonInteractive', '-Command', command], shell };
-}
+// Shell discovery for the Bash tool.
+//
+// The tool used to hardcode `spawn('pwsh', …)`, which relies on `pwsh` being on
+// PATH. On a Windows box with only the built-in Windows PowerShell that name does
+// not resolve at all, so the spawn failed with ENOENT and the whole tool was dead —
+// no fallback, and nothing in the message said why. It only ever worked where the
+// user had installed PowerShell 7 and added it to PATH by hand.
+//
+// Mirrors Claude Code's findPowerShell (src/utils/shell/powershellDetection.ts):
+// prefer pwsh (Core 7+), fall back to powershell (Desktop 5.1), and cache the
+// answer — the probe shells out, so it must not run per command.
+//
+// The EDITION matters beyond picking a binary: 7+ supports the pipeline chain
+// operators (`&&`, `||`) and 5.1 does not, so the prompt's syntax guidance depends
+// on which one was found.
+
+import cp from 'node:child_process';
+import fs from 'node:fs';
+
+// The two PowerShell families, by the name they are invoked as.
+export const SHELL_CANDIDATES = ['pwsh', 'powershell'];
+
+// Last-resort Windows fallback. A Windows box always has cmd.exe (%COMSPEC%),
+// so when neither PowerShell exists the Bash tool must still run SOMETHING
+// rather than failing outright. `cmd` is not a PowerShell, so the syntax
+// guidance and the spawn args differ (see cmdSpawnArgs).
+export function findCmdExe() {
+  const fromEnv = process.env.COMSPEC || process.env.ComSpec;
+  if (fromEnv) {
+    try { if (fs.existsSync(fromEnv)) return fromEnv; } catch { /* fall through to the PATH probe */ }
+  }
+  if (process.platform === 'win32') {
+    return whichSync('cmd') || whichSync('cmd.exe') || 'cmd.exe';
+  }
+  return null;
+}
+
+/**
+ * Resolve an executable name through PATH without spawning it.
+ *
+ * `where` on Windows / `which` on POSIX are the platform's own resolvers, so the
+ * answer matches what a shell would do. Returns the first absolute path or null.
+ */
+function whichSync(name) {
+  const probe = process.platform === 'win32' ? 'where' : 'which';
+  try {
+    const out = cp.execFileSync(probe, [name], {
+      stdio: ['ignore', 'pipe', 'ignore'],
+      encoding: 'utf8',
+      windowsHide: true,
+    });
+    // `where` can print several matches; take the first non-empty line.
+    const first = String(out).split(/\r?\n/).map((l) => l.trim()).filter(Boolean)[0];
+    return first || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Find a usable shell: pwsh, then the built-in powershell, then (on Windows)
+ * cmd.exe as a last resort. Returns { path, name, edition } or null.
+ *
+ * `edition` drives syntax guidance — see the header. It is inferred from the NAME
+ * rather than by running the binary (a spawn per probe is not worth it, and
+ * PowerShell 6, also named `pwsh`, is EOL and not a realistic target, so `pwsh`
+ * safely implies 7+). `edition: 'cmd'` means neither PowerShell exists and the
+ * Bash tool is running through cmd.exe: it still works, but the command syntax is
+ * cmd's, not PowerShell's.
+ */
+export function detectShell() {
+  for (const name of SHELL_CANDIDATES) {
+    const path = whichSync(name);
+    if (path) {
+      return { path, name, edition: name === 'pwsh' ? 'core' : 'desktop' };
+    }
+  }
+  // No PowerShell at all: on Windows, guarantee cmd.exe so the tool is not dead.
+  const cmd = findCmdExe();
+  if (cmd) return { path: cmd, name: 'cmd', edition: 'cmd' };
+  return null;
+}
+
+let cached;          // undefined = not probed yet; null = probed, none found
+let cachedEnvKey;    // re-probe if PATH changes (a /env PATH=… must take effect)
+
+/**
+ * Cached detectShell(). The probe spawns a process, so it runs once per PATH.
+ * Re-probing when PATH changes means an in-session PATH fix (`/env PATH=…`, which
+ * is exactly what a user with a stripped PATH would do) can rescue the tool.
+ */
+export function getShell() {
+  const key = String(process.env.PATH || '');
+  if (cached === undefined || cachedEnvKey !== key) {
+    cached = detectShell();
+    cachedEnvKey = key;
+  }
+  return cached;
+}
+
+/** Test seam: forget the cached probe. */
+export function resetShellCache() {
+  cached = undefined;
+  cachedEnvKey = undefined;
+}
+
+/**
+ * The command + args to run `command` through the detected shell.
+ *
+ * `-NoProfile` and `-NonInteractive` are not cosmetic: a user profile can print a
+ * banner into stdout (polluting the captured result) and can take seconds to load
+ * on every single tool call, and `-NonInteractive` stops a command that prompts
+ * from hanging the tool forever with no way to answer.
+ *
+ * When neither PowerShell exists, `edition === 'cmd'` selects cmd.exe args instead
+ * (see detectShell). Throws a message naming the fix only when no shell at all
+ * was found, instead of letting the caller hit a bare ENOENT.
+ */
+/**
+ * The spawn argv for a command.
+ *
+ * `interactive` drops `-NonInteractive`, and that is not cosmetic: PowerShell in non-interactive mode
+ * treats stdin as an already-finished stream and closes it, so a child started that way reads EOF
+ * immediately and exits — before anything can be written to it. The flag has to come off for
+ * `Bash {interactive: true}` to mean anything.
+ */
+export function shellSpawnArgs(command, opts = {}) {
+  const shell = getShell();
+  if (!shell) {
+    throw new Error(
+      'No shell found (tried pwsh, powershell, and cmd.exe). '
+      + 'Install PowerShell 7+ or add it to PATH, then retry.',
+    );
+  }
+  if (shell.edition === 'cmd') {
+    // cmd.exe: `/d` skips AutoRun commands, `/s` makes `/c` quoting behave
+    // predictably. The command is passed as ONE argv element, so Node does the
+    // quoting and we do not wrap it ourselves.
+    return { bin: shell.path, args: ['/d', '/s', '/c', command], shell };
+  }
+  const args = ['-NoProfile'];
+  if (!opts.interactive) args.push('-NonInteractive');
+  args.push('-Command', command);
+  return { bin: shell.path, args, shell };
+}