ineedcodes 1.5.1 → 1.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ineedcodes",
-  "version": "1.5.1",
+  "version": "1.6.1",
   "description": "Your terminal, now autonomous. Just say what you want, ineed does the rest.",
   "license": "MIT",
   "type": "module",

package/src/agent.js

@@ -29,8 +29,11 @@ const SYSTEM = `You are ineed, an autonomous terminal agent on the user's machin
 Rules:
 - Use the tools to do real work. Never invent output. Every success claim needs evidence from a tool result.
 - Prefer targeted edits (edit_file) over full rewrites (write_file). Work only inside the current folder.
+- Scope discipline: never explore outside the working folder (no listing the home directory, no scanning drives, no cloning repos) unless the user explicitly names those paths in the current objective. If the task needs it, ask first.
+- Prefer answering from what you already know: questions like "udah?", "done?", or status checks get a direct answer from the conversation. Only call tools when new facts are genuinely needed.
 - Never push to remotes or delete data without being asked.
 - Destructive commands are always blocked. Ask the user to run those themselves.
+- Your replies go straight to a terminal: never use markdown formatting (no **bold**, no ## headers, no tables, no emojis as decoration). Plain sentences and simple "- " bullets only.
 - Explain to match the user's depth preference (short: results only; normal: what changed and why; deep: also the reasoning and trade-offs).
 - Suggest "boost" (isolated git-worktree run) when a task involves major refactoring, repeated failed fixes, or architecture changes, by telling the user to run /boost. Do not start it yourself.
 - Some actions need user approval. A tool result starting with "Denied" means the user said no: do not retry the same call, explain what you wanted instead.
@@ -121,7 +124,7 @@ const SPAWN_TOOL = {
 };
 
 export async function runObjective(cfg, objective, cwd, history, hooks = {}, extra = {}) {
-  const ctrl = new AbortController();
+  let ctrl = new AbortController();
   hooks.onRunStart?.(ctrl);
   const plan = cfg.mode === 'plan';
   const depth = extra.depth ?? 0;
@@ -188,19 +191,27 @@ export async function runObjective(cfg, objective, cwd, history, hooks = {}, ext
   const usage = { input: 0, output: 0 };
   let answer = '';
   let lastShown = '';
+  // notes typed mid-task, injected at safe points; a steer can also interrupt an in-flight call
+  const drainSteerInto = () => {
+    const steer = hooks.drainSteer?.() ?? [];
+    for (const s of steer) {
+      messages.push({ role: 'user', content: `[steer from the user, newer than the objective] ${s}` });
+    }
+    if (steer.length) hooks.onSteer?.(steer);
+    return steer;
+  };
+  let steerRestarts = 0;
   try {
     for (let step = 0; step < MAX_STEPS; step++) {
-      if (ctrl.signal.aborted) break;
-      // steering: notes typed while the task runs join the conversation here
-      if (hooks.drainSteer) {
-        const steer = hooks.drainSteer();
-        if (steer.length) {
-          for (const s of steer) {
-            messages.push({ role: 'user', content: `[steer from the user, newer than the objective] ${s}` });
-          }
-          hooks.onSteer?.(steer);
-        }
+      // a steer abort must not kill the task: restart the call with the note included
+      if (ctrl.signal.aborted && ctrl.signal.reason === 'steer') {
+        drainSteerInto();
+        hooks.onNote?.('applying your steer, restarting the call');
+        ctrl = new AbortController();
+        hooks.onRunStart?.(ctrl);
       }
+      if (ctrl.signal.aborted) break;
+      drainSteerInto();
       let msg;
       try {
         hooks.onThinkingStart?.();
@@ -208,6 +219,16 @@ export async function runObjective(cfg, objective, cwd, history, hooks = {}, ext
         hooks.onThinkingEnd?.();
       } catch (err) {
         hooks.onThinkingEnd?.();
+        const steerInterrupt = ctrl.signal.aborted && (ctrl.signal.reason === 'steer' || err.reason === 'steer');
+        if (steerInterrupt && steerRestarts < 20) {
+          steerRestarts++;
+          drainSteerInto();
+          hooks.onNote?.('applying your steer, restarting the call');
+          ctrl = new AbortController();
+          hooks.onRunStart?.(ctrl);
+          step--; // redo this step with the steer included
+          continue;
+        }
         if (ctrl.signal.aborted) break;
         throw err;
       }
@@ -253,11 +274,16 @@ export async function runObjective(cfg, objective, cwd, history, hooks = {}, ext
       }
 
       for (const call of calls) {
+        // a stop must cut through: never execute queued tools after an abort
+        if (ctrl.signal.aborted) break;
         let input = {};
         try { input = JSON.parse(call.function?.arguments || '{}'); } catch {}
         hooks.onTool?.(call.function?.name, input);
         let result;
-        if (spawnResults.has(call.id)) {
+        // enforce the role's tool allowlist at execution time, not just listing time
+        if (extra.toolFilter && !extra.toolFilter.includes(call.function?.name)) {
+          result = { output: `Refused: your role is not allowed to use ${call.function?.name}. Report what you need instead.` };
+        } else if (spawnResults.has(call.id)) {
           result = { output: workerResultText(spawnResults.get(call.id)) };
         } else if (call.function?.name === 'spawn_agent') {
           result = { output: 'Refused: workers cannot spawn more agents.' };
@@ -334,7 +360,7 @@ export async function runObjective(cfg, objective, cwd, history, hooks = {}, ext
             result = { output: `Todo list updated (${todos.filter(t => t.status === 'completed').length}/${todos.length} done).` };
           } else {
             const name = call.function?.name;
-            const isEdit = ['write_file', 'edit_file', 'delete_file'].includes(name);
+            const isEdit = ['write_file', 'edit_file', 'delete_file', 'copy_file', 'move_file'].includes(name);
             let allowedNow = true;
             if (isEdit && cfg.permEdit !== 'allow' && !hooks.approved?.has('edit')) {
               const verdict = canAsk ? await hooks.onApprove('edit', name, input) : true; // cannot ask: CI-style allow

package/src/provider.js

@@ -11,7 +11,13 @@ async function request(url, opts, signal) {
   try {
     return await fetch(url, { ...opts, signal: ctrl.signal });
   } catch (err) {
-    if (signal?.aborted) { const e = new Error('stopped by user'); e.stopped = true; throw e; }
+    if (signal?.aborted) {
+      // signal.reason can be a string (abort('steer')) that undici rethrows as-is
+      const e = new Error('stopped by user');
+      e.stopped = true;
+      e.reason = signal.reason;
+      throw e;
+    }
     if (timedOut) throw new Error('request timed out after 120s');
     throw new Error(`cannot reach ${url}: ${err.message}`);
   } finally {

package/src/session.js

@@ -85,6 +85,7 @@ export async function startSession(cfg, { fresh = false, resume = null } = {}) {
   let sessionId = null;
   let lastBoost = null;
   let usage = { input: 0, output: 0 };
+  var tuiReady = false;
 
   // ONE readline, ONE line dispatcher for the whole session
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -131,6 +132,7 @@ export async function startSession(cfg, { fresh = false, resume = null } = {}) {
   let streamFlushTimer = null;
   let streamFlushedCount = 0;
   let streamBaseLines = null;
+  const chatLines = [];
 
   function flushStreamed() {
     if (!TUI || !lastStreamedForHooks) return;
@@ -170,7 +172,7 @@ export async function startSession(cfg, { fresh = false, resume = null } = {}) {
       onAgentEnd: (id, r) => { stop(); say((r.status === 'completed' ? green('  ◆ ' + id + ' done') : yellow('  ◆ ' + id + ' ' + r.status)) + gray(' ' + trunc(String(r.summary ?? '').replaceAll('\n', ' '), 90))); },
       onMCP: names => { if (names.length) say(dim('  MCP tools available: ' + names.join(', '))); },
       onMCPResult: (name, out) => { say(gray('    mcp result: ' + trunc(out, 100))); },
-        onNote: note => { stop(); say(dim('  ◇ ' + note)); },
+        onNote: note => { stop(); if (note.includes('applying your steer')) { lastStreamedForHooks = ''; streamFlushedCount = 0; streamBaseLines = null; if (typeof tuiReady !== 'undefined' && tuiReady) { chatLines.length = 0; redrawChat(); } } say(dim('  ◇ ' + note)); },
         onUsage: u => { usage = u; if (TUI) drawStatus(); },
         drainSteer: () => steerQueue.splice(0),
       onSteer: list => { for (const s of list) say(yellow('  ↳ steer: ') + s); },
@@ -262,7 +264,8 @@ export async function startSession(cfg, { fresh = false, resume = null } = {}) {
       say('  ' + cyan('/status') + '   everything about this session at a glance');
       say('  ' + cyan('/compact') + '  shrink the conversation into a checkpoint');
       say('  ' + cyan('/depth') + '    answer depth: /depth short|normal|deep');
-      say('  ' + cyan('/resume') + '   bring back a saved conversation');
+      say('  ' + cyan('/new') + '     start a fresh session, keep the old saved');
+      say('  ' + cyan('/resume') + '   list sessions, /resume <code> like 1425-0609');
       say('  ' + cyan('/skills') + '   list installed skills, /skills <name> shows one');
       say('  ' + cyan('/mcp') + '     list MCP servers and their tools');
       say('  ' + cyan('/humanizer') + ' natural-writing pass for pages and posts (on/off)');
@@ -292,9 +295,12 @@ export async function startSession(cfg, { fresh = false, resume = null } = {}) {
   async function handle(input) {
     if (!input) return;
     if (busy) {
-      if (input === '/stop') { activeRun?.abort(); say(dim('  (stopping...')); return; }
+      if (input === '/stop' || input.startsWith('/stop ') || input === 'stop') { activeRun?.abort(); say(dim('  (stopping...')); return; }
       if (input.startsWith('/')) { pendingLines.push(input); return; }
       steerQueue.push(input);
+      // interrupt the in-flight provider call so the steer applies immediately
+      if (activeRun) activeRun.abort('steer');
+      say(dim('  ↳ steer noted, applying it now...'));
       return;
     }
     if (['/exit', '/quit', 'exit', 'quit'].includes(input)) return doExit();
@@ -481,22 +487,43 @@ export async function startSession(cfg, { fresh = false, resume = null } = {}) {
       say(all.length ? all.map(s => `  ${cyan(s.name)} ${dim('(' + s.scope + ')')} ${s.description}`).join('\n') : yellow('No skills installed.'));
       return;
     }
-    if (input === '/resume') {
+    if (input === '/new') {
+      if (sessionId) saveSession({ id: sessionId, cwd: process.cwd(), model: state.model, history });
+      history = [];
+      sessionId = null;
+      say(green('New session started.') + dim(' The old one is saved, /resume brings it back.'));
+      if (TUI) { chatLines.length = 0; redrawChat(); drawStatus(); }
+      return;
+    }
+    if (input === '/resume' || input.startsWith('/resume ')) {
+      const codeArg = input === '/resume' ? '' : input.slice(8).trim();
       busy = true;
       const list = listSessions();
       if (!list.length) { say(yellow('No saved sessions yet.')); busy = false; return afterTask(); }
-      list.slice(0, 5).forEach((s, i) => {
+      if (codeArg) {
+        const s = loadSession(codeArg);
+        if (s?.history?.length) {
+          history = s.history;
+          sessionId = s.id;
+          renderHistory(s.history);
+          say(green(`Resumed ${s.id} (${Math.floor(s.history.length / 2)} turns). Continue where we left off.`));
+        } else say(red(`No session with code ${codeArg}. Check /resume for the list of codes.`));
+        busy = false;
+        return afterTask();
+      }
+      list.slice(0, 8).forEach((s, i) => {
         const first = String(s.history?.find(m => m.role === 'user')?.content ?? '').replaceAll('\n', ' ').slice(0, 70);
-        say(`   ${i + 1}. ${new Date(s.time).toLocaleString()} · ${Math.floor((s.history?.length ?? 0) / 2)} turns · ${first}`);
+        say(`   ${s.id}  ·  ${Math.floor((s.history?.length ?? 0) / 2)} turns  ·  ${first}`);
       });
-      const pick = await ask('   Resume which? [1]: ');
-      const n = Number(pick) || 1;
-      const s = loadSession(list[n - 1]?.id);
+      const pick = await ask('   Resume which? (code, e.g. 1425-0609, empty = newest): ');
+      const s = pick ? loadSession(pick.trim()) : list[0];
       if (s?.history?.length) {
         history = s.history;
         sessionId = s.id;
-        say(green(`Resumed ${Math.floor(s.history.length / 2)} turns. Continue where we left off.`));
-      } else say(red('Could not load that session.'));
+        renderHistory(s.history);
+        say(green(`Resumed ${s.id} (${Math.floor(s.history.length / 2)} turns). Continue where we left off.`));
+        if (TUI) redrawChat();
+      } else say(red(`No session with code ${pick}. Check the list above.`));
       busy = false;
       return afterTask();
     }
@@ -584,7 +611,6 @@ export async function startSession(cfg, { fresh = false, resume = null } = {}) {
   }
 
   // ── full TUI mode ──
-  const chatLines = [];           // completed chat lines (ANSI strings)
   let chatTop = 0, chatBot = 0;   // scroll region rows
   let statusRow = 0;
 
@@ -621,14 +647,14 @@ export async function startSession(cfg, { fresh = false, resume = null } = {}) {
   }
 
   function redrawChat() {
-    for (let i = chatTop; i <= chatBot; i++) {
-      screen.at(i, 1);
-      screen.clearLine();
-    }
-    screen.at(chatTop, 1);
+    // build the whole frame in one buffer, then paint once: no flicker
     const vis = chatBot - chatTop + 1;
     const show = chatLines.slice(-vis);
-    process.stdout.write(show.join('\r\n'));
+    let buf = '';
+    for (let i = 0; i < vis; i++) {
+      buf += `\x1b[${chatTop + i};1H\x1b[2K` + (show[i] ?? '');
+    }
+    process.stdout.write(buf);
     scrollRegion();
   }
 
@@ -637,10 +663,29 @@ export async function startSession(cfg, { fresh = false, resume = null } = {}) {
     redrawChat();
   }
 
-  const tuiUserLine = input => {
+  function renderHistory(h) {
+    if (!TUI) {
+      for (const m of h) {
+        const c = String(m.content ?? '').replaceAll('\n', ' ').slice(0, 90);
+        if (c) console.log('  ' + gray((m.role === 'user' ? 'you: ' : 'ineed: ') + c));
+      }
+      return;
+    }
+    if (!tuiReady) return;
+    setTimeout(() => {
+      for (const m of h) {
+        if (m.role === 'user') tuiUserLine(String(m.content ?? ''));
+        else if (m.content) tuiPrint(box([dim('  (earlier) ') + trunc(String(m.content).replaceAll('\n', ' '), 90)]));
+      }
+      drawStatus();
+      scrollRegion();
+    }, 0);
+  }
+
+  function tuiUserLine(input) {
     for (const l of wrapLines(userBubble(input), Math.max(10, (process.stdout.columns || 80) - 4))) chatLines.push(l);
     redrawChat();
-  };
+  }
 
   const layout = () => {
     const rows = process.stdout.rows || 24;
@@ -658,6 +703,18 @@ export async function startSession(cfg, { fresh = false, resume = null } = {}) {
 
   rl.on('resize', layout);
 
+  // typed-ahead input while busy: echo it above the status bar so the user sees what they type
+  let typedAhead = '';
+  rl.on('keypress', (ch, key) => {
+    if (!busy || !key) return;
+    if (key.name === 'backspace') typedAhead = typedAhead.slice(0, -1);
+    else if (key.name === 'return') typedAhead = '';
+    else if (key.ctrl || !ch || ch < ' ') return;
+    else typedAhead += ch;
+    process.stdout.write(`\x1b[${statusRow - 1};1H\x1b[2K` + dim('  you: ') + typedAhead);
+    scrollRegion();
+  });
+
   // keep Ctrl+Z from suspending us in raw mode: swallow the key, tell the user
   const origWrite = rl.write.bind(rl);
   rl.write = (d, key) => {

package/src/sessions.js

@@ -1,15 +1,22 @@
 // sessions.js: session persistence. Conversation checkpoints live outside the repo,
 // under the config dir, so users can leave and resume work (master prompt #34).
+// IDs are HHMM-DDMM codes so /resume 1425-0609 just works.
 
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { CONFIG_DIR as configDirPath } from './config.js';
+
 const DIR = path.join(configDirPath, 'sessions');
 
+const pad = n => String(n).padStart(2, '0');
+
+export function newSessionId(d = new Date()) {
+  return `${pad(d.getHours())}${pad(d.getMinutes())}-${pad(d.getDate())}${pad(d.getMonth() + 1)}`;
+}
 
 export function saveSession(data) {
   fs.mkdirSync(DIR, { recursive: true });
-  const id = data.id || 's_' + Date.now();
+  const id = data.id || newSessionId();
   fs.writeFileSync(path.join(DIR, id + '.json'), JSON.stringify({ ...data, id, time: Date.now() }, null, 2), { mode: 0o600 });
   return id;
 }
@@ -19,7 +26,7 @@ export function listSessions() {
     return fs.readdirSync(DIR)
       .filter(f => f.endsWith('.json'))
       .map(f => { try { return JSON.parse(fs.readFileSync(path.join(DIR, f), 'utf8')); } catch { return null; } })
-      .filter(Boolean)
+      .filter(Boolean).filter(s => (s.history?.length ?? 0) > 0)
       .sort((a, b) => b.time - a.time)
       .slice(0, 20);
   } catch { return []; }

package/src/tools.js

@@ -129,6 +129,48 @@ export const TOOLS = [
     allowedInPlan: true,
     web: true
   },
+  {
+    name: 'read_file_range',
+    description: 'Read part of a file by line numbers (1-based). For big files.',
+    parameters: { type: 'object', properties: { path: { type: 'string' }, offset: { type: 'number', description: 'first line, default 1' }, limit: { type: 'number', description: 'lines to read, default 200' } }, required: ['path'] },
+    allowedInPlan: true
+  },
+  {
+    name: 'file_exists',
+    description: 'Check whether a path exists.',
+    parameters: { type: 'object', properties: { path: { type: 'string' } }, required: ['path'] },
+    allowedInPlan: true
+  },
+  {
+    name: 'file_metadata',
+    description: 'Size, modified time, and type of a file.',
+    parameters: { type: 'object', properties: { path: { type: 'string' } }, required: ['path'] },
+    allowedInPlan: true
+  },
+  {
+    name: 'copy_file',
+    description: 'Copy a file to a new path.',
+    parameters: { type: 'object', properties: { path: { type: 'string' }, to: { type: 'string' } }, required: ['path', 'to'] },
+    allowedInPlan: false
+  },
+  {
+    name: 'move_file',
+    description: 'Move or rename a file.',
+    parameters: { type: 'object', properties: { path: { type: 'string' }, to: { type: 'string' } }, required: ['path', 'to'] },
+    allowedInPlan: false
+  },
+  {
+    name: 'search_files',
+    description: 'Find files whose NAME contains a string (recursive).',
+    parameters: { type: 'object', properties: { pattern: { type: 'string' }, path: { type: 'string' } }, required: ['pattern'] },
+    allowedInPlan: true
+  },
+  {
+    name: 'list_tracked_files',
+    description: 'List files tracked by git in this repository.',
+    parameters: { type: 'object', properties: {} },
+    allowedInPlan: true
+  },
   {
     name: 'shell',
     description: 'Run a shell command in the working directory. Returns exit code with stdout and stderr.',
@@ -208,6 +250,59 @@ export function runTool(name, input, cwd) {
       fs.unlinkSync(abs);
       return { output: `Deleted ${path.relative(cwd, abs)}.` };
     }
+    if (name === 'read_file_range') {
+      if (isSecret(abs)) return { output: 'Refused: that looks like a secret file, and secrets never enter the model context.' };
+      const all = fs.readFileSync(abs, 'utf8').split('\n');
+      const offset = Math.max(1, Number(input.offset ?? 1));
+      const limit = Math.max(1, Math.min(2_000, Number(input.limit ?? 200)));
+      const slice = all.slice(offset - 1, offset - 1 + limit);
+      const numbered = slice.map((l, i) => `${offset + i}: ${l}`).join('\n');
+      return { output: `${abs} lines ${offset}-${offset + slice.length - 1} of ${all.length}\n${numbered.slice(0, 60_000)}` };
+    }
+    if (name === 'file_exists') {
+      return { output: fs.existsSync(abs) ? `yes: ${path.relative(cwd, abs)}` : `no: ${path.relative(cwd, abs)}` };
+    }
+    if (name === 'file_metadata') {
+      const st = fs.statSync(abs);
+      return { output: `${path.relative(cwd, abs)}\nsize: ${st.size} bytes\n${st.isDirectory() ? 'directory' : 'file'}\nmodified: ${st.mtime.toISOString()}` };
+    }
+    if (name === 'copy_file') {
+      const dest = path.resolve(cwd, String(input.to ?? ''));
+      if (!underRoot(dest, cwd)) return { output: 'Refused: destination is outside the working directory.' };
+      fs.copyFileSync(abs, dest);
+      return { output: `Copied ${path.relative(cwd, abs)} -> ${path.relative(cwd, dest)}.` };
+    }
+    if (name === 'move_file') {
+      const dest = path.resolve(cwd, String(input.to ?? ''));
+      if (!underRoot(dest, cwd)) return { output: 'Refused: destination is outside the working directory.' };
+      fs.renameSync(abs, dest);
+      return { output: `Moved ${path.relative(cwd, abs)} -> ${path.relative(cwd, dest)}.` };
+    }
+    if (name === 'search_files') {
+      const pattern = String(input.pattern ?? '').toLowerCase();
+      if (!pattern) return { output: 'Error: empty pattern.' };
+      const out = [];
+      const skip = new Set(['node_modules', '.git', 'dist', 'build', '.next', '.cache']);
+      (function walk(d, depth) {
+        if (out.length >= 100 || depth > 5) return;
+        let entries;
+        try { entries = fs.readdirSync(d, { withFileTypes: true }); } catch { return; }
+        for (const e of entries) {
+          if (out.length >= 100) return;
+          if (skip.has(e.name)) continue;
+          const p = path.join(d, e.name);
+          if (e.name.toLowerCase().includes(pattern)) out.push(path.relative(cwd, p) + (e.isDirectory() ? '/' : ''));
+          if (e.isDirectory()) walk(p, depth + 1);
+        }
+      })(abs, 0);
+      return { output: out.length ? out.join('\n') : '(no matches)' };
+    }
+    if (name === 'list_tracked_files') {
+      const g = spawnSync('git', ['ls-files'], { cwd, encoding: 'utf8', maxBuffer: 4 * 1024 * 1024 });
+      if (g.status !== 0) return { output: 'Error: not a git repository (or git unavailable).' };
+      const files = g.stdout.split('\n').filter(Boolean);
+      return { output: files.length ? files.slice(0, 500).join('\n') + (files.length > 500 ? `\n(+${files.length - 500} more)` : '') : '(no tracked files)' };
+    }
     return { output: `Unknown tool: ${name}` };
   } catch (err) {
     return { output: `Error: ${err.message}` };

package/src/ui.js

@@ -1,6 +1,6 @@
 // ui.js: terminal helpers. No dependencies, respects NO_COLOR and non-TTY.
 
-export const VERSION = '1.5.1';
+export const VERSION = '1.6.1';
 
 const USE_COLOR = process.stdout.isTTY && !process.env.NO_COLOR;
 const wrap = (code, t) => USE_COLOR ? `\x1b[${code}m${t}\x1b[0m` : String(t);
@@ -18,6 +18,17 @@ export const trunc = (s, n = 120) => {
   return o.length > n ? o.slice(0, n - 1) + '...' : o;
 };
 
+// Terminal-safe markdown: **bold** becomes ANSI bold (or disappears without color),
+// headers lose their hashes. Files keep their markdown; only the screen is cleaned.
+export const mdTerm = t => {
+  let s = String(t);
+  if (USE_COLOR) s = s.replace(/\*\*([^*\n]+)\*\*/g, `\x1b[1m$1\x1b[0m`);
+  else s = s.replace(/\*\*([^*\n]+)\*\*/g, '$1');
+  s = s.replace(/(^|\n)#{1,6} /g, '$1');
+  s = s.replace(/\*([^*\n]+)\*/g, '$1');
+  return s;
+};
+
 const plain = s => String(s).replace(/\x1b\[[0-9;]*m/g, '');
 
 // Rounded box around lines. Width follows the longest line, capped to the terminal.