ineedcodes 0.2.0 → 1.0.1

package/src/session.js

@@ -0,0 +1,156 @@
+// session.js: interactive REPL. Slash commands are shortcuts, never required.
+
+import * as readline from 'node:readline';
+import { loadConfig, clearConfig, normalize } 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 { wizard } from './wizard.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);
+  let history = [];
+  let busy = false;
+  let activeRun = null;
+  let mode = state.mode;
+  let pendingLines = [];
+  let lastSigint = 0;
+  let closed = false;
+
+  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 prompt = () => {
+    rl.setPrompt(`\n${bold(green('ineed'))}${dim(` [${mode}/${state.reasoning}]`)} ${dim('› ')}`);
+    rl.prompt();
+  };
+
+  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 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.'));
+  };
+
+  const pickModel = async () => {
+    console.log(dim('   Fetching models...'));
+    let models = [];
+    try { models = await fetchModels(state); } catch (err) { console.log(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)); }
+      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 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));
+  };
+
+  const runTask = async input => {
+    busy = true;
+    try {
+      const res = await runObjective(state, input, process.cwd(), history, {
+        onTool: (name, input2) => {
+          console.log('  ' + cyan('· ' + name) + ' ' + gray(trunc(JSON.stringify(input2), 100)));
+        },
+        onResult: out => { console.log('  ' + gray(trunc(out, 120))); },
+        onText: t => { console.log('  ' + dim(trunc(t, 300))); },
+        onRunStart: c => { activeRun = c; },
+        onRunEnd: () => { activeRun = null; }
+      });
+      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  '));
+      }
+    } catch (err) {
+      console.log('\n' + red('Error: ' + err.message));
+      console.log(dim('  Check /setup if this keeps happening.'));
+    } finally {
+      busy = false;
+      activeRun = null;
+      if (!closed) {
+        prompt();
+        drain();
+      }
+    }
+  };
+
+  const drain = () => {
+    while (!busy && !closed) {
+      const next = pendingLines.shift();
+      if (!next) break;
+      handle(next);
+    }
+  };
+
+  const handle = input => {
+    if (!input) { if (!busy && !closed) prompt(); 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();
+        }
+      });
+      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 === '/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);
+        mode = state.mode;
+        console.log(green('\nReady. ' + state.model));
+        prompt();
+      }).catch(() => process.exit(1));
+      return;
+    }
+    runTask(input);
+  };
+
+  handleRef = handle;
+  header();
+  prompt();
+}

package/src/tools.js

