osai-agent 4.0.0

package/src/ui/diff.js

@@ -0,0 +1,249 @@
+import chalk from 'chalk';
+import { highlightCode } from '../parser/markdown.js';
+
+export const langFromPath = (fp) => {
+  if (!fp) return '';
+  const m = fp.match(/\.(\w+)$/);
+  if (!m) return '';
+  const ext = m[1].toLowerCase();
+  const map = {
+    js:'js', jsx:'jsx', ts:'ts', tsx:'tsx', mjs:'js', cjs:'js', mts:'ts', cts:'ts',
+    py:'py', python:'py', sh:'sh', bash:'sh', zsh:'sh', shell:'sh',
+    rs:'rs', go:'go', rb:'rb', java:'java', kt:'kt', swift:'swift',
+    css:'css', scss:'scss', less:'less', html:'html', htm:'html',
+    json:'json', xml:'xml', yaml:'yaml', yml:'yaml', md:'md',
+    sql:'sql', graphql:'graphql', gql:'graphql'
+  };
+  return map[ext] || '';
+};
+
+const c = {
+  removedBg:  '#2d1010',
+  removedFg:  '#f7768e',
+  addedBg:    '#1a2f1a',
+  addedFg:    '#9ece6a',
+  ctxFg:      '#565f89',
+  lineNumFg:  '#414868',
+  border:     '#2a2e3f',
+  headerBg:   '#1a1b26',
+  headerFg:   '#7aa2f7',
+  dim:        '#414868',
+};
+
+const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, '');
+const visLen    = (s) => stripAnsi(s).length;
+const getWidth  = () => Math.min(Math.max(process.stdout.columns || 96, 60), 120);
+const wrapPlain = (line, width) => {
+  const safeWidth = Math.max(1, width | 0);
+  const src = String(line ?? '');
+  if (!src.length) return [''];
+  const out = [];
+  for (let i = 0; i < src.length; i += safeWidth) out.push(src.slice(i, i + safeWidth));
+  return out;
+};
+
+// ─── Unified diff between two strings ──────────────────────────
+// Returns an array of { type: 'ctx'|'del'|'add', line, oldN, newN }
+export const buildDiff = (oldText, newText) => {
+  const oldLines = (oldText || '').split('\n');
+  const newLines = (newText || '').split('\n');
+
+  // LCS-based Myers-lite diff (line level)
+  const m = oldLines.length, n = newLines.length;
+  const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+  for (let i = m - 1; i >= 0; i--)
+    for (let j = n - 1; j >= 0; j--)
+      dp[i][j] = oldLines[i] === newLines[j]
+        ? dp[i + 1][j + 1] + 1
+        : Math.max(dp[i + 1][j], dp[i][j + 1]);
+
+  const hunks = [];
+  let i = 0, j = 0;
+  while (i < m || j < n) {
+    if (i < m && j < n && oldLines[i] === newLines[j]) {
+      hunks.push({ type: 'ctx', line: oldLines[i], oldN: i + 1, newN: j + 1 });
+      i++; j++;
+    } else if (j < n && (i >= m || dp[i + 1] && dp[i][j + 1] >= (dp[i + 1] ? dp[i + 1][j] : 0))) {
+      hunks.push({ type: 'add', line: newLines[j], newN: j + 1 });
+      j++;
+    } else {
+      hunks.push({ type: 'del', line: oldLines[i], oldN: i + 1 });
+      i++;
+    }
+  }
+  return hunks;
+};
+
+// ─── Keep only changed hunks + 3 context lines around them ─────
+export const collapseContext = (hunks, ctx = 3) => {
+  const changed = new Set();
+  hunks.forEach((h, i) => { if (h.type !== 'ctx') for (let d = -ctx; d <= ctx; d++) changed.add(i + d); });
+  const out = [];
+  let skipped = 0;
+  for (let i = 0; i < hunks.length; i++) {
+    if (changed.has(i)) {
+      if (skipped > 0) { out.push({ type: 'skip', count: skipped }); skipped = 0; }
+      out.push(hunks[i]);
+    } else {
+      skipped++;
+    }
+  }
+  if (skipped > 0) out.push({ type: 'skip', count: skipped });
+  return out;
+};
+
+// ─── Inline word-level highlighting for changed lines ──────────
+const wordDiff = (oldLine, newLine, fg, bg) => {
+  const ow = oldLine.split(/(\s+)/);
+  const nw = newLine.split(/(\s+)/);
+  const oldSet = new Set(ow);
+  return nw.map(w => {
+    if (!oldSet.has(w) && w.trim()) return chalk.hex(fg).bgHex(bg).bold(w);
+    return chalk.hex(fg)(w);
+  }).join('');
+};
+
+// ─── Public: render a WRITE_FILE creation diff ─────────────────
+export const printNewFile = (filePath, content) => {
+  const lines = (content || '').split('\n');
+  const w = getWidth();
+  const bc = chalk.hex(c.border);
+  const lnW = String(lines.length).length;
+  const innerW = w - lnW - 6;
+  const lang = langFromPath(filePath);
+
+  console.log();
+  const header = ` + ${filePath} (new file, ${lines.length} lines) `;
+  const headerPad = Math.max(0, w - 2 - header.length);
+  console.log(bc('╭') + chalk.bgHex(c.headerBg).hex(c.headerFg)(header) + chalk.hex(c.headerBg)('─'.repeat(headerPad)) + bc('╮'));
+
+  const shown = Math.min(lines.length, 50);
+  for (let i = 0; i < shown; i++) {
+    const lineNum = chalk.hex(c.lineNumFg)(String(i + 1).padStart(lnW));
+    const raw = lines[i].length > innerW ? lines[i].slice(0, innerW - 1) + '…' : lines[i];
+    const colored = highlightCode(raw, lang);
+    const prefix = chalk.bgHex(c.addedBg).hex(c.addedFg)('+');
+    const padLen = Math.max(0, innerW - stripAnsi(colored).length);
+    console.log(bc('│') + ' ' + lineNum + ' ' + prefix + ' ' + colored + ' '.repeat(padLen) + bc('│'));
+  }
+  if (lines.length > 50) {
+    const msg = `  ··· ${lines.length - 50} more lines`;
+    console.log(bc('│') + chalk.hex(c.dim)(msg) + ' '.repeat(Math.max(0, w - 2 - msg.length)) + bc('│'));
+  }
+  console.log(bc('╰' + '─'.repeat(w - 2) + '╯'));
+  console.log();
+};
+
+// ─── Public: render an EDIT_FILE diff (find → replace) ─────────
+export const printEditDiff = (filePath, find, replace) => {
+  const hunks = buildDiff(find, replace);
+  const collapsed = collapseContext(hunks, 3);
+
+  const w = getWidth();
+  const bc = chalk.hex(c.border);
+  const allLines = [...hunks.filter(h => h.oldN || h.newN)];
+  const maxN = Math.max(...allLines.map(h => Math.max(h.oldN || 0, h.newN || 0)), 1);
+  const lnW = String(maxN).length;
+  const innerW = w - lnW * 2 - 7;
+  const lang = langFromPath(filePath);
+
+  console.log();
+  const header = ` ✎ ${filePath} `;
+  const headerPad = Math.max(0, w - 2 - header.length);
+  console.log(bc('╭') + chalk.bgHex(c.headerBg).hex(c.headerFg)(header) + chalk.hex(c.headerBg)('─'.repeat(headerPad)) + bc('╮'));
+
+  for (const hunk of collapsed) {
+    if (hunk.type === 'skip') {
+      const msg = `  ··· ${hunk.count} unchanged line${hunk.count > 1 ? 's' : ''}`;
+      const pad = Math.max(0, w - 2 - msg.length);
+      console.log(bc('│') + chalk.hex(c.dim)(msg) + ' '.repeat(pad) + bc('│'));
+      continue;
+    }
+
+    const oldNum = hunk.oldN ? String(hunk.oldN).padStart(lnW) : ' '.repeat(lnW);
+    const newNum = hunk.newN ? String(hunk.newN).padStart(lnW) : ' '.repeat(lnW);
+    const lineNums = chalk.hex(c.lineNumFg)(`${oldNum}:${newNum}`);
+    const lineNumsCont = chalk.hex(c.lineNumFg)(`${' '.repeat(lnW)}:${' '.repeat(lnW)}`);
+
+    if (hunk.type === 'ctx') {
+      const chunks = wrapPlain(hunk.line, innerW);
+      chunks.forEach((chunk, idx) => {
+        const nums = idx === 0 ? lineNums : lineNumsCont;
+        const styled = chalk.hex(c.ctxFg)(' ' + chunk);
+        const pad = Math.max(0, innerW + 1 - visLen(styled));
+        console.log(bc('│') + ' ' + nums + ' ' + styled + ' '.repeat(pad) + bc('│'));
+      });
+    } else if (hunk.type === 'del') {
+      const chunks = wrapPlain(hunk.line, innerW);
+      chunks.forEach((chunk, idx) => {
+        const nums = idx === 0 ? lineNums : lineNumsCont;
+        const sign = idx === 0 ? '-' : ' ';
+        const colored = chalk.bgHex(c.removedBg).hex(c.removedFg)(sign) + highlightCode(chunk, lang);
+        const pad = Math.max(0, innerW + 1 - stripAnsi(colored).length);
+        console.log(bc('│') + ' ' + nums + ' ' + colored + ' '.repeat(pad) + bc('│'));
+      });
+    } else if (hunk.type === 'add') {
+      const chunks = wrapPlain(hunk.line, innerW);
+      chunks.forEach((chunk, idx) => {
+        const nums = idx === 0 ? lineNums : lineNumsCont;
+        const sign = idx === 0 ? '+' : ' ';
+        const colored = chalk.bgHex(c.addedBg).hex(c.addedFg)(sign) + highlightCode(chunk, lang);
+        const pad = Math.max(0, innerW + 1 - stripAnsi(colored).length);
+        console.log(bc('│') + ' ' + nums + ' ' + colored + ' '.repeat(pad) + bc('│'));
+      });
+    }
+  }
+
+  const dels = hunks.filter(h => h.type === 'del').length;
+  const adds = hunks.filter(h => h.type === 'add').length;
+  const summary = `  ${chalk.hex(c.addedFg)('+' + adds)} ${chalk.hex(c.removedFg)('-' + dels)} `;
+  const summaryPad = Math.max(0, w - 2 - stripAnsi(summary).length);
+  console.log(bc('│') + summary + ' '.repeat(summaryPad) + bc('│'));
+  console.log(bc('╰' + '─'.repeat(w - 2) + '╯'));
+  console.log();
+};
+
+// ─── Public: render an APPEND_FILE diff ────────────────────────
+export const printAppendDiff = (filePath, content) => {
+  const lines = (content || '').split('\n');
+  const w = getWidth();
+  const bc = chalk.hex(c.border);
+  const lnW = String(lines.length).length;
+  const innerW = w - lnW - 6;
+  const lang = langFromPath(filePath);
+
+  console.log();
+  const header = ` + ${filePath} (appending ${lines.length} line${lines.length > 1 ? 's' : ''}) `;
+  const headerPad = Math.max(0, w - 2 - header.length);
+  console.log(bc('╭') + chalk.bgHex(c.headerBg).hex(c.addedFg)(header) + chalk.hex(c.headerBg)('─'.repeat(headerPad)) + bc('╮'));
+
+  const skip = lines.length > 30;
+  const shown = skip ? lines.slice(0, 15) : lines;
+  shown.forEach((line, i) => {
+    const lineNum = chalk.hex(c.lineNumFg)(String(i + 1).padStart(lnW));
+    const raw = line.length > innerW ? line.slice(0, innerW - 1) + '…' : line;
+    const colored = highlightCode(raw, lang);
+    const pad = Math.max(0, innerW - stripAnsi(colored).length);
+    console.log(bc('│') + ' ' + lineNum + ' ' + chalk.bgHex(c.addedBg).hex(c.addedFg)('+') + ' ' + colored + ' '.repeat(pad) + bc('│'));
+  });
+  if (skip) {
+    const msg = `  ··· ${lines.length - 15} more lines`;
+    console.log(bc('│') + chalk.hex(c.dim)(msg) + ' '.repeat(Math.max(0, w - 2 - msg.length)) + bc('│'));
+  }
+  console.log(bc('╰' + '─'.repeat(w - 2) + '╯'));
+  console.log();
+};
+
+// ─── Public: DELETE_FILE ────────────────────────────────────────
+
+// ─── Public: DELETE_FILE ────────────────────────────────────────
+export const printDeleteFile = (filePath) => {
+  const w = getWidth();
+  const bc = chalk.hex(c.border);
+  const msg = ` ✗ ${filePath} (deleted) `;
+  const pad = Math.max(0, w - 2 - msg.length);
+  console.log();
+  console.log(bc('╭') + chalk.bgHex(c.removedBg).hex(c.removedFg)(msg) + chalk.hex(c.removedBg)('─'.repeat(pad)) + bc('╮'));
+  console.log(bc('╰' + '─'.repeat(w - 2) + '╯'));
+  console.log();
+};

