bortexcode 1.2.5 → 1.2.8

package/bin/bortex.js

@@ -1167,6 +1167,111 @@ function classifyLocalPromptIntent(text) {
   return null;
 }
 
+function stripMatchingQuotes(value) {
+  const s = String(value || '').trim();
+  if (s.length >= 2 && ((s[0] === '"' && s[s.length - 1] === '"') || (s[0] === '\'' && s[s.length - 1] === '\'') || (s[0] === '`' && s[s.length - 1] === '`'))) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+
+function extractNaturalFilePath(text) {
+  const raw = String(text || '');
+  const quotedAfterFile = raw.match(/(?:file|path|percorso)\s+["'`]([^"'`]+)["'`]/i);
+  if (quotedAfterFile?.[1]) return quotedAfterFile[1].trim();
+  const tokenAfterFile = raw.match(/(?:file|path|percorso)\s+([^\s,;]+)/i);
+  if (tokenAfterFile?.[1]) return stripMatchingQuotes(tokenAfterFile[1]);
+  const absoluteOrRelative = raw.match(/["'`]?((?:[A-Za-z]:[\\/]|\/|~\/|\.{1,2}[\\/])[^"'`\s,;:]+)["'`]?/);
+  if (absoluteOrRelative?.[1]) return absoluteOrRelative[1].trim();
+  return '';
+}
+
+function extractNaturalFileContent(text, filePath) {
+  const raw = String(text || '').trim();
+  const marker = raw.match(/(?:con\s+(?:contenuto|testo)|contenente|with\s+(?:content|text)|containing)\s+([\s\S]+)$/i);
+  let content = marker?.[1] || '';
+  if (!content && filePath) {
+    const beforeFile = raw.slice(0, raw.toLowerCase().indexOf(filePath.toLowerCase())).trim();
+    const writePrefix = beforeFile.match(/(?:scrivi|write|salva|metti)\s+([\s\S]+?)(?:\s+(?:nel|nella|in|su|to)\s+(?:file|path|percorso)?\s*)?$/i);
+    if (writePrefix?.[1]) content = writePrefix[1];
+  }
+  content = String(content || '').trim();
+  if (!content) return '';
+  if ((content[0] === '"' || content[0] === '\'' || content[0] === '`')) {
+    const quote = content[0];
+    const end = content.indexOf(quote, 1);
+    if (end > 0) return content.slice(1, end);
+  }
+  content = content
+    .replace(/\s+(?:e|and|poi|then)\s+(?:rispondi|reply|dimmi|dillo|fammi sapere|tell me)\b[\s\S]*$/i, '')
+    .replace(/\s+(?:rispondi|reply)\b[\s\S]*$/i, '')
+    .trim();
+  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();
+  if (!raw) return null;
+  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 }];
+  }
+
+  const wantsAppend = /(?:^|\b)(appendi|accoda|aggiungi|append|add)(?:\b|$)/i.test(raw) && /(?:file|path|percorso|\/|\\|\.\.?[\\/])/.test(raw);
+  const wantsWrite = /(?:^|\b)(crea|creare|scrivi|write|create|salva|metti)(?:\b|$)/i.test(raw) && /(?:file|path|percorso|\/|\\|\.\.?[\\/])/.test(raw);
+  if (!wantsAppend && !wantsWrite) return null;
+
+  const textValue = extractNaturalFileContent(raw, filePath);
+  if (!textValue && !/(?:^|\b)(crea|create)(?:\b|$)/i.test(raw)) return null;
+  return [{
+    tool: wantsAppend ? 'append' : 'write',
+    path: filePath,
+    text: textValue,
+    confirm: true
+  }];
+}
+
+async function runNaturalLocalFileAction(opts, prompt) {
+  const calls = buildNaturalLocalFileActionCalls(prompt);
+  if (!calls) return { handled: false };
+  opts.lastToolRunReport = await executeStructuredToolBatch(opts, calls, {
+    continueOnError: true,
+    goal: prompt,
+    source: 'natural-local-file-action',
+    reportLabel: 'natural-local-action'
+  });
+  return { handled: true, data: opts.lastToolRunReport };
+}
+
 async function runSshStatusCommand(opts, { quiet = false } = {}) {
   const cwd = opts?.cwd || process.cwd();
   const platform = os.platform();
@@ -2644,6 +2749,86 @@ 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 {
+      const text = fs.readFileSync(filePath, 'utf8');
+      process.stdout.write(text.endsWith('\n') ? text : `${text}\n`);
+      return {
+        ok: true,
+        stdout: text,
+        stderr: null,
+        data: { path: filePath, bytes: Buffer.byteLength(text, 'utf8') }
+      };
+    } catch (err) {
+      return { ok: false, stdout: null, stderr: err.message, data: { path: filePath }, error: err.message };
+    }
+  }
+  if (tool === 'mkdir') {
+    const dirPath = resolveCliPath(opts, call.path || '.');
+    try {
+      fs.mkdirSync(dirPath, { recursive: true });
+      console.log(`Mkdir ok -> ${dirPath}`);
+      return { ok: true, stdout: `Mkdir ok -> ${dirPath}\n`, stderr: null, data: { path: dirPath } };
+    } catch (err) {
+      return { ok: false, stdout: null, stderr: err.message, data: { path: dirPath }, error: err.message };
+    }
+  }
+  if (tool === 'write' || tool === 'append') {
+    const filePath = resolveCliPath(opts, call.path);
+    const text = String(call.text ?? '');
+    try {
+      fs.mkdirSync(path.dirname(filePath), { recursive: true });
+      if (tool === 'append') fs.appendFileSync(filePath, text, 'utf8');
+      else fs.writeFileSync(filePath, text, 'utf8');
+      const label = tool === 'append' ? 'Append' : 'Write';
+      console.log(`${label} ok -> ${filePath}`);
+      return {
+        ok: true,
+        stdout: `${label} ok -> ${filePath}\n`,
+        stderr: null,
+        data: { path: filePath, bytes: Buffer.byteLength(text, 'utf8'), mode: tool }
+      };
+    } catch (err) {
+      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 || '');
@@ -2900,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))) {
@@ -2961,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}` : ''})`;
@@ -2984,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;
 }
