ineedcodes 1.0.0 → 1.0.2

package/README.md

@@ -1,6 +1,6 @@
 <div align="center">
 
-<img src="https://raw.githubusercontent.com/ineedcodes/ineedcodes/main/assets/logo.svg" alt="ineed" width="320">
+<img src="https://raw.githubusercontent.com/salsabila2507/ineedcodes/main/assets/logo.svg" alt="ineed" width="480">
 
 **Your terminal, now autonomous.**
 
@@ -9,7 +9,7 @@ You say what you want. ineed reads the files, writes the code, runs the commands
 [![npm](https://img.shields.io/npm/v/ineedcodes.svg)](https://www.npmjs.com/package/ineedcodes)
 [![license](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 [![node](https://img.shields.io/node/v/ineedcodes.svg)](https://nodejs.org)
-[![stars](https://img.shields.io/github/stars/ineedcodes/ineedcodes?style=social)](https://github.com/ineedcodes/ineedcodes)
+[![stars](https://img.shields.io/github/stars/salsabila2507/ineedcodes?style=social)](https://github.com/salsabila2507/ineedcodes)
 
 </div>
 
@@ -113,7 +113,7 @@ This project exists so anyone can start vibecoding: describe what you want, watc
 
 ## Contributing
 
-Issues and PRs are welcome at [github.com/ineedcodes/ineedcodes](https://github.com/ineedcodes/ineedcodes).
+Issues and PRs are welcome at [github.com/salsabila2507/ineedcodes](https://github.com/salsabila2507/ineedcodes).
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ineedcodes",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Your terminal, now autonomous. Just say what you want, ineed does the rest.",
   "license": "MIT",
   "type": "module",
@@ -26,10 +26,10 @@
   "homepage": "https://ineed.codes",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/ineedcodes/ineedcodes.git"
+    "url": "git+https://github.com/salsabila2507/ineedcodes.git"
   },
   "bugs": {
-    "url": "https://github.com/ineedcodes/ineedcodes/issues"
+    "url": "https://github.com/salsabila2507/ineedcodes/issues"
   },
   "keywords": [
     "ai",

package/src/agent.js

@@ -3,6 +3,7 @@
 import { chat } from './provider.js';
 import { TOOLS, runTool, shellRun, isDestructive } from './tools.js';
 import { trunc, gray, cyan, dim } from './ui.js';
+import { getMemoryProvider } from './memory.js';
 
 export const MAX_STEPS = 30;
 export const MAX_HISTORY_CHARS = 30_000;
@@ -13,7 +14,9 @@ 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.
 - Never push to remotes or delete data without being asked.
-- Destructive commands are blocked. Ask the user to run those themselves.
+- Destructive commands are always blocked. Ask the user to run those themselves.
+- 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.
+- For objectives with 3 or more steps, keep a checklist with the todo tool and update statuses as you go (in_progress for what you are doing now).
 - When the objective is done, verify it (run the tests, read the file back, whatever proves it), then reply with the final result in this shape:
   What changed, what you ran, the evidence you saw.`;
 
@@ -32,16 +35,29 @@ export async function runObjective(cfg, objective, cwd, history, hooks = {}) {
   hooks.onRunStart?.(ctrl);
   const plan = cfg.mode === 'plan';
   const tools = plan ? TOOLS.filter(t => t.allowedInPlan) : TOOLS;
+  const canAsk = typeof hooks.onApprove === 'function';
+
+  // recall durable memory before meaningful work (rule 12/15: MemoryProvider abstraction)
+  const memory = getMemoryProvider(cfg);
+  let recalled = '';
+  if (memory) {
+    hooks.onMemoryStart?.();
+    try { recalled = await memory.recall(objective); } catch { recalled = ''; }
+    hooks.onMemoryEnd?.(recalled);
+  }
+
   const messages = [
     {
       role: 'system',
       content: `${SYSTEM}\nWorking directory: ${cwd}\nMode: ${plan ? 'plan (read only, suggest what to change, do not change anything)' : 'build'}`
+        + (recalled ? `\nRelevant memory from previous sessions with this user (durable facts, may be stale):\n${recalled}` : '')
     },
     ...trimHistory(history),
     { role: 'user', content: objective }
   ];
   const changed = new Set();
   const ran = [];
+  const todos = [];
   let answer = '';
   let lastShown = '';
   try {
@@ -49,8 +65,11 @@ export async function runObjective(cfg, objective, cwd, history, hooks = {}) {
       if (ctrl.signal.aborted) break;
       let msg;
       try {
+        hooks.onThinkingStart?.();
         msg = await chat(cfg, messages, tools, ctrl.signal);
+        hooks.onThinkingEnd?.();
       } catch (err) {
+        hooks.onThinkingEnd?.();
         if (ctrl.signal.aborted) break;
         throw err;
       }
@@ -62,7 +81,13 @@ export async function runObjective(cfg, objective, cwd, history, hooks = {}) {
       }
       const calls = msg.tool_calls ?? [];
       if (calls.length === 0) {
-        return { answer, changed: [...changed], ran, aborted: false };
+        // task finished: store durable knowledge only when something actually changed
+        if (memory && answer && (changed.size > 0 || ran.length > 0) && !ctrl.signal.aborted) {
+          try {
+            await memory.store(`project ${cwd}: ${objective.slice(0, 150)} -> ${answer.slice(0, 300)}`);
+          } catch {}
+        }
+        return { answer, changed: [...changed], ran, todos: [...todos], aborted: false };
       }
       for (const call of calls) {
         let input = {};
@@ -73,17 +98,42 @@ export async function runObjective(cfg, objective, cwd, history, hooks = {}) {
           if (plan) result = { output: 'Refused: plan mode is read only. Switch to build mode with /build.' };
           else if (isDestructive(String(input.command ?? ''))) {
             result = { output: 'Refused: that command is destructive. Run it yourself if you are sure.' };
-          } else {
+          } else if (cfg.permShell !== 'allow' && !hooks.approved?.has('shell')) {
+            const verdict = canAsk ? await hooks.onApprove('shell', 'shell', input) : true; // cannot ask: CI-style allow
+            if (verdict === 'always') hooks.approved?.add('shell');
+            if (!verdict) {
+              result = { output: 'Denied: the user did not approve this shell command.' };
+            }
+          }
+          if (!result) {
+            hooks.onWorkStart?.(`running: ${trunc(String(input.command ?? ''), 60)}`);
             result = await shellRun(String(input.command ?? ''), cwd, ctrl.signal);
+            hooks.onWorkEnd?.();
             ran.push(String(input.command ?? '').slice(0, 120));
           }
         } else {
           if (plan && !TOOLS.find(t => t.name === call.function?.name)?.allowedInPlan) {
             result = { output: 'Refused: plan mode is read only. Switch to build mode with /build.' };
+          } else if (call.function?.name === 'todo') {
+            const list = Array.isArray(input.todos) ? input.todos : [];
+            todos.splice(0, todos.length, ...list.slice(0, 50).map(t => ({
+              content: String(t.content ?? '').slice(0, 200),
+              status: ['pending', 'in_progress', 'completed'].includes(t.status) ? t.status : 'pending'
+            })));
+            hooks.onTodos?.([...todos]);
+            result = { output: `Todo list updated (${todos.filter(t => t.status === 'completed').length}/${todos.length} done).` };
           } else {
-            result = runTool(call.function?.name, input, cwd);
-            if (!plan && ['write_file', 'edit_file', 'delete_file'].includes(call.function?.name)
-              && !/^(Refused|Error)/.test(String(result.output))) {
+            const name = call.function?.name;
+            const isEdit = ['write_file', 'edit_file', 'delete_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
+              if (verdict === 'always') hooks.approved?.add('edit');
+              allowedNow = Boolean(verdict);
+            }
+            result = allowedNow ? runTool(name, input, cwd) : { output: `Denied: the user did not approve ${name}.` };
+            if (allowedNow && !plan && isEdit
+              && !/^(Refused|Error|Denied)/.test(String(result.output))) {
               changed.add(String(input.path ?? ''));
             }
           }
@@ -96,7 +146,7 @@ export async function runObjective(cfg, objective, cwd, history, hooks = {}) {
     hooks.onRunEnd?.();
   }
   const stopped = ctrl.signal.aborted;
-  return { answer, changed: [...changed], ran, aborted: true, stopped };
+  return { answer, changed: [...changed], ran, todos: [...todos], aborted: true, stopped };
 }
 
 export function pushTurn(history, objective, result) {

package/src/cli.js

@@ -2,7 +2,6 @@
 // ineed: your terminal, now autonomous.
 // First open asks for provider setup. After that, just say what you want.
 
-import * as fs from 'node:fs';
 import { spawn } from 'node:child_process';
 
 const [MAJOR] = process.versions.node.split('.').map(Number);
@@ -13,7 +12,7 @@ if (!(MAJOR >= 20)) {
 }
 
 const { loadConfig } = await import('./config.js');
-const { VERSION, bold, dim, red, green, yellow } = await import('./ui.js');
+const { VERSION, bold, dim, red, green, yellow, cyan, box } = await import('./ui.js');
 
 const args = process.argv.slice(2);
 
@@ -46,7 +45,12 @@ if (args[0] === '--child') {
     process.exit(1);
   }
   try {
-    const res = await runObjective(cfg, task, process.cwd(), []);
+    const res = await runObjective(cfg, task, process.cwd(), [], {
+      onTodos: list => {
+        const mark = s => s === 'completed' ? green('✔') : s === 'in_progress' ? cyan('▸') : dim('○');
+        console.log(box([bold('To-do'), ...list.map(t => '  ' + mark(t.status) + ' ' + t.content)]));
+      }
+    });
     if (res.aborted) {
       console.log('\n' + yellow('Stopped.') + dim(' Task did not finish (step limit or Ctrl+C). Re-run to continue.'));
       process.exit(2);
@@ -69,7 +73,6 @@ if (args.length > 0 && args[0] !== '--reset') {
   const readline = await import('node:readline');
   const { makeInput } = await import('./ui.js');
   const { wizard } = await import('./wizard.js');
-  const { startSession } = await import('./session.js');
   const { clearConfig } = await import('./config.js');
 
   if (args[0] === '--reset') {
@@ -78,6 +81,7 @@ if (args.length > 0 && args[0] !== '--reset') {
   }
 
   let cfg = loadConfig();
+  const fresh = !cfg;
   if (!cfg) {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     const ask = makeInput(rl);
@@ -89,5 +93,7 @@ if (args.length > 0 && args[0] !== '--reset') {
     }
     rl.close();
   }
-  await startSession(cfg);
+  const { startSession } = await import('./session.js');
+  const wasFresh = fresh || process.env.INEED_FRESH === '1';
+  await startSession(cfg, { fresh: wasFresh });
 }

package/src/config.js

@@ -22,7 +22,10 @@ export function normalize(c) {
     apiKey: String(c.apiKey ?? ''),
     model: String(c.model),
     reasoning: c.reasoning === 'high' ? 'high' : 'low',
-    mode: c.mode === 'plan' ? 'plan' : 'build'
+    mode: c.mode === 'plan' ? 'plan' : 'build',
+    memory: c.memory !== false,
+    permEdit: c.permEdit === 'allow' ? 'allow' : 'ask',
+    permShell: c.permShell === 'allow' ? 'allow' : 'ask'
   };
 }
 

package/src/memory.js

@@ -0,0 +1,61 @@
+// memory.js: MemoryProvider abstraction. Default adapter shells out to the `icm` CLI.
+// The agent never depends on icm internals; if icm is missing or slow, memory is silently empty.
+
+import { spawn } from 'node:child_process';
+
+function icm(args, timeoutMs = 10_000) {
+  return new Promise(resolve => {
+    let child;
+    try {
+      child = spawn('icm', args, { stdio: ['ignore', 'pipe', 'pipe'], shell: process.platform === 'win32' });
+    } catch {
+      resolve(null);
+      return;
+    }
+    let out = '';
+    const timer = setTimeout(() => { try { child.kill('SIGKILL'); } catch {} resolve(null); }, timeoutMs);
+    child.stdout.on('data', c => {
+      out += c.toString();
+      if (out.length > 20_000) { try { child.kill('SIGKILL'); } catch {} }
+    });
+    child.stderr.on('data', () => {});
+    child.on('error', () => { clearTimeout(timer); resolve(null); });
+    child.on('close', code => {
+      clearTimeout(timer);
+      resolve(code === 0 ? out.slice(0, 8_000) : null);
+    });
+  });
+}
+
+export const ICMAdapter = {
+  name: 'icm',
+
+  // recall relevant durable memory for an objective. Returns '' when nothing/no icm.
+  async recall(query) {
+    if (!query?.trim()) return '';
+    const out = await icm(['recall', query.slice(0, 200), '--limit', '3', '--read-only']);
+    if (!out) return '';
+    const lines = out.split('\n').map(l => l.trim()).filter(l => l && !l.startsWith('memories['));
+    const text = lines.join('\n').slice(0, 2_000);
+    return /no (memories|results)|\(empty\)/i.test(text) ? '' : text;
+  },
+
+  // store durable knowledge. Fire-and-forget friendly. Never stores secrets (caller filters).
+  async store(content) {
+    if (!content?.trim()) return false;
+    const out = await icm(['remember', content.trim().slice(0, 1_000)]);
+    return out !== null;
+  },
+
+  async available() {
+    return (await icm(['--help'], 5_000)) !== null;
+  }
+};
+
+// pick the provider. Only icm exists today; the abstraction keeps that swappable.
+// Disable with config memory:false or env INEED_NO_MEMORY=1 (used by the test suite).
+export function getMemoryProvider(cfg) {
+  if (cfg?.memory === false) return null;
+  if (process.env.INEED_NO_MEMORY === '1') return null;
+  return ICMAdapter;
+}

package/src/provider.js

@@ -39,7 +39,27 @@ export async function chat(cfg, messages, tools, signal) {
   }));
   const headers = { 'content-type': 'application/json' };
   if (cfg.apiKey) headers.authorization = `Bearer ${cfg.apiKey}`;
-  const res = await request(`${cfg.baseUrl}/chat/completions`, { method: 'POST', headers, body: JSON.stringify(body) }, signal);
+
+  // transient failures (network errors, 429, 5xx) get retries with backoff; other HTTP answers do not
+  const ATTEMPTS = 4;
+  let res;
+  for (let attempt = 1; attempt <= ATTEMPTS; attempt++) {
+    let threw = null;
+    try {
+      res = await request(`${cfg.baseUrl}/chat/completions`, { method: 'POST', headers, body: JSON.stringify(body) }, signal);
+    } catch (err) {
+      threw = err;
+    }
+    const retryable = threw || [429, 500, 502, 503, 504].includes(res?.status);
+    if (!retryable || attempt === ATTEMPTS || signal?.aborted) {
+      if (threw) throw threw;
+      break;
+    }
+    if (threw || res) {
+      const delay = Math.min(15_000, 1500 * attempt * attempt);
+      await new Promise(r => setTimeout(r, delay));
+    }
+  }
   if (!res.ok) {
     const text = await res.text();
     // provider does not know reasoning_effort: retry once without it

package/src/session.js

@@ -1,156 +1,390 @@
-// session.js: interactive REPL. Slash commands are shortcuts, never required.
+// session.js: interactive chat TUI. Fixed logo header, scrolling chat area, fixed status + input footer.
+// Falls back to a plain REPL (same commands) when stdout is not a TTY, so tests and pipes keep working.
 
 import * as readline from 'node:readline';
-import { loadConfig, clearConfig, normalize } from './config.js';
+import { clearConfig, normalize, saveConfig } from './config.js';
 import { runObjective, pushTurn } from './agent.js';
 import { fetchModels } from './provider.js';
-import { makeInput, bold, dim, red, green, yellow, cyan, gray, trunc, BANNER } from './ui.js';
+import { makeInput, bold, dim, red, green, yellow, cyan, gray, trunc, BANNER, logo, box, startSpinner, VERSION, RULE, userBubble, screen } from './ui.js';
 import { wizard } from './wizard.js';
+import { getMemoryProvider, ICMAdapter } from './memory.js';
 
-export async function startSession(cfg) {
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  let handleRef = null;
-  const ask = makeInput(rl, l => handleRef?.(l));
-  let state = normalize(cfg);
+const plain = s => String(s).replace(/\x1b\[[0-9;]*m/g, '');
+
+function wrapLines(text, width) {
+  const out = [];
+  for (const raw of String(text).split('\n')) {
+    let line = raw;
+    if (line === '') { out.push(''); continue; }
+    while (plain(line).length > width) {
+      let vis = 0, i = 0;
+      while (i < line.length && vis < width) {
+        if (line[i] === '\x1b') { while (i < line.length && line[i] !== 'm') i++; }
+        else vis++;
+        i++;
+      }
+      out.push(line.slice(0, i));
+      line = line.slice(i);
+    }
+    out.push(line);
+  }
+  return out;
+}
+
+export async function startSession(cfg, { fresh = false } = {}) {
+  const state = normalize(cfg);
   let history = [];
   let busy = false;
   let activeRun = null;
   let mode = state.mode;
-  let pendingLines = [];
   let lastSigint = 0;
   let closed = false;
+  const approved = new Set(); // session-wide "always allow" grants
+  const pendingLines = [];
 
-  rl.on('SIGINT', () => {
-    if (activeRun) { activeRun.abort(); console.log(dim('\nStopping current task... press Ctrl+C again to force exit.')); return; }
-    const now = Date.now();
-    if (now - lastSigint < 3000) { console.log(dim('\nGoodbye.')); process.exit(0); }
-    lastSigint = now;
-    console.log(dim('\n(Ctrl+C again to exit)'));
-    rl.prompt();
-  });
+  const TUI = process.stdout.isTTY && !process.env.NO_COLOR;
 
-  const prompt = () => {
-    rl.setPrompt(`\n${bold(green('ineed'))}${dim(` [${mode}/${state.reasoning}]`)} ${dim('› ')}`);
-    rl.prompt();
-  };
+  // ONE readline, ONE line dispatcher for the whole session
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  let handleRef = null;
+  const ask = makeInput(rl, l => handleRef?.(l));
 
-  const header = () => {
-    console.log(BANNER() + dim(` · ${state.model} · ${process.cwd()}`));
-    console.log(dim('Just say what you want. /help shows shortcuts. Ctrl+C twice exits.'));
-  };
+  const say = TUI ? lines => tuiPrint(lines) : (lines => console.log(lines));
 
-  const showHelp = () => {
-    console.log('  ' + cyan('/model') + '    pick a model from your provider');
-    console.log('  ' + cyan('/plan') + '     plan mode: read only, agent suggests, changes nothing');
-    console.log('  ' + cyan('/build') + '    build mode: agent makes real changes (default)');
-    console.log('  ' + cyan('/reason') + '   toggle reasoning effort low/high');
-    console.log('  ' + cyan('/setup') + '    redo provider setup');
-    console.log('  ' + cyan('/reset') + '    clear saved config');
-    console.log('  ' + cyan('/clear') + '    forget this session\'s conversation');
-    console.log('  ' + cyan('/exit') + '     quit');
-    console.log(dim('  Everything else you type is a task, in normal language.'));
-  };
+  function doExit() {
+    closed = true;
+    if (TUI) { screen.resetRegion(); screen.exit(); }
+    console.log(dim('Goodbye.'));
+    process.exit(0);
+  }
 
-  const pickModel = async () => {
-    console.log(dim('   Fetching models...'));
+  async function pickModel() {
     let models = [];
-    try { models = await fetchModels(state); } catch (err) { console.log(red('   ' + err.message)); return; }
+    try { models = await fetchModels(state); } catch (err) { say(red('   ' + err.message)); return; }
     if (models.length === 0) {
-      const m = await ask('   Server sent no list. Type the model id: ');
-      if (m) { state = normalize({ ...state, model: m }); console.log(green('   Model: ' + state.model)); }
+      say(yellow('   Server sent no list. Change model by editing ~/.ineedcodes/config.json'));
       return;
     }
-    const max = 5;
-    const list = models.slice(0, max);
-    console.log(dim(`   ${models.length} models available, showing ${list.length}. Type a number, or a full model id.`));
-    list.forEach((m, i) => console.log(`   ${i + 1}. ${m}`));
+    const list = models.slice(0, 5);
+    say(dim(`   ${models.length} models available, showing ${list.length}. Type a number, or a full model id.`));
+    list.forEach((m, i) => say(`   ${i + 1}. ${m}`));
     const pick = await ask('   Model: ');
     if (!pick) return;
     const idx = Number(pick);
-    if (Number.isInteger(idx) && idx >= 1 && idx <= list.length) state = normalize({ ...state, model: list[idx - 1] });
-    else state = normalize({ ...state, model: pick });
-    console.log(green('   Model: ' + state.model));
-  };
+    if (Number.isInteger(idx) && idx >= 1 && idx <= list.length) Object.assign(state, normalize({ ...state, model: list[idx - 1] }));
+    else Object.assign(state, normalize({ ...state, model: pick }));
+    say(green('   Model: ' + state.model));
+    if (TUI) drawStatus();
+  }
 
-  const runTask = async input => {
+  async function runTask(input) {
     busy = true;
+    let lastStreamed = '';
+    if (TUI) tuiUserLine(input);
+    let spinner = null;
+    const stopSpinner = () => { spinner?.stop(); spinner = null; };
     try {
       const res = await runObjective(state, input, process.cwd(), history, {
-        onTool: (name, input2) => {
-          console.log('  ' + cyan('· ' + name) + ' ' + gray(trunc(JSON.stringify(input2), 100)));
+        onMemoryStart: () => { stopSpinner(); spinner = startSpinner('recalling memory'); },
+        onMemoryEnd: () => stopSpinner(),
+        onThinkingStart: () => { stopSpinner(); spinner = startSpinner('thinking'); },
+        onThinkingEnd: () => stopSpinner(),
+        onWorkStart: label => { stopSpinner(); spinner = startSpinner(label || 'working'); },
+        onWorkEnd: () => stopSpinner(),
+        onTool: (name, input2) => { stopSpinner(); say(cyan('  ● ' + name) + gray(' ' + trunc(JSON.stringify(input2), 90))); },
+        onResult: out => { say(gray('    ' + trunc(out, 110))); },
+        onText: t => { stopSpinner(); lastStreamed = t; },
+        onTodos: list => {
+          stopSpinner();
+          const mark = s => s === 'completed' ? green('✔') : s === 'in_progress' ? cyan('▸') : dim('○');
+          say(box([bold('To-do'), ...list.map(t => '  ' + mark(t.status) + ' ' + t.content)]));
+        },
+        onApprove: async (cat, name, input2) => {
+          stopSpinner();
+          say(yellow('  ⚠ approval needed') + ' ' + cyan(name) + gray(' ' + trunc(JSON.stringify(input2), 80)));
+          const a = await ask('     [y] once · [a] always for ' + cat + ' · [n] no: ');
+          const c = a.trim().toLowerCase();
+          if (c === 'a' || c === 'always') { approved.add(cat); say(dim('     always allowed for this session.')); return 'always'; }
+          if (c === 'y' || c === 'yes') return true;
+          say(dim('     denied.'));
+          return false;
         },
-        onResult: out => { console.log('  ' + gray(trunc(out, 120))); },
-        onText: t => { console.log('  ' + dim(trunc(t, 300))); },
+        approved,
         onRunStart: c => { activeRun = c; },
-        onRunEnd: () => { activeRun = null; }
+        onRunEnd: () => { activeRun = null; stopSpinner(); }
       });
       history = pushTurn(history, input, res);
-      if (res.aborted) console.log('\n' + yellow('Stopped.') + dim(' Partly done, tell me to continue if you want.'));
-      else {
-        console.log('\n' + bold(green('Done')));
-        if (res.changed?.length) console.log(dim('  Changed: ' + res.changed.join(', ')));
-        if (res.answer) console.log('  ' + res.answer.split('\n').slice(0, 14).join('\n  '));
+      stopSpinner();
+      if (res.aborted) {
+        say(yellow('  ■ Stopped') + dim(' - partly done. Ask me to continue.'));
+      } else {
+        const rows = [green(bold('■ Done'))];
+        if (res.changed?.length) rows.push(dim('  files: ') + res.changed.join(', '));
+        if (res.answer) String(res.answer).split('\n').slice(0, 14).forEach(l => rows.push('  ' + l));
+        else if (!res.changed?.length) rows.push(dim('  (no output)'));
+        say(box(rows));
       }
     } catch (err) {
-      console.log('\n' + red('Error: ' + err.message));
-      console.log(dim('  Check /setup if this keeps happening.'));
+      stopSpinner();
+      history = pushTurn(history, input, { answer: '(task failed: ' + err.message + ')' });
+      say(red('  ✗ ' + err.message) + dim('  context kept.'));
     } finally {
       busy = false;
       activeRun = null;
-      if (!closed) {
-        prompt();
-        drain();
-      }
+      stopSpinner();
+      await afterTask();
     }
-  };
+  }
 
-  const drain = () => {
+  async function afterTask() {
+    if (closed) return;
+    if (TUI) { drawStatus(); scrollRegion(); return; }
+    plainPrompt();
     while (!busy && !closed) {
       const next = pendingLines.shift();
       if (!next) break;
-      handle(next);
+      await handle(next);
     }
+  }
+
+  const commands = {
+    '/help': () => {
+      say('  ' + cyan('/model') + '    pick a model from your provider');
+      say('  ' + cyan('/plan') + '     plan mode: read only');
+      say('  ' + cyan('/build') + '    build mode: real changes (default)');
+      say('  ' + cyan('/reason') + '   toggle reasoning low/high');
+      say('  ' + cyan('/perm') + '     permissions: /perm auto | /perm safe | /perm');
+      say('  ' + cyan('/config') + '   show provider config (key hidden)');
+      say('  ' + cyan('/memory') + '   memory status, /memory on|off to toggle');
+      say('  ' + cyan('/clear') + '    forget this conversation');
+      say('  ' + cyan('/setup') + '    redo provider setup');
+      say('  ' + cyan('/reset') + '    clear saved config');
+      say('  ' + cyan('/exit') + '     quit');
+    },
+    '/config': () => {
+      say(box([
+        bold('Provider config') + dim('  ~/.ineedcodes/config.json'),
+        dim('base URL') + '   ' + state.baseUrl,
+        dim('model') + '      ' + state.model,
+        dim('reasoning') + '  ' + state.reasoning,
+        dim('mode') + '        ' + mode,
+        dim('memory') + '      ' + (state.memory === false ? 'off' : 'on (icm)'),
+        dim('edit perm') + '   ' + state.permEdit,
+        dim('shell perm') + '  ' + state.permShell,
+        dim('API key') + '     saved, hidden'
+      ]));
+    },
+    '/clear': () => { history = []; say(dim('Conversation forgotten.')); }
   };
 
-  const handle = input => {
-    if (!input) { if (!busy && !closed) prompt(); return; }
+  async function handle(input) {
+    if (!input) return;
     if (busy) { pendingLines.push(input); return; }
-    if (['/exit', '/quit', 'exit', 'quit'].includes(input)) { console.log(dim('Goodbye.')); closed = true; rl.close(); process.exit(0); }
-    if (input === '/help' || input === '?') { showHelp(); prompt(); return; }
-    if (input === '/model') {
-      busy = true;
-      pickModel().then(() => {
-        busy = false;
-        if (!closed) {
-          prompt();
-          drain();
-        }
-      });
+    if (['/exit', '/quit', 'exit', 'quit'].includes(input)) return doExit();
+    if (input === '/help' || input === '?') return commands['/help']();
+    if (input === '/config') return commands['/config']();
+    if (input === '/clear') return commands['/clear']();
+    if (input === '/model') { busy = true; try { await pickModel(); } finally { busy = false; } return afterTask(); }
+    if (input === '/plan') { mode = 'plan'; Object.assign(state, normalize({ ...state, mode })); say(yellow('Plan mode: read only.')); if (TUI) drawStatus(); return; }
+    if (input === '/build') { mode = 'build'; Object.assign(state, normalize({ ...state, mode })); say(green('Build mode: real changes.')); if (TUI) drawStatus(); return; }
+    if (input === '/reason') {
+      Object.assign(state, normalize({ ...state, reasoning: state.reasoning === 'high' ? 'low' : 'high' }));
+      say(dim('Reasoning effort: ' + state.reasoning));
+      if (TUI) drawStatus();
       return;
     }
-    if (input === '/plan') { mode = 'plan'; state = normalize({ ...state, mode: 'plan' }); console.log(yellow('Plan mode: read only.')); prompt(); return; }
-    if (input === '/build') { mode = 'build'; state = normalize({ ...state, mode: 'build' }); console.log(green('Build mode: real changes allowed.')); prompt(); return; }
-    if (input === '/reason') {
-      state = normalize({ ...state, reasoning: state.reasoning === 'high' ? 'low' : 'high' });
-      console.log(dim('Reasoning effort: ' + state.reasoning));
-      prompt(); return;
+    if (input === '/perm' || input.startsWith('/perm ')) {
+      const arg = input.slice(5).trim();
+      const apply = (pe, ps, msg) => {
+        Object.assign(state, normalize({ ...state, permEdit: pe, permShell: ps }));
+        saveConfig(state);
+        say(green(msg));
+        if (TUI) drawStatus();
+      };
+      if (arg === 'auto') return apply('allow', 'allow', 'Permissions: edits and shell run without asking.');
+      if (arg === 'safe') return apply('ask', 'ask', 'Permissions: edits and shell ask first.');
+      const parts = arg.split(/\s+/);
+      if (parts[0] === 'edit' && ['allow', 'ask'].includes(parts[1])) {
+        return apply(parts[1], state.permShell, `Edit permission: ${parts[1]}.`);
+      }
+      if (parts[0] === 'shell' && ['allow', 'ask'].includes(parts[1])) {
+        return apply(state.permEdit, parts[1], `Shell permission: ${parts[1]}.`);
+      }
+      say(box([
+        bold('Permissions'),
+        dim('edit') + '   ' + state.permEdit + dim('  (write_file, edit_file, delete_file)'),
+        dim('shell') + '   ' + state.permShell,
+        dim('granted this session') + '  ' + ([...approved].join(', ') || 'none'),
+        '',
+        dim('/perm auto') + '   never ask (saved)',
+        dim('/perm safe') + '   ask for edits and shell (saved)',
+        dim('/perm edit allow|ask   /perm shell allow|ask')
+      ]));
+      return;
+    }
+    if (input === '/memory' || input.startsWith('/memory ')) {
+      const arg = input.split(/\s+/)[1];
+      if (arg === 'on' || arg === 'off') {
+        Object.assign(state, normalize({ ...state, memory: arg === 'on' }));
+        saveConfig(state);
+        say(arg === 'on'
+          ? green('Memory: on') + dim(' - durable facts are recalled before tasks and stored after real work.')
+          : yellow('Memory: off') + dim(' - nothing is recalled or stored.'));
+        if (TUI) drawStatus();
+        return;
+      }
+      busy = true;
+      const provider = getMemoryProvider(state);
+      if (!provider) { say(yellow('Memory is off.') + dim(' Turn it on with /memory on')); busy = false; return afterTask(); }
+      const ok = await ICMAdapter.available();
+      say(ok ? green('Memory: on') + dim(` via ${provider.name}.`) : yellow('Memory: provider not installed.') + dim(' Install icm to enable.'));
+      busy = false;
+      return afterTask();
     }
-    if (input === '/clear') { history = []; console.log(dim('Conversation forgotten.')); prompt(); return; }
     if (input === '/setup' || input === '/reset') {
       clearConfig();
-      console.log(dim('Config cleared.'));
-      wizard(ask, { fromCommand: true }).then(c => {
-        state = normalize(c);
+      say(dim('Config cleared. Running setup...'));
+      busy = true;
+      try {
+        const c = await wizard(ask, { fromCommand: true });
+        Object.assign(state, normalize(c));
         mode = state.mode;
-        console.log(green('\nReady. ' + state.model));
-        prompt();
-      }).catch(() => process.exit(1));
-      return;
+        say(green('Ready. ' + state.model));
+        if (TUI) { drawHeader(); drawStatus(); }
+      } catch { return doExit(); }
+      busy = false;
+      return afterTask();
     }
-    runTask(input);
+    return runTask(input);
+  }
+
+  const plainPrompt = () => {
+    rl.setPrompt(`\n[${mode}/${state.reasoning}] ${bold(green('ineed'))} ${green('❯')} `);
+    rl.prompt();
   };
 
+  const printWelcome = () => {
+    const lines = fresh
+      ? [
+          green(bold('Welcome to ineed!')),
+          '  You are all set: any OpenAI-compatible provider, any folder.',
+          '  Type what you want in normal language, for example:',
+          dim('    "buatkan landing page beranimasi di folder ini"'),
+          dim('    "fix the failing tests and tell me what was wrong"'),
+          dim('    "explain this repository like I am a beginner"'),
+          '  ' + dim('Helpers: /help commands · /perm auto or safe · /model · /memory on|off')
+        ]
+      : [
+          dim('Type what you want. /help for commands.')
+            + (state.permEdit === 'ask' || state.permShell === 'ask' ? dim(' Edits and shell ask first: /perm auto to relax.') : '')
+        ];
+    for (const l of lines) say(l);
+  };
+
+  // ── plain REPL mode (pipes, tests, NO_COLOR) ──
+  if (!TUI) {
+    rl.on('SIGINT', () => {
+      if (activeRun) { activeRun.abort(); console.log(dim('\nStopping...')); return; }
+      const now = Date.now();
+      if (now - lastSigint < 3000) return doExit();
+      lastSigint = now;
+      console.log(dim('\n(Ctrl+C again to exit)'));
+      rl.prompt();
+    });
+    handleRef = handle;
+    console.log(logo());
+    console.log(BANNER() + dim(` · ${state.model} · ${process.cwd()}`));
+    printWelcome();
+    plainPrompt();
+    return;
+  }
+
+  // ── full TUI mode ──
+  const chatLines = [];           // completed chat lines (ANSI strings)
+  let chatTop = 0, chatBot = 0;   // scroll region rows
+  let statusRow = 0;
+
+  function drawHeader() {
+    const rows = 6;
+    const lines = logo().split('\n');
+    for (let i = 0; i < rows; i++) {
+      screen.at(i + 1, 1);
+      screen.clearLine();
+      process.stdout.write(lines[i] ?? '');
+    }
+  }
+
+  function drawStatus() {
+    const cols = process.stdout.columns || 80;
+    const left = ` ${bold(green('ineed'))} ${dim(`v${VERSION}`)}`;
+    const mid = ` ${dim(state.model)}`;
+    const right = ` ${mode === 'plan' ? yellow('plan') : green('build')} ${dim('/')} ${dim(state.reasoning)} ${dim('/')} ${state.memory === false ? dim('mem:off') : dim('mem:on')} `;
+    screen.at(statusRow, 1);
+    screen.clearLine();
+    process.stdout.write(dim('─'.repeat(Math.max(0, cols - plain(left).length - plain(mid).length - plain(right).length))) + left + mid + right);
+  }
+
+  function scrollRegion() {
+    screen.region(chatTop, chatBot);
+    screen.at(chatBot, 1);
+  }
+
+  function redrawChat() {
+    for (let i = chatTop; i <= chatBot; i++) {
+      screen.at(i, 1);
+      screen.clearLine();
+    }
+    screen.at(chatTop, 1);
+    const vis = chatBot - chatTop + 1;
+    const show = chatLines.slice(-vis);
+    process.stdout.write(show.join('\r\n'));
+    scrollRegion();
+  }
+
+  function tuiPrint(text) {
+    for (const l of wrapLines(String(text), Math.max(10, (process.stdout.columns || 80) - 4))) chatLines.push(l);
+    redrawChat();
+  }
+
+  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;
+    const headerRows = 6;
+    statusRow = rows - 1;
+    chatTop = headerRows + 1;
+    chatBot = statusRow - 1;
+    screen.at(1, 1);
+    process.stdout.write('\x1b[2J');
+    drawHeader();
+    redrawChat();
+    drawStatus();
+    scrollRegion();
+  };
+
+  rl.on('resize', layout);
+
+  // 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) => {
+    if (key && key.ctrl && key.name === 'z') { tuiPrint(dim('  (Ctrl+Z is disabled here. Use /exit, or Ctrl+C twice.)')); return; }
+    return origWrite(d, key);
+  };
+
+  rl.on('SIGINT', () => {
+    if (activeRun) { activeRun.abort(); return; }
+    const now = Date.now();
+    if (now - lastSigint < 3000) return doExit();
+    lastSigint = now;
+  });
+
   handleRef = handle;
-  header();
-  prompt();
+
+  screen.enter();
+  layout();
+  printWelcome();
+  scrollRegion();
 }

package/src/tools.js

@@ -55,6 +55,25 @@ export const TOOLS = [
     parameters: { type: 'object', properties: { path: { type: 'string' } }, required: ['path'] },
     allowedInPlan: false
   },
+  {
+    name: 'todo',
+    description: 'Maintain a visible task checklist for multi-step objectives. Replace the whole list each time.',
+    parameters: {
+      type: 'object',
+      properties: {
+        todos: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: { content: { type: 'string' }, status: { type: 'string', enum: ['pending', 'in_progress', 'completed'] } },
+            required: ['content', 'status']
+          }
+        }
+      },
+      required: ['todos']
+    },
+    allowedInPlan: true
+  },
   {
     name: 'shell',
     description: 'Run a shell command in the working directory. Returns exit code with stdout and stderr.',
@@ -76,7 +95,7 @@ export function runTool(name, input, cwd) {
         try { entries = fs.readdirSync(d, { withFileTypes: true }); } catch { return; }
         for (const e of entries) {
           if (skip.has(e.name)) continue;
-          out.push((e.isDirectory() ? e.name + '/' : e.name) + (e.isDirectory() && depth < 4 ? '/' : ''));
+          out.push(e.isDirectory() ? e.name + '/' : e.name);
           if (e.isDirectory()) walk(path.join(d, e.name), depth + 1);
         }
       })(abs, 0);

package/src/ui.js

@@ -1,6 +1,6 @@
 // ui.js: terminal helpers. No dependencies, respects NO_COLOR and non-TTY.
 
-export const VERSION = '1.0.0';
+export const VERSION = '1.0.2';
 
 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,17 +18,80 @@ export const trunc = (s, n = 120) => {
   return o.length > n ? o.slice(0, n - 1) + '...' : o;
 };
 
-export const LOGO = [
-  '####  ##   ',
-  ' ##   ##   ',
-  ' ##   ##   ',
-  ' ##   ##   ',
-  ' ####  ### '
-].join('\n');
+const plain = s => String(s).replace(/\x1b\[[0-9;]*m/g, '');
+
+// Rounded box around lines. Width follows the longest line, capped to the terminal.
+export function box(lines, colorFn = t => t) {
+  const cols = process.stdout.columns || 80;
+  const inner = Math.min(cols - 4, Math.max(10, ...lines.map(l => plain(l).length)) + 2);
+  const top = colorFn('╭' + '─'.repeat(inner) + '╮');
+  const bot = colorFn('╰' + '─'.repeat(inner) + '╯');
+  const mid = lines.map(l => colorFn('│') + ' ' + l + ' '.repeat(Math.max(0, inner - plain(l).length - 1)) + colorFn('│'));
+  return [top, ...mid, bot].join('\n');
+}
+
+const SPIN_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
+// Spinner for TTYs only. In pipes and tests it becomes a no-op.
+export function startSpinner(text = 'thinking') {
+  if (!process.stdout.isTTY || process.env.NO_COLOR) return { stop: () => {} };
+  let i = 0;
+  let stopped = false;
+  const line = () => `\r${cyan(SPIN_FRAMES[i++ % SPIN_FRAMES.length])} ${dim(text + '...')}  `;
+  process.stdout.write(line());
+  const iv = setInterval(() => process.stdout.write(line()), 90);
+  return {
+    stop() {
+      if (stopped) return;
+      stopped = true;
+      clearInterval(iv);
+      process.stdout.write('\r' + ' '.repeat(plain(text).length + 20) + '\r');
+    }
+  };
+}
+
+export const RULE = () => dim('─'.repeat(Math.min(process.stdout.columns || 80, 64)));
+
+// user bubble: quoted, colored, compact
+export const userBubble = text => {
+  const w = Math.min(process.stdout.columns || 80, 60);
+  const wrapped = [];
+  for (const raw of String(text).split('\n')) {
+    let line = raw;
+    while (line.length > w - 4) {
+      wrapped.push('  ' + yellow('│ ') + line.slice(0, w - 4));
+      line = line.slice(w - 4);
+    }
+    wrapped.push('  ' + yellow('│ ') + line);
+  }
+  return wrapped.join('\n') + '\n  ' + yellow('╰' + '─'.repeat(w - 4) + '╯');
+};
+
+// ── raw screen plumbing for the full-screen chat layout ──
+export const screen = {
+  enter() { process.stdout.write('\x1b[?1049h\x1b[?25l\x1b[H\x1b[2J'); },
+  exit() { process.stdout.write('\x1b[r\x1b[?25h\x1b[?1049l'); },
+  region(top, bot) { process.stdout.write(`\x1b[${top};${bot}r`); },
+  resetRegion() { process.stdout.write('\x1b[r'); },
+  at(row, col = 1) { process.stdout.write(`\x1b[${row};${col}H`); },
+  clearLine() { process.stdout.write('\x1b[2K'); }
+};
 
 export const BANNER = () =>
   bold(green('ineed')) + dim(` v${VERSION}`) + dim(' · your terminal, now autonomous');
 
+// Big startup logo, ANSI-shadow style. Six fixed-width lines.
+const LOGO_LINES = [
+  '██╗ ███╗   ██╗  ███████╗  ███████╗  ██████╗ ',
+  '██║ ████╗  ██║  ██╔════╝  ██╔════╝  ██╔══██╗',
+  '██║ ██╔██╗ ██║  █████╗    █████╗    ██║  ██║',
+  '██║ ██║╚██╗██║  ██╔══╝    ██╔══╝    ██║  ██║',
+  '██║ ██║ ╚████║  ███████╗  ███████╗  ██████╔╝',
+  '╚═╝ ╚═╝  ╚═══╝  ╚══════╝  ╚══════╝  ╚═════╝ '
+];
+export const LOGO = LOGO_LINES.join('\n');
+export const logo = () => LOGO_LINES.map(l => green(bold(l))).join('\n');
+
 // Ask a question and await one line. `secret` hides typed characters.
 // onLine: receiver for lines typed when no question is pending (REPL dispatch).
 export function makeInput(rl, onLine) {

package/src/wizard.js

@@ -2,7 +2,7 @@
 
 import { fetchModels, chat } from './provider.js';
 import { saveConfig } from './config.js';
-import { bold, dim, red, yellow, green, cyan, trunc } from './ui.js';
+import { bold, dim, red, yellow, green, cyan, trunc, logo, BANNER, startSpinner } from './ui.js';
 
 export async function testConnection(cfg, signal) {
   // proves reachability + auth + a working chat in one shot
@@ -15,7 +15,10 @@ export async function wizard(ask, { fromCommand = false } = {}) {
   const abortIfEnded = () => { if (inputEnded()) throw Object.assign(new Error('Setup aborted: input ended.'), { aborted: true }); };
 
   console.log('');
-  console.log(bold('Welcome to ineed') + dim(' - let\'s connect you to an AI provider. You only do this once.'));
+  console.log(logo());
+  console.log('');
+  console.log(BANNER());
+  console.log(bold('Welcome!') + dim(' Let\'s connect you to an AI provider. You only do this once.'));
   console.log(dim('Any OpenAI-compatible API works: OpenAI, OmniRoute, LM Studio, Ollama, vLLM, and more.'));
   console.log('');
 
@@ -39,9 +42,11 @@ export async function wizard(ask, { fromCommand = false } = {}) {
   const probe = { baseUrl, apiKey, model: 'x' };
   console.log(dim('\n   Checking connection...'));
   let models = [];
+  const connSpin = startSpinner('connecting');
   try {
     models = await fetchModels(probe);
   } catch {}
+  connSpin.stop();
   if (models.length > 0) {
     console.log(green(`   Connected. ${models.length} models available.`));
   } else {
@@ -65,11 +70,15 @@ export async function wizard(ask, { fromCommand = false } = {}) {
   console.log(dim(`   Testing ${model}...`));
   let saved = false;
   while (!saved) {
+    let testSpin = null;
     try {
+      testSpin = startSpinner('testing ' + model);
       const reply = await testConnection({ baseUrl, apiKey, model });
+      testSpin.stop();
       console.log(green('   Works.') + dim(` Replied: ${trunc(reply, 40)}`));
       saved = true;
     } catch (err) {
+      testSpin?.stop();
       console.log(red('   Test failed: ' + err.message));
       const choice = await ask('   [r]etry key, [m]odel, [l]ist models, [b]ase url, or [s]ave anyway? ');
       if (choice === '') abortIfEnded();