icopilot 2.2.0

package/dist/util/completion.js

@@ -0,0 +1,350 @@
+import { loadCustomAgents } from '../agents/custom-agents.js';
+const defaultSlashCommands = [
+    'help',
+    'clear',
+    'new',
+    'goal',
+    'model',
+    'provider',
+    'cwd',
+    'diff',
+    'changes',
+    'diff-review',
+    'git-log',
+    'context',
+    'usage',
+    'pin',
+    'unpin',
+    'read-only',
+    'ro',
+    'every',
+    'after',
+    'schedule',
+    'tokens',
+    'editor',
+    'reasoning',
+    'think-tokens',
+    'compact',
+    'settings',
+    'feedback',
+    'sessions',
+    'cloud',
+    'export',
+    'share',
+    'paste',
+    'copy',
+    'copy-context',
+    'handoff',
+    'plan',
+    'edit-format',
+    'commit',
+    'pr',
+    'review',
+    'issue',
+    'branch',
+    'index',
+    'rag',
+    'search',
+    'goto',
+    'refs',
+    'route',
+    'undo',
+    'redo',
+    'cost',
+    'snippets',
+    'profile',
+    'role',
+    'style',
+    'conventions',
+    'stats',
+    'metrics',
+    'audit',
+    'explain',
+    'explain-shell',
+    'suggest',
+    'generate',
+    'actions',
+    'codegen',
+    'summary',
+    'agent',
+    'explore',
+    'compare',
+    'env',
+    'trigger',
+    'template',
+    'readme',
+    'changelog',
+    'release',
+    'fix',
+    'heal',
+    'lint',
+    'test',
+    'auto-lint',
+    'auto-test',
+    'auto-fix',
+    'doctor',
+    'tdd',
+    'task',
+    'tasks',
+    'todo',
+    'deps',
+    'init',
+    'security',
+    'proxy',
+    'filter',
+    'retention',
+    'dead-code',
+    'refactor',
+    'stacktrace',
+    'history',
+    'bookmark',
+    'alias',
+    'skill',
+    'stash',
+    'multi',
+    'parallel',
+    'watch',
+    'web',
+    'run',
+    'bridge',
+    'error-watch',
+    'memory',
+    'corrections',
+    'repo',
+    'hook',
+    'team-memory',
+    'space',
+    'doc',
+    'diagram',
+    'extension',
+    'serve',
+    'worktree',
+    'plugin',
+    'workflow',
+    'sandbox',
+    'ask',
+    'code',
+    'architect',
+    'exit',
+    'quit',
+];
+const defaultFlags = [
+    '-p',
+    '--prompt',
+    '--model',
+    '--provider',
+    '--base-url',
+    '--local',
+    '--provider',
+    '--cwd',
+    '--sandbox',
+    '--tui',
+    '--architect',
+    '--verbose',
+    '--serve',
+    '--browser',
+    '--help',
+    '--version',
+];
+const defaultAgentNames = ['explore', 'task', 'review', 'plan'];
+const undoArgs = ['--hard', 'file', 'status'];
+const defaultSlashSubcommands = {
+    memory: ['list', 'add', 'remove', 'clear', 'search', 'auto'],
+    'memory auto': ['list', 'clear', 'forget'],
+};
+export function defaultContext(projectRoot = process.cwd()) {
+    const customAgentNames = safeCustomAgentNames(projectRoot);
+    return {
+        slashCommands: [...defaultSlashCommands],
+        flags: [...defaultFlags],
+        agentNames: [...new Set([...defaultAgentNames, ...customAgentNames])],
+        slashSubcommands: structuredClone(defaultSlashSubcommands),
+    };
+}
+export function bashCompletion(ctx = defaultContext()) {
+    const commands = ctx.slashCommands
+        .map((command) => `/${command}`)
+        .map(bashWord)
+        .join(' ');
+    const flags = ctx.flags.map(bashWord).join(' ');
+    const agentNames = ctx.agentNames.map(bashWord).join(' ');
+    const undoOptions = undoArgs.map(bashWord).join(' ');
+    const memorySubcommands = (ctx.slashSubcommands.memory ?? []).map(bashWord).join(' ');
+    const memoryAutoSubcommands = (ctx.slashSubcommands['memory auto'] ?? []).map(bashWord).join(' ');
+    const bashCompWordCur = '${COMP_WORDS[COMP_CWORD]}';
+    const bashCompWordPrev = '${COMP_WORDS[COMP_CWORD-1]}';
+    const bashCompWordPrevPrev = '${COMP_WORDS[COMP_CWORD-2]}';
+    return `# bash completion for icopilot and icli
+_icopilot() {
+  local cur prev
+  COMPREPLY=()
+
+  if type _init_completion >/dev/null 2>&1; then
+    _init_completion -n : || return
+  else
+    cur="${bashCompWordCur}"
+    prev="${bashCompWordPrev}"
+  fi
+
+  local slash_commands='${commands}'
+  local flags='${flags}'
+  local agent_names='${agentNames}'
+  local undo_args='${undoOptions}'
+  local memory_subcommands='${memorySubcommands}'
+  local memory_auto_subcommands='${memoryAutoSubcommands}'
+
+  if [[ "$prev" == "/agent" ]]; then
+    COMPREPLY=( $(compgen -W "$agent_names" -- "$cur") )
+    return
+  fi
+
+  if [[ "$prev" == "/undo" ]]; then
+    COMPREPLY=( $(compgen -W "$undo_args" -- "$cur") )
+    return
+  fi
+
+  if [[ "$prev" == "/memory" ]]; then
+    COMPREPLY=( $(compgen -W "$memory_subcommands" -- "$cur") )
+    return
+  fi
+
+  if [[ "$prev" == "auto" && "${bashCompWordPrevPrev}" == "/memory" ]]; then
+    COMPREPLY=( $(compgen -W "$memory_auto_subcommands" -- "$cur") )
+    return
+  fi
+
+  case "$cur" in
+    /*)
+      COMPREPLY=( $(compgen -W "$slash_commands" -- "$cur") )
+      return
+      ;;
+    -* )
+      COMPREPLY=( $(compgen -W "$flags" -- "$cur") )
+      return
+      ;;
+  esac
+
+  if declare -F _filedir >/dev/null 2>&1; then
+    _filedir
+  fi
+}
+
+complete -F _icopilot icopilot icli
+`;
+}
+export function zshCompletion(ctx = defaultContext()) {
+    const commands = ctx.slashCommands
+        .map((command) => `/${command}`)
+        .map(zshSingleQuoted)
+        .join(' ');
+    const flagSpecs = ctx.flags
+        .map((flag) => `    ${zshSingleQuoted(`${flag}[icopilot option]`)} \\\n`)
+        .join('');
+    const agentNames = ctx.agentNames.map(zshSingleQuoted).join(' ');
+    const undoOptions = undoArgs.map(zshSingleQuoted).join(' ');
+    const memorySubcommands = (ctx.slashSubcommands.memory ?? []).map(zshSingleQuoted).join(' ');
+    const memoryAutoSubcommands = (ctx.slashSubcommands['memory auto'] ?? [])
+        .map(zshSingleQuoted)
+        .join(' ');
+    return `#compdef icopilot icli
+
+_icopilot() {
+  local -a slash_commands
+  slash_commands=(${commands})
+  local -a agent_names
+  agent_names=(${agentNames})
+  local -a undo_args
+  undo_args=(${undoOptions})
+  local -a memory_subcommands
+  memory_subcommands=(${memorySubcommands})
+  local -a memory_auto_subcommands
+  memory_auto_subcommands=(${memoryAutoSubcommands})
+
+  _arguments \\
+${flagSpecs}    '*::arg:->args'
+
+  case $state in
+    args)
+      if (( CURRENT >= 2 )) && [[ \${words[CURRENT-1]} == /agent ]]; then
+        compadd -- $agent_names
+      elif (( CURRENT >= 2 )) && [[ \${words[CURRENT-1]} == /undo ]]; then
+        compadd -- $undo_args
+      elif (( CURRENT >= 2 )) && [[ \${words[CURRENT-1]} == /memory ]]; then
+        compadd -- $memory_subcommands
+      elif (( CURRENT >= 3 )) && [[ \${words[CURRENT-2]} == /memory && \${words[CURRENT-1]} == auto ]]; then
+        compadd -- $memory_auto_subcommands
+      elif [[ $PREFIX == /* ]]; then
+        compadd -- $slash_commands
+      else
+        _files
+      fi
+      ;;
+  esac
+}
+
+_icopilot "$@"
+`;
+}
+export function pwshCompletion(ctx = defaultContext()) {
+    const commands = ctx.slashCommands
+        .map((command) => `/${command}`)
+        .map(pwshSingleQuoted)
+        .join(', ');
+    const flags = ctx.flags.map(pwshSingleQuoted).join(', ');
+    const agentNames = ctx.agentNames.map(pwshSingleQuoted).join(', ');
+    const undoOptions = undoArgs.map(pwshSingleQuoted).join(', ');
+    const memorySubcommands = (ctx.slashSubcommands.memory ?? []).map(pwshSingleQuoted).join(', ');
+    const memoryAutoSubcommands = (ctx.slashSubcommands['memory auto'] ?? [])
+        .map(pwshSingleQuoted)
+        .join(', ');
+    return `# PowerShell completion for icopilot and icli
+Register-ArgumentCompleter -Native -CommandName icopilot,icli -ScriptBlock {
+  param($wordToComplete, $commandAst, $cursorPosition)
+
+  $slashCommands = @(${commands})
+  $flags = @(${flags})
+  $agentNames = @(${agentNames})
+  $undoArgs = @(${undoOptions})
+  $memorySubcommands = @(${memorySubcommands})
+  $memoryAutoSubcommands = @(${memoryAutoSubcommands})
+  $elements = @($commandAst.CommandElements | ForEach-Object { $_.Extent.Text })
+
+  if ($elements.Count -ge 2 -and $elements[$elements.Count - 2] -eq '/agent') {
+    $candidates = $agentNames
+  } elseif ($elements.Count -ge 2 -and $elements[$elements.Count - 2] -eq '/undo') {
+    $candidates = $undoArgs
+  } elseif ($elements.Count -ge 2 -and $elements[$elements.Count - 2] -eq '/memory') {
+    $candidates = $memorySubcommands
+  } elseif ($elements.Count -ge 3 -and $elements[$elements.Count - 3] -eq '/memory' -and $elements[$elements.Count - 2] -eq 'auto') {
+    $candidates = $memoryAutoSubcommands
+  } elseif ($wordToComplete -like '/*') {
+    $candidates = $slashCommands
+  } elseif ($wordToComplete -like '-*') {
+    $candidates = $flags
+  } else {
+    $candidates = $slashCommands + $flags
+  }
+
+  $candidates |
+    Where-Object { $_ -like "$wordToComplete*" } |
+    ForEach-Object { [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_) }
+}
+`;
+}
+function bashWord(value) {
+    return value.replace(/[\\'"$`\s]/g, '\\$&');
+}
+function zshSingleQuoted(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function pwshSingleQuoted(value) {
+    return `'${value.replace(/'/g, `''`)}'`;
+}
+function safeCustomAgentNames(projectRoot) {
+    try {
+        return loadCustomAgents(projectRoot).map((agent) => agent.name);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/util/cost.js

@@ -0,0 +1,28 @@
+export const RATES = {
+    'gpt-4o': { input: 2.5, output: 10 },
+    'gpt-4o-mini': { input: 0.15, output: 0.6 },
+    'gpt-4.1': { input: 2, output: 8 },
+    'gpt-4.1-mini': { input: 0.4, output: 1.6 },
+    o1: { input: 15, output: 60 },
+    'o1-mini': { input: 1.1, output: 4.4 },
+    'o3-mini': { input: 1.1, output: 4.4 },
+};
+export const DEFAULT_RATE = { input: 1, output: 3 };
+export function getRate(model) {
+    const normalized = model.trim().toLowerCase();
+    const match = Object.entries(RATES)
+        .sort(([a], [b]) => b.length - a.length)
+        .find(([name]) => normalized.startsWith(name.toLowerCase()));
+    return match?.[1] ?? DEFAULT_RATE;
+}
+export function estimateCost(model, inputTokens, outputTokens) {
+    const rate = getRate(model);
+    return (inputTokens / 1000) * rate.input + (outputTokens / 1000) * rate.output;
+}
+export function formatUsd(n) {
+    if (n > 0 && n < 0.0001)
+        return '<$0.0001';
+    if (n < 1)
+        return `$${n.toFixed(4)}`;
+    return `$${n.toFixed(2)}`;
+}

package/dist/util/keybindings.js

@@ -0,0 +1,113 @@
+/**
+ * Vi and Emacs keybinding support for readline-based REPL.
+ * Provides modal editing (vi) and extended key sequences (emacs).
+ */
+import { config } from '../config.js';
+const DEFAULT_KEYMAP = {
+    emacs: 'EMACS',
+    vi: 'VI',
+    default: 'DEFAULT',
+};
+/**
+ * Enhance readline interface with vi/emacs keybindings.
+ * Note: Node's readline has limited key handling. This provides
+ * basic support through key event listeners and buffer manipulation.
+ */
+export function attachKeybindings(rl, mode = 'default') {
+    if (mode === 'default') {
+        return { mode: 'default', viMode: 'insert', buffer: '', cursor: 0 };
+    }
+    const state = {
+        mode,
+        viMode: 'insert',
+        buffer: '',
+        cursor: 0,
+    };
+    // Node.js readline doesn't expose raw key events in a portable way.
+    // Instead, we provide integration points that applications can use.
+    // For full vi/emacs support, users should use a readline alternative like ink or blessed.
+    // Store reference to readline for applications to integrate with.
+    rl.__keybindingMode = mode;
+    rl.__keybindingState = state;
+    return state;
+}
+/**
+ * Check if readline interface has keybindings attached.
+ */
+export function hasKeybindings(rl) {
+    return !!rl.__keybindingMode && rl.__keybindingMode !== 'default';
+}
+/**
+ * Get current keybinding mode.
+ */
+export function getKeybindingMode(rl) {
+    return rl.__keybindingMode ?? 'default';
+}
+/**
+ * Guide text for keybindings.
+ */
+export function getKeybindingHelp(mode) {
+    if (mode === 'vi') {
+        return `
+Vi keybindings enabled.
+  ESC        enter normal mode
+  i          insert mode
+  dd         delete line
+  yy         yank (copy) line
+  p          paste
+  h/j/k/l    navigation
+  0/$        go to start/end of line
+  A/I        append/insert at line end/start
+  u          undo
+
+Type '/help keybindings' for more info.
+`;
+    }
+    else if (mode === 'emacs') {
+        return `
+Emacs keybindings enabled.
+  C-a        go to line start
+  C-e        go to line end
+  C-k        kill to line end
+  C-u        kill from line start
+  C-w        kill word
+  M-d        delete word
+  C-y        yank (paste)
+  C-r        search history
+
+Type '/help keybindings' for more info.
+`;
+    }
+    return 'Default keybindings enabled. Type "/help keybindings" for more info.\n';
+}
+/**
+ * Get recommended readline options for keybinding mode.
+ * These work with native Node readline, but for full vi/emacs experience,
+ * use a library like ink, blessed, or rustyline (via wasm).
+ */
+export function getReadlineOptionsForMode(mode) {
+    // Node.js readline has limited keybinding support.
+    // In native mode, only basic Ctrl sequences work.
+    // Full vi/emacs would require a wrapper library.
+    return {
+        terminal: true,
+        historySize: 500,
+    };
+}
+/**
+ * Apply keybinding configuration from .icopilotrc.
+ */
+export function applyKeybindingConfig() {
+    const mode = config.keybindings?.mode ?? 'default';
+    if (mode !== 'vi' && mode !== 'emacs' && mode !== 'default') {
+        return 'default';
+    }
+    return mode;
+}
+/**
+ * Format keybinding info for display.
+ */
+export function formatKeybindingInfo(mode) {
+    const modeLabel = mode === 'vi' ? '🔤 Vi' : mode === 'emacs' ? '🔤 Emacs' : '⌨️  Default';
+    return `${modeLabel} mode`;
+}

package/dist/util/lazy.js

@@ -0,0 +1,26 @@
+export function lazy(loader) {
+    let promise = null;
+    let value;
+    let loaded = false;
+    return async () => {
+        if (loaded)
+            return value;
+        promise ??= loader().then((result) => {
+            value = result;
+            loaded = true;
+            return result;
+        });
+        return promise;
+    };
+}
+export function lazySync(loader) {
+    let loaded = false;
+    let value;
+    return () => {
+        if (!loaded) {
+            value = loader();
+            loaded = true;
+        }
+        return value;
+    };
+}

package/dist/util/perf.js

@@ -0,0 +1,25 @@
+const START = process.hrtime.bigint();
+const MODULE_LOAD_MS = process.uptime() * 1_000;
+let reported = false;
+let tracingEnabled = Boolean(process.env.ICOPILOT_PERF_TRACE) || process.argv.includes('--perf-trace');
+export function enablePerfTrace() {
+    tracingEnabled = true;
+    process.env.ICOPILOT_PERF_TRACE = '1';
+}
+export function elapsedMs() {
+    return Number(process.hrtime.bigint() - START) / 1_000_000;
+}
+export function reportColdStart(label = 'cold-start') {
+    if (!tracingEnabled)
+        return;
+    process.stderr.write(`[perf] process start → ${label}: ${process.uptime().toFixed(1)}ms\n`);
+}
+export function markFirstPrompt(label = 'first prompt ready') {
+    if (reported || !tracingEnabled)
+        return;
+    reported = true;
+    const firstPromptMs = process.uptime() * 1_000;
+    process.stderr.write(`[perf] process start → module load: ${MODULE_LOAD_MS.toFixed(1)}ms\n`);
+    process.stderr.write(`[perf] module load → ${label}: ${(firstPromptMs - MODULE_LOAD_MS).toFixed(1)}ms\n`);
+    process.stderr.write(`[perf] process start → ${label}: ${firstPromptMs.toFixed(1)}ms\n`);
+}

package/dist/util/token-worker.js

@@ -0,0 +1,11 @@
+import { parentPort } from 'node:worker_threads';
+import { encode } from 'gpt-tokenizer';
+parentPort?.on('message', (message) => {
+    try {
+        const text = typeof message.text === 'string' ? message.text : '';
+        parentPort?.postMessage({ count: encode(text).length });
+    }
+    catch (error) {
+        parentPort?.postMessage({ error: String(error?.message || error) });
+    }
+});

package/dist/util/tokens.js

@@ -0,0 +1,50 @@
+import { Worker } from 'node:worker_threads';
+import { lazy } from './lazy.js';
+let _cachedEncode = null;
+const loadTokenizer = lazy(async () => {
+    const encode = (await import('gpt-tokenizer')).encode;
+    _cachedEncode = encode;
+    return encode;
+});
+export async function countTokens(text) {
+    if (text.length > 200_000 && Worker) {
+        return countTokensInWorker(text);
+    }
+    const encode = await loadTokenizer();
+    return encode(text).length;
+}
+/**
+ * Count tokens when the caller cannot await dynamic tokenizer loading.
+ *
+ * If the async tokenizer cache has already been warmed, this returns the exact
+ * tokenizer count. Otherwise it returns the existing length/4 heuristic to keep
+ * synchronous call sites cold-start friendly.
+ */
+export function countTokensSync(text) {
+    if (_cachedEncode)
+        return _cachedEncode(text).length;
+    return Math.ceil(text.length / 4);
+}
+export async function primeTokenizer() {
+    await loadTokenizer();
+}
+function countTokensInWorker(text) {
+    return new Promise((resolve, reject) => {
+        const worker = new Worker(new URL('./token-worker.js', import.meta.url));
+        worker.once('message', (message) => {
+            if (typeof message.count === 'number') {
+                resolve(message.count);
+            }
+            else {
+                reject(new Error(message.error || 'token worker failed'));
+            }
+            void worker.terminate();
+        });
+        worker.once('error', reject);
+        worker.once('exit', (code) => {
+            if (code !== 0)
+                reject(new Error(`token worker exited with code ${code}`));
+        });
+        worker.postMessage({ text });
+    });
+}