@@ -0,0 +1,185 @@
+// tools.js: real execution tools. Every result is { output: string } so the model never sees undefined.
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { spawn } from 'node:child_process';
+
+const underRoot = (p, root) => p === root || p.startsWith(root + path.sep);
+
+const SECRET_PATTERNS = [
+  /(^|\/)\.env($|\.)/,
+  /(^|\/)\.ssh\//,
+  /(^|\/)id_rsa/,
+  /(^|\/)id_ed25519/,
+  /\.pem$/
+];
+
+function isSecret(abs) {
+  return SECRET_PATTERNS.some(re => re.test(abs));
+}
+
+export const TOOLS = [
+  {
+    name: 'list_files',
+    description: 'List files in a directory, recursive, skips node_modules/.git/dist.',
+    parameters: { type: 'object', properties: { path: { type: 'string', description: 'relative to working directory' } } },
+    allowedInPlan: true
+  },
+  {
+    name: 'read_file',
+    description: 'Read a text file (UTF-8).',
+    parameters: { type: 'object', properties: { path: { type: 'string' } }, required: ['path'] },
+    allowedInPlan: true
+  },
+  {
+    name: 'search_text',
+    description: 'Search file contents for a string, returns file:line: matches (max 100).',
+    parameters: { type: 'object', properties: { pattern: { type: 'string' }, path: { type: 'string', description: 'directory, defaults to working directory' } }, required: ['pattern'] },
+    allowedInPlan: true
+  },
+  {
+    name: 'write_file',
+    description: 'Create or overwrite a file with content.',
+    parameters: { type: 'object', properties: { path: { type: 'string' }, content: { type: 'string' } }, required: ['path', 'content'] },
+    allowedInPlan: false
+  },
+  {
+    name: 'edit_file',
+    description: 'Replace an exact string in a file with a new string (targeted edit).',
+    parameters: { type: 'object', properties: { path: { type: 'string' }, search: { type: 'string' }, replace: { type: 'string' } }, required: ['path', 'search', 'replace'] },
+    allowedInPlan: false
+  },
+  {
+    name: 'delete_file',
+    description: 'Delete one file.',
+    parameters: { type: 'object', properties: { path: { type: 'string' } }, required: ['path'] },
+    allowedInPlan: false
+  },
+  {
+    name: 'shell',
+    description: 'Run a shell command in the working directory. Returns exit code with stdout and stderr.',
+    parameters: { type: 'object', properties: { command: { type: 'string' } }, required: ['command'] },
+    allowedInPlan: false
+  }
+];
+
+export function runTool(name, input, cwd) {
+  try {
+    const abs = path.resolve(cwd, String(input.path ?? ''));
+    if (!underRoot(abs, cwd)) return { output: 'Refused: path is outside the working directory.' };
+    if (name === 'list_files') {
+      const out = [];
+      const skip = new Set(['node_modules', '.git', 'dist', 'build', '.next', '.cache']);
+      (function walk(d, depth) {
+        if (out.length > 500 || depth > 5) return;
+        let entries;
+        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 ? '/' : ''));
+          if (e.isDirectory()) walk(path.join(d, e.name), depth + 1);
+        }
+      })(abs, 0);
+      return { output: out.length ? out.join('\n') : '(empty)' };
+    }
+    if (name === 'read_file') {
+      if (isSecret(abs)) return { output: 'Refused: that looks like a secret file, and secrets never enter the model context.' };
+      const st = fs.statSync(abs);
+      if (st.isDirectory()) return { output: 'Error: that is a directory, use list_files.' };
+      return { output: fs.readFileSync(abs, 'utf8').slice(0, 60_000) };
+    }
+    if (name === 'search_text') {
+      const pattern = String(input.pattern ?? '');
+      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.isDirectory()) { walk(p, depth + 1); continue; }
+          if (e.name.startsWith('.env') || e.name.endsWith('.pem')) continue;
+          let lines;
+          try { lines = fs.readFileSync(p, 'utf8').split('\n'); } catch { continue; }
+          for (let i = 0; i < lines.length && out.length < 100; i++) {
+            if (lines[i].includes(pattern)) out.push(`${path.relative(cwd, p)}:${i + 1}: ${lines[i].trim().slice(0, 200)}`);
+          }
+        }
+      })(abs, 0);
+      return { output: out.length ? out.join('\n') : '(no matches)' };
+    }
+    if (name === 'write_file') {
+      const content = String(input.content ?? '');
+      fs.mkdirSync(path.dirname(abs), { recursive: true });
+      fs.writeFileSync(abs, content);
+      return { output: `Wrote ${path.relative(cwd, abs) || '.'} (${content.length} bytes).` };
+    }
+    if (name === 'edit_file') {
+      if (isSecret(abs)) return { output: 'Refused: that looks like a secret file.' };
+      const search = String(input.search ?? '');
+      const replace = String(input.replace ?? '');
+      if (!search) return { output: 'Error: empty search string.' };
+      const src = fs.readFileSync(abs, 'utf8');
+      const count = src.split(search).length - 1;
+      if (count === 0) return { output: 'Error: search string not found in file.' };
+      if (count > 1) return { output: `Error: search string matches ${count} times, give a longer unique string.` };
+      fs.writeFileSync(abs, src.replace(search, replace));
+      return { output: `Edited ${path.relative(cwd, abs)}.` };
+    }
+    if (name === 'delete_file') {
+      fs.unlinkSync(abs);
+      return { output: `Deleted ${path.relative(cwd, abs)}.` };
+    }
+    return { output: `Unknown tool: ${name}` };
+  } catch (err) {
+    return { output: `Error: ${err.message}` };
+  }
+}
+
+const DESTRUCTIVE = [
+  /\brm\s+(-[a-zA-Z]*[rf][a-zA-Z]*\s+)+\/(\s|$)/,
+  /\brm\s+-[a-zA-Z]*r[a-zA-Z]*f/,
+  /\bmkfs\b/,
+  /\bdd\s+if=/,
+  /\bgit\s+push\s+.*--force/,
+  /\bgit\s+reset\s+--hard\s+origin/,
+  /:\(\)\{\s*:\|:\s*&\s*\}\s*;:/
+];
+
+export function isDestructive(command) {
+  return DESTRUCTIVE.some(re => re.test(command));
+}
+
+export function shellRun(command, cwd, signal) {
+  return new Promise(resolve => {
+    const child = spawn(command, { cwd, shell: true, env: { ...process.env, NO_COLOR: '1' } });
+    let out = '';
+    let settled = false;
+    let timedOut = false;
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      signal?.removeEventListener('abort', onAbort);
+      resolve({ output: `exit code: ${timedOut ? 'timeout' : child.exitCode}\n${out.slice(0, 20_000)}` });
+    };
+    const timer = setTimeout(() => {
+      timedOut = true;
+      try { child.kill('SIGKILL'); } catch {}
+      out += '\n[timeout after 120s]';
+    }, 120_000);
+    const onAbort = () => { try { child.kill('SIGKILL'); } catch {} out += '\n[stopped by user]'; };
+    signal?.addEventListener('abort', onAbort, { once: true });
+    child.stdout.on('data', c => {
+      out += c.toString();
+      if (out.length > 100_000) { try { child.kill('SIGKILL'); } catch {} }
+    });
+    child.stderr.on('data', c => { out += c.toString(); });
+    child.on('close', finish);
+    child.on('error', err => { out += `spawn error: ${err.message}`; finish(); });
+  });
+}

