@semalt-ai/code 1.8.4 → 1.8.5

package/lib/proc.js

@@ -0,0 +1,96 @@
+'use strict';
+
+const dbg = require('./debug');
+
+// Platform-aware subprocess spawn + tree-kill helpers.
+//
+// Why this module exists: when a child is started with `shell: true`, the
+// PID Node hands back is the shell wrapper (`sh -c "..."` on POSIX, `cmd.exe
+// /c "..."` on Windows). Calling `child.kill()` kills the wrapper, but its
+// descendants (the actual `find`, `grep`, `bash` pipeline) become orphans
+// and keep running. To abort cleanly we have to kill the whole process tree.
+//
+// Constraint from the project: no other file imports `process.kill` or
+// `child.kill` directly — those calls live here. `tools.js` (and any future
+// caller) only knows about `spawnWithGroup` and `killTreeEscalating`.
+
+const isWindows = process.platform === 'win32';
+
+// Wrap `child_process.spawn` so the resulting child is addressable as a
+// process group. POSIX: `detached: true` makes the child a process-group
+// leader, so `process.kill(-pid, sig)` reaches all descendants. Windows:
+// taskkill /T walks the PID hierarchy itself, so `detached` is unnecessary
+// and actively harmful — it would spawn the child in a new console window.
+function spawnWithGroup(spawn, command, args, opts = {}) {
+  const finalOpts = { ...opts };
+  if (!isWindows) finalOpts.detached = true;
+  return spawn(command, args, finalOpts);
+}
+
+function killTree(child, signal) {
+  if (!child || child.killed || child.exitCode !== null || child.pid == null) return;
+  if (isWindows) {
+    // taskkill /T = traverse children, /F = force. windowsHide prevents the
+    // brief CMD window flash. Fire and forget — taskkill exits on its own
+    // and we don't care about its result code (the child's `exit` event is
+    // the authoritative signal).
+    const { spawn } = require('child_process');
+    try {
+      const args = ['/PID', String(child.pid), '/T'];
+      if (signal === 'SIGKILL') args.push('/F');
+      const tk = spawn('taskkill', args, { windowsHide: true, stdio: 'ignore' });
+      tk.on('error', () => {});
+      tk.unref();
+    } catch {
+      // taskkill failed to launch (PID already gone, or taskkill missing on
+      // a stripped-down Windows image). The child's exit event will still
+      // fire if the process is gone; nothing else to do here.
+    }
+  } else {
+    try {
+      // Negative PID = whole process group. Requires detached:true at spawn.
+      process.kill(-child.pid, signal || 'SIGTERM');
+    } catch (err) {
+      // ESRCH = process group already gone. Anything else is unexpected but
+      // not fatal — surface only when debug is active for triage.
+      if (err.code !== 'ESRCH') {
+        dbg.log(`[killTree] kill failed: ${err.code} ${err.message}`);
+      }
+    }
+  }
+}
+
+// Send SIGTERM (or taskkill graceful), wait 2s, escalate to SIGKILL (or
+// taskkill /F) if the tree didn't exit. Hard-coded 2s grace per the abort
+// requirements — long enough for well-behaved children to clean up, short
+// enough that a stuck `trap "" TERM` process doesn't tie up the agent.
+function killTreeEscalating(child) {
+  killTree(child, 'SIGTERM');
+  const escalation = setTimeout(() => {
+    if (child.exitCode === null && !child.killed) killTree(child, 'SIGKILL');
+  }, 2000);
+  // Don't keep the event loop alive solely for the escalation timer; if the
+  // process exits naturally first, the `once('exit')` listener clears it.
+  escalation.unref();
+  child.once('exit', () => clearTimeout(escalation));
+}
+
+// Future Windows-enablement notes:
+//   - Job objects (CreateJobObject API via a native binding) give stronger
+//     tree-kill guarantees than taskkill, especially for grandchild
+//     processes that detach themselves. Consider migrating if taskkill
+//     proves unreliable for nested children.
+//   - Windows has no SIGTERM/SIGKILL distinction at the OS level for
+//     spawned processes. taskkill (without /F) attempts WM_CLOSE-style
+//     graceful close; /F is a hard terminate. The 2s escalation here maps
+//     to "graceful taskkill, then forceful taskkill" — same shape as POSIX.
+//   - shell: true on Windows uses cmd.exe by default. Cross-platform
+//     command translation (find, grep, etc.) is the tool layer's problem,
+//     not this module's.
+
+module.exports = {
+  spawnWithGroup,
+  killTree,
+  killTreeEscalating,
+  isWindows,
+};

package/lib/prompts.js

