bortexcode 1.2.6 → 1.2.8

package/bin/bortex.js

@@ -1209,6 +1209,20 @@ function extractNaturalFileContent(text, filePath) {
   return stripMatchingQuotes(content);
 }
 
+function extractNaturalReplaceParts(text) {
+  const raw = String(text || '').trim();
+  const quotedPair = raw.match(/(?:sostituisci|rimpiazza|replace)\s+(["'`])([\s\S]*?)\1\s+(?:con|with)\s+(["'`])([\s\S]*?)\3/i);
+  if (quotedPair) {
+    return { search: quotedPair[2], replacement: quotedPair[4] };
+  }
+  const plainPair = raw.match(/(?:sostituisci|rimpiazza|replace)\s+([\s\S]+?)\s+(?:con|with)\s+([\s\S]+?)(?:\s+(?:nel|nella|in|su)\s+(?:file|path|percorso)?\s|$)/i);
+  if (!plainPair) return null;
+  const search = stripMatchingQuotes(plainPair[1]);
+  const replacement = stripMatchingQuotes(plainPair[2]);
+  if (!search) return null;
+  return { search, replacement };
+}
+
 function buildNaturalLocalFileActionCalls(text) {
   const raw = String(text || '').trim();
   const lower = raw.toLowerCase();
@@ -1216,6 +1230,18 @@ function buildNaturalLocalFileActionCalls(text) {
   const filePath = extractNaturalFilePath(raw);
   if (!filePath) return null;
 
+  const replaceParts = extractNaturalReplaceParts(raw);
+  if (replaceParts) {
+    return [{
+      tool: 'replace',
+      path: filePath,
+      search: replaceParts.search,
+      replacement: replaceParts.replacement,
+      all: true,
+      confirm: true
+    }];
+  }
+
   if (/(?:^|\b)(leggi|mostra|apri|read|show|cat)(?:\b|$)/i.test(raw) && /(?:file|path|percorso|\/|\\|\.\.?[\\/])/.test(raw)) {
     return [{ tool: 'read', path: filePath }];
   }
@@ -2723,6 +2749,9 @@ async function executeStructuredBuiltinTool(opts, call) {
       error: res.ok ? null : `${label} exit ${res.code == null ? 'null' : res.code}`
     };
   };
+  if (tool === 'applyPatch') {
+    return runUnifiedPatchTool(opts, call);
+  }
   if (tool === 'read') {
     const filePath = resolveCliPath(opts, call.path);
     try {
@@ -2767,6 +2796,39 @@ async function executeStructuredBuiltinTool(opts, call) {
       return { ok: false, stdout: null, stderr: err.message, data: { path: filePath, mode: tool }, error: err.message };
     }
   }
+  if (tool === 'replace') {
+    const filePath = resolveCliPath(opts, call.path);
+    const search = String(call.search ?? '');
+    const replacement = String(call.replacement ?? '');
+    const replaceAll = call.all !== false;
+    try {
+      if (!search) {
+        return { ok: false, stdout: null, stderr: 'empty search string', data: { path: filePath }, error: 'empty search string' };
+      }
+      const before = fs.readFileSync(filePath, 'utf8');
+      const count = before.split(search).length - 1;
+      if (count <= 0) {
+        const msg = `Replace no match -> ${filePath}`;
+        console.log(msg);
+        return { ok: false, stdout: `${msg}\n`, stderr: 'no matches', data: { path: filePath, search, count: 0 }, error: 'no matches' };
+      }
+      const after = replaceAll
+        ? before.split(search).join(replacement)
+        : before.replace(search, replacement);
+      fs.writeFileSync(filePath, after, 'utf8');
+      const applied = replaceAll ? count : 1;
+      const msg = `Replace ok -> ${filePath} (${applied} occurrence${applied === 1 ? '' : 's'})`;
+      console.log(msg);
+      return {
+        ok: true,
+        stdout: `${msg}\n`,
+        stderr: null,
+        data: { path: filePath, search, replacement, count: applied, all: replaceAll, bytes: Buffer.byteLength(after, 'utf8') }
+      };
+    } catch (err) {
+      return { ok: false, stdout: null, stderr: err.message, data: { path: filePath, search }, error: err.message };
+    }
+  }
   if (tool === 'gitStatus') {
     const res = await runChild('git', ['status', '--short', ...(call.branch ? ['-b'] : [])], { cwd: opts.cwd, shell: false });
     const entries = parseGitStatusShortEntries(res.stdout || '');
@@ -3023,6 +3085,19 @@ function validateStructuredToolCall(raw) {
       if (typeof call.text !== 'string') return { ok: false, error: 'Campo `text` mancante o non valido.' };
       break;
     }
+    case 'replace': {
+      const e1 = requireString('path');
+      if (e1) return { ok: false, error: e1 };
+      const e2 = requireString('search');
+      if (e2) return { ok: false, error: e2 };
+      if (typeof call.replacement !== 'string') return { ok: false, error: 'Campo `replacement` mancante o non valido.' };
+      if (call.all != null && typeof call.all !== 'boolean') return { ok: false, error: '`all` deve essere boolean.' };
+      break;
+    }
+    case 'applyPatch':
+      if (typeof call.patch !== 'string' || !call.patch.trim()) return { ok: false, error: 'Campo `patch` mancante o non valido.' };
+      if (call.checkOnly != null && typeof call.checkOnly !== 'boolean') return { ok: false, error: '`checkOnly` deve essere boolean.' };
+      break;
     case 'diff':
     case 'gitDiff':
       if (call.mode && !['unstaged', 'staged', 'all'].includes(String(call.mode))) {
@@ -3084,6 +3159,8 @@ function structuredToolCallToLocalCommand(call) {
     case 'mkdir': return `/mkdir ${call.path || '.'}`;
     case 'write': return `/write ${call.path} ${call.text}`;
     case 'append': return `/append ${call.path} ${call.text}`;
+    case 'replace': return `replace(${call.path}: ${call.search} -> ${call.replacement}${call.all === false ? ', first' : ', all'})`;
+    case 'applyPatch': return `applyPatch(${call.checkOnly ? 'check' : 'apply'}, ${String(call.patch || '').length} chars)`;
     case 'diff': return `/diff ${call.mode || 'unstaged'}`;
     case 'gitDiff': return `gitDiff(${call.mode || 'all'}${call.statOnly === false ? ',patch' : ',stat'})`;
     case 'search': return `search(${call.pattern}${call.path ? ` in ${call.path}` : ''}${call.glob ? ` glob=${call.glob}` : ''})`;
@@ -3107,7 +3184,8 @@ function structuredToolCallToLocalCommand(call) {
 
 function isRiskyStructuredToolCall(call) {
   const t = String(call.tool || '');
-  if (['write', 'append', 'mkdir', 'sh', 'runTest', 'runBuild', 'runLint'].includes(t)) return true;
+  if (['write', 'append', 'replace', 'mkdir', 'sh', 'runTest', 'runBuild', 'runLint'].includes(t)) return true;
+  if (t === 'applyPatch') return call.checkOnly !== true;
   if (t === 'git') return !isReadonlyGitArgs(call.args);
   return false;
 }
@@ -3484,7 +3562,7 @@ async function buildStructuredToolPlanWithLlm(opts, goal, llmOptions = {}) {
 
   const profile = detectWorkspaceProfile(opts);
   const supportedTools = [
-    'project', 'pwd', 'ls', 'tree', 'glob', 'read', 'readMany', 'mkdir', 'write', 'append',
+    'project', 'pwd', 'ls', 'tree', 'glob', 'read', 'readMany', 'mkdir', 'write', 'append', 'replace', 'applyPatch',
     'diff', 'git', 'gitStatus', 'gitDiff', 'search', 'runTest', 'runBuild', 'runLint', 'sshStatus', 'systemStatus', 'processStatus', 'portStatus', 'sh', 'review', 'commitSuggest'
   ];
   const testCmd = profile.suggested.test?.[0] || '';
@@ -3577,6 +3655,8 @@ async function buildStructuredToolPlanWithLlm(opts, goal, llmOptions = {}) {
     'Regole:',
     '- Preferisci tool read-only prima dei tool rischiosi',
     '- Per controlli di stato locale usa sshStatus/systemStatus/processStatus/portStatus invece di sh quando possibile',
+    '- Per modifiche testuali puntuali usa replace invece di sh',
+    '- Per modifiche multi-file o blocchi ampi usa applyPatch con una unified diff valida; usa checkOnly:true se devi solo validare',
     '- Includi review e commitSuggest verso la fine',
     '- Se proponi `runTest`/`runBuild`/`runLint` preferiscili a `sh` quando possibile',
     '- Se proponi `sh`, usa comandi test/build/lint concreti se disponibili',
@@ -3803,6 +3883,7 @@ function printLocalHelp() {
   console.log('  /patch-apply <patch-file>');
   console.log('  /patch-check-inline    incolla patch e valida (.end per terminare)');
   console.log('  /patch-apply-inline    incolla patch e applica (.end per terminare)');
+  console.log('  /tool {"tool":"applyPatch","patch":"...","checkOnly":true|false}');
   console.log('  /todo add|list|done|rm|clear ...');
   console.log('  /plan [goal]');
   console.log('  /agent-local <goal>    planner locale rapido');
@@ -3934,6 +4015,75 @@ function printPlan(opts) {
   (opts.plan.steps || []).forEach((s, i) => console.log(` ${i + 1}. ${s}`));
 }
 
+async function runUnifiedPatchTool(opts, call) {
+  const patch = String(call.patch || '');
+  const checkOnly = call.checkOnly === true;
+  const data = {
+    cwd: opts.cwd,
+    patchChars: patch.length,
+    checkOnly,
+    checkOk: false,
+    applied: false
+  };
+  if (!patch.trim()) {
+    return { ok: false, stdout: null, stderr: 'empty patch', data, error: 'empty patch' };
+  }
+
+  const tmp = path.join(os.tmpdir(), `bortex-tool-${Date.now()}-${Math.random().toString(16).slice(2)}.patch`);
+  fs.writeFileSync(tmp, patch, 'utf8');
+  try {
+    const check = await runChild('git', ['apply', '--check', '--verbose', tmp], { cwd: opts.cwd, shell: false });
+    const checkStdout = String(check.stdout || '');
+    const checkStderr = String(check.stderr || '');
+    if (checkStdout) process.stdout.write(checkStdout.endsWith('\n') ? checkStdout : `${checkStdout}\n`);
+    if (checkStderr) process.stderr.write(checkStderr.endsWith('\n') ? checkStderr : `${checkStderr}\n`);
+    data.checkOk = !!check.ok;
+    data.checkExitCode = check.code == null ? null : check.code;
+
+    if (!check.ok) {
+      const msg = 'Patch check failed';
+      console.log(msg);
+      return {
+        ok: false,
+        stdout: checkStdout || null,
+        stderr: checkStderr || msg,
+        data,
+        error: msg
+      };
+    }
+
+    if (checkOnly) {
+      const msg = 'Patch check ok';
+      console.log(msg);
+      return {
+        ok: true,
+        stdout: [checkStdout, `${msg}\n`].filter(Boolean).join(''),
+        stderr: checkStderr || null,
+        data
+      };
+    }
+
+    const applied = await runChild('git', ['apply', '--verbose', '--whitespace=nowarn', tmp], { cwd: opts.cwd, shell: false });
+    const applyStdout = String(applied.stdout || '');
+    const applyStderr = String(applied.stderr || '');
+    if (applyStdout) process.stdout.write(applyStdout.endsWith('\n') ? applyStdout : `${applyStdout}\n`);
+    if (applyStderr) process.stderr.write(applyStderr.endsWith('\n') ? applyStderr : `${applyStderr}\n`);
+    data.applied = !!applied.ok;
+    data.applyExitCode = applied.code == null ? null : applied.code;
+    const msg = applied.ok ? 'Patch apply ok' : 'Patch apply failed';
+    console.log(msg);
+    return {
+      ok: !!applied.ok,
+      stdout: [checkStdout, applyStdout, `${msg}\n`].filter(Boolean).join(''),
+      stderr: [checkStderr, applyStderr].filter(Boolean).join('\n') || null,
+      data,
+      error: applied.ok ? null : msg
+    };
+  } finally {
+    try { fs.unlinkSync(tmp); } catch (_) {}
+  }
+}
+
 async function runGitApplyInline(opts, mode) {
   if (typeof opts._readMultiline !== 'function') {
     throw new Error('Patch inline disponibile solo in REPL interattiva.');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bortexcode",
-  "version": "1.2.6",
+  "version": "1.2.8",
   "description": "Bortex Code CLI - AI coding assistant powered by bortex.site",
   "homepage": "https://bortex.site",
   "license": "UNLICENSED",