package/src/ui/h.js

@@ -0,0 +1,7 @@
+import React from 'react';
+
+/**
+ * Helper to use React.createElement concisely instead of JSX,
+ * avoiding the need for a build step in this ESM project.
+ */
+export const h = React.createElement;

package/src/ui/mouse-scroll.js

@@ -0,0 +1,63 @@
+const SGR_MOUSE_RE = /\x1b\[<(\d+);(\d+);(\d+)([mM])/g;
+const SGR_MOUSE_INPUT_STRIP_RE = /\[<\d+;\d+;\d+[mM]/g;
+const SGR_MOUSE_INPUT_DETECT_RE = /\[<\d+;\d+;\d+[mM]/;
+
+/** True when stdin chunk is only SGR mouse events (clicks/wheel), not real text. */
+export function isOnlySgrMouseInput(input) {
+  if (!input) return false;
+  const stripped = input
+    .replace(/\x1b\[<\d+;\d+;\d+[mM]/g, '')
+    .replace(SGR_MOUSE_INPUT_STRIP_RE, '');
+  return stripped.length === 0 && SGR_MOUSE_INPUT_DETECT_RE.test(input);
+}
+let WHEEL_LINES = 3;
+if (process.env.OSAI_UI_WHEEL_LINES) {
+  const n = Number.parseInt(process.env.OSAI_UI_WHEEL_LINES, 10);
+  if (Number.isFinite(n) && n > 0) WHEEL_LINES = n;
+}
+
+export const MOUSE_SCROLL_ENABLED = process.env.OSAI_UI_MOUSE_SCROLL !== '0';
+
+export function enableMouseReporting() {
+  if (!MOUSE_SCROLL_ENABLED || !process.stdout.isTTY) return;
+  try {
+    process.stdout.write('\x1b[?1000h');  // Enable basic mouse tracking (press events incl. wheel)
+    process.stdout.write('\x1b[?1006h');  // Enable SGR mouse encoding (coordinates > 223)
+  } catch {}
+}
+
+export function disableMouseReporting() {
+  if (!process.stdout.isTTY) return;
+  try {
+    process.stdout.write('\x1b[?1006l');  // Disable SGR mouse encoding
+    process.stdout.write('\x1b[?1000l');  // Disable mouse tracking
+  } catch {}
+}
+
+/**
+ * Listen for SGR mouse wheel events on stdin.
+ * @param {(delta: number) => void} onWheel negative = up, positive = down
+ * @returns {() => void} cleanup
+ */
+export function setupMouseScroll(onWheel) {
+  if (!MOUSE_SCROLL_ENABLED || !process.stdin.isTTY) return () => {};
+
+  enableMouseReporting();
+
+  const onData = (chunk) => {
+    const str = typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+    let match;
+    SGR_MOUSE_RE.lastIndex = 0;
+    while ((match = SGR_MOUSE_RE.exec(str)) !== null) {
+      const btn = Number.parseInt(match[1], 10);
+      if (btn === 64) onWheel(-WHEEL_LINES);
+      else if (btn === 65) onWheel(WHEEL_LINES);
+    }
+  };
+
+  process.stdin.on('data', onData);
+  return () => {
+    process.stdin.off('data', onData);
+    disableMouseReporting();
+  };
+}

package/src/ui/slash-picker.js

@@ -0,0 +1,58 @@
+import { printBoxHeaderOnly } from './terminal.js';
+import chalk from 'chalk';
+
+export const SLASH_COMMANDS = [
+  { cmd: '/clear',   desc: 'Clear displayed history',                    action: 'clear' },
+  { cmd: '/help',    desc: 'Show available commands',                     action: 'help' },
+  { cmd: '/new',     desc: 'Start a new section (saves current)',         action: 'new' },
+  { cmd: '/status',  desc: 'Show OS, mode and session info',              action: 'status' },
+  { cmd: '/stats',   desc: 'Iterations, tokens and timing',               action: 'stats' },
+  { cmd: '/history', desc: 'Saved sessions - resume a past conversation', action: 'history' },
+  { cmd: '/save',    desc: 'Save current session to disk',                action: 'save' },
+  { cmd: '/context', desc: 'Show conversation context size',              action: 'context' },
+  { cmd: '/devices', desc: 'List configured devices',                     action: 'devices' },
+  { cmd: '/provider', desc: 'Manage AI providers and API keys',           action: 'provider' },
+  { cmd: '/plan',    desc: 'Switch to PLAN mode (read-only, no modifications)', action: 'plan' },
+  { cmd: '/exec',    desc: 'Switch to EXEC mode (modifications allowed)',      action: 'exec' },
+  { cmd: '/mode',    desc: 'Switch GENERAL / CODING / NETWORK / SSH mode', action: 'mode' },
+  { cmd: '/todos',   desc: 'Show current todo list',                      action: 'todos' },
+  { cmd: '/skills',  desc: 'List available agent skills',                 action: 'skills' },
+  { cmd: '/exit',    desc: 'Exit the agent',                              action: 'exit' },
+  { cmd: '/logout',  desc: 'Log out and clear credentials',               action: 'logout' },
+];
+
+export const MODE_OPTIONS = [
+  { name: 'GENERAL', desc: 'System administration mode',               value: 'GENERAL' },
+  { name: 'CODING',  desc: 'Software engineering mode',                value: 'CODING'  },
+  { name: 'NETWORK', desc: 'Remote network device management',          value: 'NETWORK' },
+  { name: 'SSH',     desc: 'Remote execution via SSH',                 value: 'SSH'     },
+  { name: 'PLAN',    desc: 'Plan mode — read-only, no file modifications', value: 'PLAN' },
+  { name: 'EXEC',    desc: 'Exec mode — file modifications allowed',       value: 'EXEC'  },
+];
+
+export const executeSlashCommand = async (cmd, rl, userOS) => {
+  switch (cmd) {
+    case '/clear':   return { action: 'clear' };
+    case '/help':    return { action: 'help' };
+    case '/new':     return { action: 'new' };
+    case '/exit':    return { action: 'exit' };
+    case '/devices': return { action: 'devices' };
+    case '/provider': return { action: 'provider' };
+    case '/todos':   return { action: 'todos' };
+    case '/skills':  return { action: 'skills' };
+    case '/status':  return { action: 'status' };
+    case '/history': return { action: 'history' };
+    case '/save':    return { action: 'save' };
+    case '/stats':   return { action: 'stats' };
+    case '/context': return { action: 'context' };
+    case '/plan':    return { action: 'plan' };
+    case '/exec':    return { action: 'exec' };
+    case '/mode':    return { action: 'show_mode_picker' };
+    case '/logout':  return { action: 'logout' };
+    default:         return { action: 'none' };
+  }
+};
+
+export const showModePicker = async () => {
+  return { action: 'none' };
+};

package/src/ui/terminal.js

@@ -0,0 +1,41 @@
+import chalk from 'chalk';
+import boxen from 'boxen';
+
+export const printInfo = (msg) => console.log(chalk.blue('i ') + msg);
+export const printError = (msg) => console.error(chalk.red('x ') + msg);
+export const printSuccess = (msg) => console.log(chalk.green('✓ ') + msg);
+export const printHeader = () => {};
+export const printAuthHeader = (title, subtitle = '') => {
+  console.log(boxen(
+    chalk.hex('#7aa2f7').bold(`  ${title}`) +
+    (subtitle ? chalk.hex('#565f89').dim(`\n  ${subtitle}`) : ''),
+    { padding: 1, borderStyle: 'round', borderColor: '#4a9eff' }
+  ));
+};
+export const clearScreen = () => { process.stdout.write('\x1Bc'); };
+export const printDeviceList = () => {};
+export const renderInputFooter = () => {};
+export const printBoxHeaderOnly = () => {};
+export const printBoxedMessage = () => {};
+export const printShell = (msg) => console.log(msg);
+export const printPanel = (title, lines, colorFn) => {
+  const content = lines.join('\n');
+  const coloredTitle = colorFn ? colorFn(title) : title;
+  console.log(boxen(content, {
+    padding: { left: 2, right: 2 },
+    borderStyle: 'round',
+    borderColor: '#4a9eff',
+    title: coloredTitle,
+    titleAlignment: 'left',
+    float: 'left',
+  }));
+};
+export const printNotLoggedIn = () => {
+  console.log(boxen(
+    chalk.hex('#ff9e64')('  You are not logged in') +
+    chalk.hex('#c0caf5')('\n\n  Please authenticate:') +
+    chalk.white('\n    osai-agent login    ') + chalk.gray('Log in') +
+    chalk.white('\n    osai-agent register ') + chalk.gray('Create an account'),
+    { padding: 1, borderStyle: 'round', borderColor: '#ff9e64' }
+  ));
+};

package/src/ui/theme.js

@@ -0,0 +1,5 @@
+/** Fond cendre sombre pour les zones de saisie secondaires */
+export const INPUT_BACKGROUND = '#2b2d38';
+
+/** Fond noir cendré clair pour la saisie principale */
+export const MAIN_INPUT_BACKGROUND = '#202127';

package/src/ui/welcome.js

@@ -0,0 +1,12 @@
+import { APP_VERSION } from '../utils/constants.js';
+
+export const LOGO_LINES = [
+  '  ██████  ███████     █████  ██        █████   ██████  ███████ ███    ██ ████████',
+  '  ██   ██ ██         ██   ██ ██       ██   ██ ██       ██      ████   ██    ██   ',
+  '  ██   ██ ███████    ███████ ██       ███████ ██   ███ █████   ██ ██  ██    ██   ',
+  '  ██   ██      ██    ██   ██ ██       ██   ██ ██    ██ ██      ██  ██ ██    ██   ',
+  '  ██████  ███████    ██   ██ ██       ██   ██  ██████  ███████ ██   ████    ██   ',
+];
+
+export const TAGLINE = 'Your AI sysadmin, network engineer & senior developer \u2014 all in one CLI';
+export const VERSION = `v${APP_VERSION}`;

package/src/utils/constants.js

@@ -0,0 +1,231 @@
+// =============================================================================
+// OS AI Agent — Constants & Configuration
+// =============================================================================
+
+export const APP_NAME = 'osai-agent';
+export const APP_VERSION = '4.0.0';
+
+/** Default runtime parameters — can be overridden via environment variables */
+export const DEFAULTS = {
+  MAX_ITERATIONS: 100,
+  AUTO_CONTINUE_LIMIT: 10,
+  COMMAND_TIMEOUT: 30000,
+  FILE_READ_TIMEOUT: 10000,
+  MAX_OUTPUT_LINES: 50,
+  MAX_TOOL_RESULT_LENGTH: 12000,
+  WS_RECONNECT_MAX_DELAY: 20000,
+  WS_RECONNECT_BASE_DELAY: 1000,
+  WS_RECONNECT_MAX_ATTEMPTS: 5,
+  SSH_INACTIVITY_TIMEOUT: 300000,
+  SSH_COMMAND_TIMEOUT: 30000,
+  API_RETRY_ATTEMPTS: 5,
+  API_RETRY_DELAY: 1500,
+  MAX_COMMAND_HISTORY: 1000,
+  MAX_MEMORY_ENTRIES: 500,
+  AGENT_LOOP_RETRY: 2,
+  CONTEXT_COMPACT_THRESHOLD: 0.8,
+  ESTIMATED_CONTEXT_WINDOW: 128000,
+  FETCH_TIMEOUT: 15000,
+  MAX_TODOS: 50,
+};
+
+/** Tool identifiers used in JSON tool calls from the LLM */
+export const TOOLS = {
+  // Existing tools
+  LOCAL_CMD: 'LOCAL_CMD',
+  SSH_CMD: 'SSH_CMD',
+  READ_FILE: 'READ_FILE',
+  WRITE_FILE: 'WRITE_FILE',
+  EDIT_FILE: 'EDIT_FILE',
+  LIST_DIR: 'LIST_DIR',
+  // Legacy — mapped to LOCAL_CMD in extractToolCalls, not exposed in prompts
+  POWERSHELL: 'POWERSHELL',
+  // Coding tools
+  SEARCH_FILE: 'SEARCH_FILE',
+  APPEND_FILE: 'APPEND_FILE',
+  DELETE_FILE: 'DELETE_FILE',
+  CREATE_DIR: 'CREATE_DIR',
+  TREE_VIEW: 'TREE_VIEW',
+  RUN_SCRIPT: 'RUN_SCRIPT',
+  MOVE_FILE: 'MOVE_FILE',
+  COPY_FILE: 'COPY_FILE',
+  FILE_INFO: 'FILE_INFO',
+  // Web tools
+  FETCH_URL: 'FETCH_URL',
+  WEB_SEARCH: 'WEB_SEARCH',
+  // Browser tools (Playwright + HTTP fallback)
+  BROWSE: 'BROWSE',
+  BROWSE_SEARCH: 'BROWSE_SEARCH',
+  BROWSE_EXTRACT: 'BROWSE_EXTRACT',
+  // Todo tools
+  TODO_ADD: 'TODO_ADD',
+  TODO_COMPLETE: 'TODO_COMPLETE',
+  TODO_UPDATE: 'TODO_UPDATE',
+  TODO_LIST: 'TODO_LIST',
+  TODO_CLEAR: 'TODO_CLEAR',
+  // New coding tools
+  GLOB: 'GLOB',
+  GREP: 'GREP',
+  GIT: 'GIT',
+  DIAG_POST_EDIT: 'DIAG_POST_EDIT',
+  ASK_USER: 'ASK_USER',
+  PLAN_MODE: 'PLAN_MODE',
+  DIR_CHANGE: 'DIR_CHANGE',
+  GET_DEPENDENCIES: 'GET_DEPENDENCIES',
+  MCP_TOOL: 'MCP_TOOL',
+  // Skills & subagent
+  SKILL_LIST: 'SKILL_LIST',
+  LOAD_SKILL: 'LOAD_SKILL',
+  CREATE_SKILL: 'CREATE_SKILL',
+  TASK: 'TASK',
+};
+
+/** Max iterations for a read-only subagent */
+export const SUBAGENT_MAX_ITERATIONS = parseInt(process.env.OSAI_SUBAGENT_MAX_ITERATIONS) || 25;
+
+/** Completion signals that the LLM uses to indicate task status */
+export const COMPLETION_SIGNALS = {
+  DONE: 'DONE',
+  INCOMPLETE: 'INCOMPLETE',
+  BLOCKED: 'BLOCKED',
+};
+
+/** Safety tier classifications for command risk assessment */
+export const SAFETY_TIERS = {
+  READ: 'READ',
+  WRITE: 'WRITE',
+  DANGEROUS: 'DANGEROUS',
+  ASK: 'ASK',
+};
+
+/** Agent execution modes */
+export const MODES = {
+  SSH: 'SSH',
+  GENERAL: 'GENERAL',
+  NETWORK: 'NETWORK',
+  CODING: 'CODING',
+};
+
+/** Execution sub-modes — PLAN (read-only, no modifications) / EXEC (normal) */
+export const EXECUTION_MODES = {
+  PLAN: 'PLAN',
+  EXEC: 'EXEC',
+};
+
+/** Environment variable names the agent recognises */
+export const ENV_VARS = {
+  DEBUG: 'OSAI_DEBUG',
+  VERBOSE: 'OSAI_VERBOSE',
+  MAX_ITERATIONS: 'OSAI_MAX_ITERATIONS',
+  AUTO_CONTINUE: 'OSAI_AUTO_CONTINUE',
+  COMMAND_TIMEOUT: 'OSAI_COMMAND_TIMEOUT',
+  AES_SECRET: 'AES_SECRET',
+  JSON_OUTPUT: 'OSAI_JSON',
+};
+
+/** Set of tool names that are inherently read-only (no confirmation needed) */
+export const READ_ONLY_TOOLS = new Set([
+  TOOLS.READ_FILE, TOOLS.LIST_DIR, TOOLS.SEARCH_FILE,
+  TOOLS.TREE_VIEW, TOOLS.FILE_INFO, TOOLS.FETCH_URL,
+  TOOLS.WEB_SEARCH, TOOLS.TODO_LIST,
+  TOOLS.GLOB, TOOLS.GREP, TOOLS.DIAG_POST_EDIT, TOOLS.ASK_USER, TOOLS.PLAN_MODE,
+  TOOLS.BROWSE, TOOLS.BROWSE_SEARCH, TOOLS.BROWSE_EXTRACT,
+  TOOLS.DIR_CHANGE,
+  TOOLS.GET_DEPENDENCIES,
+  TOOLS.MCP_TOOL,
+  TOOLS.SKILL_LIST, TOOLS.LOAD_SKILL, TOOLS.CREATE_SKILL, TOOLS.TASK,
+]);
+
+/** Tools allowed inside a read-only subagent */
+export const SUBAGENT_ALLOWED_TOOLS = new Set([
+  TOOLS.READ_FILE, TOOLS.LIST_DIR, TOOLS.SEARCH_FILE, TOOLS.TREE_VIEW, TOOLS.FILE_INFO,
+  TOOLS.FETCH_URL, TOOLS.WEB_SEARCH, TOOLS.GLOB, TOOLS.GREP, TOOLS.GET_DEPENDENCIES,
+  TOOLS.BROWSE, TOOLS.BROWSE_SEARCH, TOOLS.BROWSE_EXTRACT,
+  TOOLS.SKILL_LIST, TOOLS.LOAD_SKILL,
+  TOOLS.LOCAL_CMD, TOOLS.GIT,
+]);
+
+/** Write tools that modify files but are safe in coding context */
+export const CODING_TOOLS = new Set([
+  TOOLS.LOCAL_CMD, TOOLS.READ_FILE, TOOLS.WRITE_FILE, TOOLS.EDIT_FILE,
+  TOOLS.LIST_DIR, TOOLS.SEARCH_FILE, TOOLS.APPEND_FILE, TOOLS.DELETE_FILE,
+  TOOLS.CREATE_DIR, TOOLS.TREE_VIEW, TOOLS.RUN_SCRIPT, TOOLS.MOVE_FILE,
+  TOOLS.COPY_FILE, TOOLS.FILE_INFO, TOOLS.FETCH_URL, TOOLS.WEB_SEARCH,
+  TOOLS.TODO_ADD, TOOLS.TODO_COMPLETE, TOOLS.TODO_UPDATE, TOOLS.TODO_LIST,
+  TOOLS.TODO_CLEAR, TOOLS.GLOB, TOOLS.GREP, TOOLS.GIT, TOOLS.DIAG_POST_EDIT,
+  TOOLS.ASK_USER, TOOLS.PLAN_MODE,
+  TOOLS.BROWSE, TOOLS.BROWSE_SEARCH, TOOLS.BROWSE_EXTRACT,
+  TOOLS.DIR_CHANGE,
+  TOOLS.MCP_TOOL,
+  TOOLS.CREATE_SKILL,
+  TOOLS.TASK,
+]);
+
+/** All known tool names for regex extraction */
+export const ALL_TOOL_NAMES = Object.values(TOOLS);
+
+/** Cross-platform shell configuration */
+export const SHELL = {
+  windows: { name: 'cmd.exe', flag: '/c' },
+  macos: { name: '/bin/zsh', flag: '-c' },
+  linux: { name: '/bin/sh', flag: '-c' },
+};
+
+/** Filenames explicitly excluded from critical env detection (safe to read) */
+export const CRITICAL_ENV_EXCLUDE = new Set([
+  '.env.example',
+]);
+
+/** Patterns for critical environment variable / secret files */
+export const CRITICAL_ENV_FILENAMES = new Set([
+  '.env', '.env.local', '.env.development', '.env.production',
+  '.env.staging', '.env.test', '.env.docker', '.env.cloud',
+  'credentials.json', 'credentials.yml', 'credentials.yaml',
+  'secrets.json', 'secrets.yml', 'secrets.yaml', 'secret.json',
+  '.netrc', '_netrc', '.npmrc', '.yarnrc.yml',
+  'id_rsa', 'id_rsa.pub', 'id_ed25519', 'id_ed25519.pub',
+  'authorized_keys', 'known_hosts',
+  'config.json',
+]);
+
+export const CRITICAL_ENV_FILENAME_PATTERNS = [
+  /^\.env\b/,
+  /\.pem$/i,
+  /\.key$/i,
+  /^id_rsa/,
+  /^id_ed25519/,
+  /^application_default_credentials\.json$/i,
+  /^credentials\.(json|yml|yaml)$/i,
+  /^secrets\.(json|yml|yaml)$/i,
+];
+
+export const CRITICAL_ENV_PATH_SEGMENTS = [
+  '.config', '.aws', '.azure', '.gcloud', '.kube', '.docker',
+  'credentials', 'secrets',
+];
+
+/** Device type categories for network mode */
+export const DEVICE_TYPES = {
+  CISCO_IOS: 'Cisco IOS',
+  CISCO_IOS_XE: 'Cisco IOS-XE',
+  CISCO_NX_OS: 'Cisco NX-OS',
+  CISCO_ASA: 'Cisco ASA',
+  MIKROTIK: 'MikroTik RouterOS',
+  PFSENSE: 'pfSense',
+  JUNOS: 'Juniper JunOS',
+  LINUX: 'Linux',
+  WINDOWS: 'Windows Server',
+};
+
+// Agent loop constants
+export const MAX_ITERATIONS = parseInt(process.env.OSAI_MAX_ITERATIONS) || DEFAULTS.MAX_ITERATIONS;
+export const AUTO_CONTINUE_LIMIT = parseInt(process.env.OSAI_AUTO_CONTINUE) || DEFAULTS.AUTO_CONTINUE_LIMIT;
+export const READ_FRESHNESS_INTERACTIONS = 20;
+export const MAX_PERSISTED_READ_FILES = 200;
+export const TOOL_SEQUENCE_WINDOW_SIZE = 6;
+export const HISTORY_SUMMARY_TRIGGER_TOKENS = 9600;
+export const HISTORY_SUMMARY_KEEP_RECENT_TOKENS = 2000;
+export const HISTORY_SUMMARY_MIN_GROWTH_TOKENS = 1000;
+export const MAX_CONTEXT_TOKENS = 12800;
+export const MAX_CONTEXT_SUMMARY_CHARS = 4000;
+export const CONTEXT_SUMMARY_TAG = '[CONTEXT_SUMMARY]';