package/src/ui.js

@@ -0,0 +1,74 @@
+// ui.js: terminal helpers. No dependencies, respects NO_COLOR and non-TTY.
+
+export const VERSION = '1.0.0';
+
+const USE_COLOR = process.stdout.isTTY && !process.env.NO_COLOR;
+const wrap = (code, t) => USE_COLOR ? `\x1b[${code}m${t}\x1b[0m` : String(t);
+
+export const bold = t => wrap('1', t);
+export const dim = t => wrap('2', t);
+export const red = t => wrap('31', t);
+export const green = t => wrap('32', t);
+export const yellow = t => wrap('33', t);
+export const cyan = t => wrap('36', t);
+export const gray = t => wrap('90', t);
+
+export const trunc = (s, n = 120) => {
+  const o = String(s).replaceAll('\n', ' ');
+  return o.length > n ? o.slice(0, n - 1) + '...' : o;
+};
+
+export const LOGO = [
+  '####  ##   ',
+  ' ##   ##   ',
+  ' ##   ##   ',
+  ' ##   ##   ',
+  ' ####  ### '
+].join('\n');
+
+export const BANNER = () =>
+  bold(green('ineed')) + dim(` v${VERSION}`) + dim(' · your terminal, now autonomous');
+
+// 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) {
+  let pending = null;
+  let closed = false;
+  const queue = [];
+
+  rl.on('line', line => {
+    const l = line.trim();
+    if (pending) { const r = pending; pending = null; r(l); return; }
+    if (onLine) { onLine(l); return; }
+    queue.push(l);
+  });
+  rl.on('close', () => {
+    closed = true;
+    if (pending) { const r = pending; pending = null; r(''); }
+  });
+
+  const ask = (q, { secret = false } = {}) => new Promise(res => {
+    process.stdout.write(q + ' ');
+    let prevEcho = null;
+    if (secret && process.stdout.isTTY) {
+      prevEcho = rl._writeToOutput;
+      rl._writeToOutput = () => {}; // hide keystrokes while the user types
+    }
+    const deliver = v => {
+      if (prevEcho) rl._writeToOutput = prevEcho;
+      else if (secret) delete rl._writeToOutput;
+      if (secret) process.stdout.write('\n');
+      res(v);
+    };
+    if (queue.length > 0) deliver(queue.shift());
+    else if (closed) deliver('');
+    else pending = deliver;
+  });
+
+  // push a line as if typed: lands on a pending question, or waits in the queue
+  ask.feed = l => {
+    if (pending) { const r = pending; pending = null; r(l); return; }
+    queue.push(l);
+  };
+  return ask;
+}

package/src/wizard.js