@@ -9,6 +9,7 @@ const WRAPPER_NAMES = new Set([
   'parameter',
   'tool_call',
   'function_call',
+  'function',
 ]);
 
 // For each tool tag: required attributes and a one-line purpose.
@@ -32,7 +33,7 @@ const TOOL_TAG_SPECS = {
   edit_file:       { attrs: ['path', 'line'],       purpose: 'Replace a single line in a file (inline content = new line).' },
   search_files:    { attrs: ['pattern?', 'dir?'],   purpose: 'Find files by glob pattern.' },
   search_in_file:  { attrs: ['path'],               purpose: 'Regex search inside a file (inline content = pattern).' },
-  replace_in_file: { attrs: ['path', 'search', 'replace'], purpose: 'Regex replace inside a file.' },
+  replace_in_file: { attrs: ['path', 'search', 'replace'], purpose: 'Regex replace inside a file; inline content is interpreted as regex flags (e.g. g, i, gi).' },
   get_env:         { attrs: [],                     purpose: 'Read an env var (inline content = name).' },
   set_env:         { attrs: ['name', 'value'],      purpose: 'Set an env var for this process.' },
   download:        { attrs: [],                     purpose: 'HTTP download to the CWD (inline content = URL).' },
@@ -80,8 +81,8 @@ ${TAG_INVENTORY}
 ## Reasoning vs planning — IMPORTANT:
 
 - Your internal chain-of-thought reasoning uses your native \`<think>...</think>\` block. Use it normally for deliberation. Do NOT treat \`<think>\` as a user-facing tool and do NOT try to emit \`<think>\` as an action — it is reserved for your own reasoning and is handled by the runtime.
-- When you need to explicitly record a short plan that the agent framework can see (for logging or hand-off between steps), use \`<plan>...</plan>\` instead. \`<plan>\` is a tool tag; \`<think>\` is not.
-- Never emit \`<think>\` as an action. The valid action tags are the ones listed above.
+- When you need to explicitly record a short plan that the agent framework can see (for logging or hand-off between steps), use \`<plan>...</plan>\` instead. Both \`<think>\` and \`<plan>\` are display-only tags handled by the runtime — never emit either as an action.
+- The valid action tags are the ones listed above.
 
 ## STRICT RULES — follow exactly:
 

package/lib/tool_specs.js

@@ -75,9 +75,10 @@ const TOOL_SPECS = {
         content: {
           type: 'string',
           description: 'Full UTF-8 text to write as the new file contents',
+          default: '',
         },
       },
-      required: ['path', 'content'],
+      required: ['path'],
     },
   },
 
@@ -93,9 +94,10 @@ const TOOL_SPECS = {
         content: {
           type: 'string',
           description: 'Full UTF-8 text to write as the initial file contents',
+          default: '',
         },
       },
-      required: ['path', 'content'],
+      required: ['path'],
     },
   },
 
@@ -111,9 +113,10 @@ const TOOL_SPECS = {
         content: {
           type: 'string',
           description: 'UTF-8 text to append to the end of the file',
+          default: '',
         },
       },
-      required: ['path', 'content'],
+      required: ['path'],
     },
   },
 
@@ -241,9 +244,10 @@ const TOOL_SPECS = {
         content: {
           type: 'string',
           description: 'New text for the target line; trailing newline is added automatically when the file is rejoined',
+          default: '',
         },
       },
-      required: ['path', 'line', 'content'],
+      required: ['path', 'line'],
     },
   },
 
@@ -255,6 +259,7 @@ const TOOL_SPECS = {
         pattern: {
           type: 'string',
           description: 'Glob pattern such as "*.ts" or "src/**/*.js"; matches against the basename when the pattern contains no slash, otherwise against the relative path',
+          default: '*',
         },
         dir: {
           type: 'string',
@@ -262,7 +267,7 @@ const TOOL_SPECS = {
           default: '.',
         },
       },
-      required: ['pattern'],
+      required: [],
     },
   },
 
@@ -300,6 +305,7 @@ const TOOL_SPECS = {
         replace: {
           type: 'string',
           description: 'Replacement string; supports the standard $1, $2, $& back-references',
+          default: '',
         },
         flags: {
           type: 'string',
@@ -307,7 +313,7 @@ const TOOL_SPECS = {
           default: '',
         },
       },
-      required: ['path', 'search', 'replace'],
+      required: ['path', 'search'],
     },
   },
 
@@ -370,9 +376,10 @@ const TOOL_SPECS = {
         content: {
           type: 'string',
           description: 'Base64-encoded payload to decode and write as the file contents',
+          default: '',
         },
       },
-      required: ['path', 'content'],
+      required: ['path'],
     },
   },