@@ -3222,6 +3423,11 @@ function buildStructuredToolPlanFromGoal(opts, goal) {
     { tool: 'review', mode: 'all', fixSuggestions: true }
   ];
 
+  const naturalFileCalls = buildNaturalLocalFileActionCalls(g);
+  if (naturalFileCalls) {
+    return naturalFileCalls;
+  }
+
   const wantsStatus = /(verifica|controlla|check|mostra|stato|status|attivo|active|running|enabled|on)/.test(lower);
   if (wantsStatus && /(\bssh\b|sshd|remote login)/.test(lower)) {
     return [{ tool: 'project' }, { tool: 'sshStatus' }];
@@ -3356,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] || '';
@@ -3449,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',
@@ -3675,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');
@@ -3806,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.');
@@ -6397,6 +6675,8 @@ async function runSinglePrompt(opts) {
     const localResult = await handleLocalCommand(opts, opts.prompt);
     if (localResult.handled) return;
   }
+  const naturalFileAction = await runNaturalLocalFileAction(opts, opts.prompt);
+  if (naturalFileAction.handled) return;
   const localIntent = classifyLocalPromptIntent(opts.prompt);
   if (localIntent?.command) {
     const localResult = await handleLocalCommand(opts, localIntent.command);
@@ -6495,6 +6775,13 @@ async function runRepl(opts) {
         continue;
       }
     }
+    try {
+      const naturalFileAction = await runNaturalLocalFileAction(opts, line);
+      if (naturalFileAction.handled) continue;
+    } catch (err) {
+      console.error(`Local tool error: ${err.message}`);
+      continue;
+    }
     if (opts.offline) {
       console.log('Offline mode: use /help for local tools or restart without --offline to use the server.');
       continue;

package/package.json

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