@@ -0,0 +1,111 @@
+// wizard.js: first open. Asks base URL, API key, then offers real models to pick from. Saved once, never asked again.
+
+import { fetchModels, chat } from './provider.js';
+import { saveConfig } from './config.js';
+import { bold, dim, red, yellow, green, cyan, trunc } from './ui.js';
+
+export async function testConnection(cfg, signal) {
+  // proves reachability + auth + a working chat in one shot
+  const m = await chat(cfg, [{ role: 'user', content: 'Reply with exactly: OK' }], undefined, signal);
+  return String(m.content ?? '').trim();
+}
+
+export async function wizard(ask, { fromCommand = false } = {}) {
+  const inputEnded = () => process.stdin.readableEnded === true && !process.stdout.isTTY;
+  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(dim('Any OpenAI-compatible API works: OpenAI, OmniRoute, LM Studio, Ollama, vLLM, and more.'));
+  console.log('');
+
+  let baseUrl = '';
+  while (true) {
+    baseUrl = await ask('1. API base URL (example: https://api.openai.com/v1): ');
+    if (/^https?:\/\//.test(baseUrl)) break;
+    abortIfEnded();
+    console.log(red('   It must start with http:// or https://'));
+  }
+
+  let apiKey = '';
+  while (apiKey === '') {
+    apiKey = await ask('2. API key (input hidden): ', { secret: true });
+    if (apiKey === '') {
+      abortIfEnded();
+      console.log(red('   API key is required. Paste it and press Enter.'));
+    }
+  }
+
+  const probe = { baseUrl, apiKey, model: 'x' };
+  console.log(dim('\n   Checking connection...'));
+  let models = [];
+  try {
+    models = await fetchModels(probe);
+  } catch {}
+  if (models.length > 0) {
+    console.log(green(`   Connected. ${models.length} models available.`));
+  } else {
+    console.log(yellow('   Connected, but the server did not return a model list (many routers hide it).'));
+  }
+
+  const suggest = models.find(m => /gpt-4o-mini/i.test(m))
+    ?? models.find(m => /flash/i.test(m))
+    ?? models.find(m => /mini|fast|small/i.test(m))
+    ?? models[0];
+  let model = '';
+  while (model === '') {
+    model = await ask('3. Model id' + (suggest ? ` (Enter = ${suggest})` : '') + ': ');
+    if (model === '' && suggest) model = suggest;
+    if (model === '') {
+      abortIfEnded();
+      console.log(red('   Model id is required.'));
+    }
+  }
+
+  console.log(dim(`   Testing ${model}...`));
+  let saved = false;
+  while (!saved) {
+    try {
+      const reply = await testConnection({ baseUrl, apiKey, model });
+      console.log(green('   Works.') + dim(` Replied: ${trunc(reply, 40)}`));
+      saved = true;
+    } catch (err) {
+      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();
+      if (/^r/i.test(choice)) {
+        apiKey = await ask('   API key: ', { secret: true });
+        if (apiKey === '') abortIfEnded();
+      } else if (/^m/i.test(choice)) {
+        model = await ask('   Model id: ') || model;
+        console.log(dim(`   Testing ${model}...`));
+      } else if (/^l/i.test(choice)) {
+        try {
+          const list = await fetchModels({ baseUrl, apiKey, model: 'x' });
+          if (list.length === 0) { console.log(yellow('   The server sent no list. Use [m] to type an id.')); continue; }
+          const show = list.slice(0, 15);
+          console.log(dim(`   ${list.length} models available, showing ${show.length}:`));
+          show.forEach((m, i) => console.log('   ' + (i + 1) + '. ' + m));
+          const pick = await ask('   Number or full model id: ');
+          if (pick === '') abortIfEnded();
+          const n = Number(pick);
+          model = Number.isInteger(n) && n >= 1 && n <= show.length ? show[n - 1] : pick;
+          console.log(dim(`   Testing ${model}...`));
+        } catch (listErr) {
+          console.log(red('   Could not list models: ' + listErr.message));
+        }
+      } else if (/^b/i.test(choice)) {
+        baseUrl = await ask('   API base URL: ') || baseUrl;
+        console.log(dim('   Testing again...'));
+        try { models = await fetchModels({ baseUrl, apiKey, model: 'x' }); } catch {}
+      } else if (/^s/i.test(choice)) {
+        saved = true;
+      }
+    }
+  }
+
+  const cfg = saveConfig({ baseUrl, apiKey, model });
+  console.log(green('   Saved to ~/.ineedcodes/config.json. You will not be asked again.'));
+  console.log('');
+  return cfg;
+}