@iaforged/context-code 1.0.63 → 1.0.65

package/dist/src/utils/bash/parser.js

@@ -1,195 +0,0 @@
-import { feature } from '../../recovery/bunBundleShim.js';
-import { logEvent } from '../../services/analytics/index.js';
-import { logForDebugging } from '../debug.js';
-import { ensureParserInitialized, getParserModule, } from './bashParser.js';
-const MAX_COMMAND_LENGTH = 10000;
-const DECLARATION_COMMANDS = new Set([
-    'export',
-    'declare',
-    'typeset',
-    'readonly',
-    'local',
-    'unset',
-    'unsetenv',
-]);
-const ARGUMENT_TYPES = new Set(['word', 'string', 'raw_string', 'number']);
-const SUBSTITUTION_TYPES = new Set([
-    'command_substitution',
-    'process_substitution',
-]);
-const COMMAND_TYPES = new Set(['command', 'declaration_command']);
-let logged = false;
-function logLoadOnce(success) {
-    if (logged)
-        return;
-    logged = true;
-    logForDebugging(success ? 'tree-sitter: native module loaded' : 'tree-sitter: unavailable');
-    logEvent('tengu_tree_sitter_load', { success });
-}
-/**
- * Awaits WASM init (Parser.init + Language.load). Must be called before
- * parseCommand/parseCommandRaw for the parser to be available. Idempotent.
- */
-export async function ensureInitialized() {
-    if (feature('TREE_SITTER_BASH') || feature('TREE_SITTER_BASH_SHADOW')) {
-        await ensureParserInitialized();
-    }
-}
-export async function parseCommand(command) {
-    if (!command || command.length > MAX_COMMAND_LENGTH)
-        return null;
-    // Gate: ant-only until pentest. External builds fall back to legacy
-    // regex/shell-quote path. Guarding the whole body inside the positive
-    // branch lets Bun DCE the NAPI import AND keeps telemetry honest — we
-    // only fire tengu_tree_sitter_load when a load was genuinely attempted.
-    if (feature('TREE_SITTER_BASH')) {
-        await ensureParserInitialized();
-        const mod = getParserModule();
-        logLoadOnce(mod !== null);
-        if (!mod)
-            return null;
-        try {
-            const rootNode = mod.parse(command);
-            if (!rootNode)
-                return null;
-            const commandNode = findCommandNode(rootNode, null);
-            const envVars = extractEnvVars(commandNode);
-            return { rootNode, envVars, commandNode, originalCommand: command };
-        }
-        catch {
-            return null;
-        }
-    }
-    return null;
-}
-/**
- * SECURITY: Sentinel for "parser was loaded and attempted, but aborted"
- * (timeout / node budget / Rust panic). Distinct from `null` (module not
- * loaded). Adversarial input can trigger abort under MAX_COMMAND_LENGTH:
- * `(( a[0][0]... ))` with ~2800 subscripts hits PARSE_TIMEOUT_MICROS.
- * Callers MUST treat this as fail-closed (too-complex), NOT route to legacy.
- */
-export const PARSE_ABORTED = Symbol('parse-aborted');
-/**
- * Raw parse — skips findCommandNode/extractEnvVars which the security
- * walker in ast.ts doesn't use. Saves one tree walk per bash command.
- *
- * Returns:
- *   - Node: parse succeeded
- *   - null: module not loaded / feature off / empty / over-length
- *   - PARSE_ABORTED: module loaded but parse failed (timeout/panic)
- */
-export async function parseCommandRaw(command) {
-    if (!command || command.length > MAX_COMMAND_LENGTH)
-        return null;
-    if (feature('TREE_SITTER_BASH') || feature('TREE_SITTER_BASH_SHADOW')) {
-        await ensureParserInitialized();
-        const mod = getParserModule();
-        logLoadOnce(mod !== null);
-        if (!mod)
-            return null;
-        try {
-            const result = mod.parse(command);
-            // SECURITY: Module loaded; null here = timeout/node-budget abort in
-            // bashParser.ts (PARSE_TIMEOUT_MS=50, MAX_NODES=50_000).
-            // Previously collapsed into `return null` → parse-unavailable → legacy
-            // path, which lacks EVAL_LIKE_BUILTINS — `trap`, `enable`, `hash` leaked.
-            if (result === null) {
-                logEvent('tengu_tree_sitter_parse_abort', {
-                    cmdLength: command.length,
-                    panic: false,
-                });
-                return PARSE_ABORTED;
-            }
-            return result;
-        }
-        catch {
-            logEvent('tengu_tree_sitter_parse_abort', {
-                cmdLength: command.length,
-                panic: true,
-            });
-            return PARSE_ABORTED;
-        }
-    }
-    return null;
-}
-function findCommandNode(node, parent) {
-    const { type, children } = node;
-    if (COMMAND_TYPES.has(type))
-        return node;
-    // Variable assignment followed by command
-    if (type === 'variable_assignment' && parent) {
-        return (parent.children.find(c => COMMAND_TYPES.has(c.type) && c.startIndex > node.startIndex) ?? null);
-    }
-    // Pipeline: recurse into first child (which may be a redirected_statement)
-    if (type === 'pipeline') {
-        for (const child of children) {
-            const result = findCommandNode(child, node);
-            if (result)
-                return result;
-        }
-        return null;
-    }
-    // Redirected statement: find the command inside
-    if (type === 'redirected_statement') {
-        return children.find(c => COMMAND_TYPES.has(c.type)) ?? null;
-    }
-    // Recursive search
-    for (const child of children) {
-        const result = findCommandNode(child, node);
-        if (result)
-            return result;
-    }
-    return null;
-}
-function extractEnvVars(commandNode) {
-    if (!commandNode || commandNode.type !== 'command')
-        return [];
-    const envVars = [];
-    for (const child of commandNode.children) {
-        if (child.type === 'variable_assignment') {
-            envVars.push(child.text);
-        }
-        else if (child.type === 'command_name' || child.type === 'word') {
-            break;
-        }
-    }
-    return envVars;
-}
-export function extractCommandArguments(commandNode) {
-    // Declaration commands
-    if (commandNode.type === 'declaration_command') {
-        const firstChild = commandNode.children[0];
-        return firstChild && DECLARATION_COMMANDS.has(firstChild.text)
-            ? [firstChild.text]
-            : [];
-    }
-    const args = [];
-    let foundCommandName = false;
-    for (const child of commandNode.children) {
-        if (child.type === 'variable_assignment')
-            continue;
-        // Command name
-        if (child.type === 'command_name' ||
-            (!foundCommandName && child.type === 'word')) {
-            foundCommandName = true;
-            args.push(child.text);
-            continue;
-        }
-        // Arguments
-        if (ARGUMENT_TYPES.has(child.type)) {
-            args.push(stripQuotes(child.text));
-        }
-        else if (SUBSTITUTION_TYPES.has(child.type)) {
-            break;
-        }
-    }
-    return args;
-}
-function stripQuotes(text) {
-    return text.length >= 2 &&
-        ((text[0] === '"' && text.at(-1) === '"') ||
-            (text[0] === "'" && text.at(-1) === "'"))
-        ? text.slice(1, -1)
-        : text;
-}

package/dist/src/utils/bash/prefix.js

@@ -1,154 +0,0 @@
-import { buildPrefix } from '../shell/specPrefix.js';
-import { splitCommand_DEPRECATED } from './commands.js';
-import { extractCommandArguments, parseCommand } from './parser.js';
-import { getCommandSpec } from './registry.js';
-const NUMERIC = /^\d+$/;
-const ENV_VAR = /^[A-Za-z_][A-Za-z0-9_]*=/;
-// Wrapper commands with complex option handling that can't be expressed in specs
-const WRAPPER_COMMANDS = new Set([
-    'nice', // command position varies based on options
-]);
-const toArray = (val) => (Array.isArray(val) ? val : [val]);
-// Check if args[0] matches a known subcommand (disambiguates wrapper commands
-// that also have subcommands, e.g. the git spec has isCommand args for aliases).
-function isKnownSubcommand(arg, spec) {
-    if (!spec?.subcommands?.length)
-        return false;
-    return spec.subcommands.some(sub => Array.isArray(sub.name) ? sub.name.includes(arg) : sub.name === arg);
-}
-export async function getCommandPrefixStatic(command, recursionDepth = 0, wrapperCount = 0) {
-    if (wrapperCount > 2 || recursionDepth > 10)
-        return null;
-    const parsed = await parseCommand(command);
-    if (!parsed)
-        return null;
-    if (!parsed.commandNode) {
-        return { commandPrefix: null };
-    }
-    const { envVars, commandNode } = parsed;
-    const cmdArgs = extractCommandArguments(commandNode);
-    const [cmd, ...args] = cmdArgs;
-    if (!cmd)
-        return { commandPrefix: null };
-    // Check if this is a wrapper command by looking at its spec
-    const spec = await getCommandSpec(cmd);
-    // Check if this is a wrapper command
-    let isWrapper = WRAPPER_COMMANDS.has(cmd) ||
-        (spec?.args && toArray(spec.args).some(arg => arg?.isCommand));
-    // Special case: if the command has subcommands and the first arg matches a subcommand,
-    // treat it as a regular command, not a wrapper
-    if (isWrapper && args[0] && isKnownSubcommand(args[0], spec)) {
-        isWrapper = false;
-    }
-    const prefix = isWrapper
-        ? await handleWrapper(cmd, args, recursionDepth, wrapperCount)
-        : await buildPrefix(cmd, args, spec);
-    if (prefix === null && recursionDepth === 0 && isWrapper) {
-        return null;
-    }
-    const envPrefix = envVars.length ? `${envVars.join(' ')} ` : '';
-    return { commandPrefix: prefix ? envPrefix + prefix : null };
-}
-async function handleWrapper(command, args, recursionDepth, wrapperCount) {
-    const spec = await getCommandSpec(command);
-    if (spec?.args) {
-        const commandArgIndex = toArray(spec.args).findIndex(arg => arg?.isCommand);
-        if (commandArgIndex !== -1) {
-            const parts = [command];
-            for (let i = 0; i < args.length && i <= commandArgIndex; i++) {
-                if (i === commandArgIndex) {
-                    const result = await getCommandPrefixStatic(args.slice(i).join(' '), recursionDepth + 1, wrapperCount + 1);
-                    if (result?.commandPrefix) {
-                        parts.push(...result.commandPrefix.split(' '));
-                        return parts.join(' ');
-                    }
-                    break;
-                }
-                else if (args[i] &&
-                    !args[i].startsWith('-') &&
-                    !ENV_VAR.test(args[i])) {
-                    parts.push(args[i]);
-                }
-            }
-        }
-    }
-    const wrapped = args.find(arg => !arg.startsWith('-') && !NUMERIC.test(arg) && !ENV_VAR.test(arg));
-    if (!wrapped)
-        return command;
-    const result = await getCommandPrefixStatic(args.slice(args.indexOf(wrapped)).join(' '), recursionDepth + 1, wrapperCount + 1);
-    return !result?.commandPrefix ? null : `${command} ${result.commandPrefix}`;
-}
-/**
- * Computes prefixes for a compound command (with && / || / ;).
- * For single commands, returns a single-element array with the prefix.
- *
- * For compound commands, computes per-subcommand prefixes and collapses
- * them: subcommands sharing a root (first word) are collapsed via
- * word-aligned longest common prefix.
- *
- * @param excludeSubcommand — optional filter; return true for subcommands
- *   that should be excluded from the prefix suggestion (e.g. read-only
- *   commands that are already auto-allowed).
- */
-export async function getCompoundCommandPrefixesStatic(command, excludeSubcommand) {
-    const subcommands = splitCommand_DEPRECATED(command);
-    if (subcommands.length <= 1) {
-        const result = await getCommandPrefixStatic(command);
-        return result?.commandPrefix ? [result.commandPrefix] : [];
-    }
-    const prefixes = [];
-    for (const subcmd of subcommands) {
-        const trimmed = subcmd.trim();
-        if (excludeSubcommand?.(trimmed))
-            continue;
-        const result = await getCommandPrefixStatic(trimmed);
-        if (result?.commandPrefix) {
-            prefixes.push(result.commandPrefix);
-        }
-    }
-    if (prefixes.length === 0)
-        return [];
-    // Group prefixes by their first word (root command)
-    const groups = new Map();
-    for (const prefix of prefixes) {
-        const root = prefix.split(' ')[0];
-        const group = groups.get(root);
-        if (group) {
-            group.push(prefix);
-        }
-        else {
-            groups.set(root, [prefix]);
-        }
-    }
-    // Collapse each group via word-aligned LCP
-    const collapsed = [];
-    for (const [, group] of groups) {
-        collapsed.push(longestCommonPrefix(group));
-    }
-    return collapsed;
-}
-/**
- * Compute the longest common prefix of strings, aligned to word boundaries.
- * e.g. ["git fetch", "git worktree"] → "git"
- *      ["npm run test", "npm run lint"] → "npm run"
- */
-function longestCommonPrefix(strings) {
-    if (strings.length === 0)
-        return '';
-    if (strings.length === 1)
-        return strings[0];
-    const first = strings[0];
-    const words = first.split(' ');
-    let commonWords = words.length;
-    for (let i = 1; i < strings.length; i++) {
-        const otherWords = strings[i].split(' ');
-        let shared = 0;
-        while (shared < commonWords &&
-            shared < otherWords.length &&
-            words[shared] === otherWords[shared]) {
-            shared++;
-        }
-        commonWords = shared;
-    }
-    return words.slice(0, Math.max(1, commonWords)).join(' ');
-}

package/dist/src/utils/bash/registry.js

@@ -1,23 +0,0 @@
-import { memoizeWithLRU } from '../memoize.js';
-import specs from './specs/index.js';
-export async function loadFigSpec(command) {
-    if (!command || command.includes('/') || command.includes('\\'))
-        return null;
-    if (command.includes('..'))
-        return null;
-    if (command.startsWith('-') && command !== '-')
-        return null;
-    try {
-        const module = await import(`@withfig/autocomplete/build/${command}.js`);
-        return module.default || module;
-    }
-    catch {
-        return null;
-    }
-}
-export const getCommandSpec = memoizeWithLRU(async (command) => {
-    const spec = specs.find(s => s.name === command) ||
-        (await loadFigSpec(command)) ||
-        null;
-    return spec;
-}, (command) => command);

package/dist/src/utils/bash/shellCompletion.js

@@ -1,196 +0,0 @@
-import { quote, tryParseShellCommand, } from '../bash/shellQuote.js';
-import { logForDebugging } from '../debug.js';
-import { getShellType } from '../localInstaller.js';
-import * as Shell from '../Shell.js';
-// Constants
-const MAX_SHELL_COMPLETIONS = 15;
-const SHELL_COMPLETION_TIMEOUT_MS = 1000;
-const COMMAND_OPERATORS = ['|', '||', '&&', ';'];
-/**
- * Check if a parsed token is a command operator (|, ||, &&, ;)
- */
-function isCommandOperator(token) {
-    return (typeof token === 'object' &&
-        token !== null &&
-        'op' in token &&
-        COMMAND_OPERATORS.includes(token.op));
-}
-/**
- * Determine completion type based solely on prefix characteristics
- */
-function getCompletionTypeFromPrefix(prefix) {
-    if (prefix.startsWith('$')) {
-        return 'variable';
-    }
-    if (prefix.includes('/') ||
-        prefix.startsWith('~') ||
-        prefix.startsWith('.')) {
-        return 'file';
-    }
-    return 'command';
-}
-/**
- * Find the last string token and its index in parsed tokens
- */
-function findLastStringToken(tokens) {
-    const i = tokens.findLastIndex(t => typeof t === 'string');
-    return i !== -1 ? { token: tokens[i], index: i } : null;
-}
-/**
- * Check if we're in a context that expects a new command
- * (at start of input or after a command operator)
- */
-function isNewCommandContext(tokens, currentTokenIndex) {
-    if (currentTokenIndex === 0) {
-        return true;
-    }
-    const prevToken = tokens[currentTokenIndex - 1];
-    return prevToken !== undefined && isCommandOperator(prevToken);
-}
-/**
- * Parse input to extract completion context
- */
-function parseInputContext(input, cursorOffset) {
-    const beforeCursor = input.slice(0, cursorOffset);
-    // Check if it's a variable prefix, before expanding with shell-quote
-    const varMatch = beforeCursor.match(/\$[a-zA-Z_][a-zA-Z0-9_]*$/);
-    if (varMatch) {
-        return { prefix: varMatch[0], completionType: 'variable' };
-    }
-    // Parse with shell-quote
-    const parseResult = tryParseShellCommand(beforeCursor);
-    if (!parseResult.success) {
-        // Fallback to simple parsing
-        const tokens = beforeCursor.split(/\s+/);
-        const prefix = tokens[tokens.length - 1] || '';
-        const isFirstToken = tokens.length === 1 && !beforeCursor.includes(' ');
-        const completionType = isFirstToken
-            ? 'command'
-            : getCompletionTypeFromPrefix(prefix);
-        return { prefix, completionType };
-    }
-    // Extract current token
-    const lastToken = findLastStringToken(parseResult.tokens);
-    if (!lastToken) {
-        // No string token found - check if after operator
-        const lastParsedToken = parseResult.tokens[parseResult.tokens.length - 1];
-        const completionType = lastParsedToken && isCommandOperator(lastParsedToken)
-            ? 'command'
-            : 'command'; // Default to command at start
-        return { prefix: '', completionType };
-    }
-    // If there's a trailing space, the user is starting a new argument
-    if (beforeCursor.endsWith(' ')) {
-        // After first token (command) with space = file argument expected
-        return { prefix: '', completionType: 'file' };
-    }
-    // Determine completion type from context
-    const baseType = getCompletionTypeFromPrefix(lastToken.token);
-    // If it's clearly a file or variable based on prefix, use that type
-    if (baseType === 'variable' || baseType === 'file') {
-        return { prefix: lastToken.token, completionType: baseType };
-    }
-    // For command-like tokens, check context: are we starting a new command?
-    const completionType = isNewCommandContext(parseResult.tokens, lastToken.index)
-        ? 'command'
-        : 'file'; // Not after operator = file argument
-    return { prefix: lastToken.token, completionType };
-}
-/**
- * Generate bash completion command using compgen
- */
-function getBashCompletionCommand(prefix, completionType) {
-    if (completionType === 'variable') {
-        // Variable completion - remove $ prefix
-        const varName = prefix.slice(1);
-        return `compgen -v ${quote([varName])} 2>/dev/null`;
-    }
-    else if (completionType === 'file') {
-        // File completion with trailing slash for directories and trailing space for files
-        // Use 'while read' to prevent command injection from filenames containing newlines
-        return `compgen -f ${quote([prefix])} 2>/dev/null | head -${MAX_SHELL_COMPLETIONS} | while IFS= read -r f; do [ -d "$f" ] && echo "$f/" || echo "$f "; done`;
-    }
-    else {
-        // Command completion
-        return `compgen -c ${quote([prefix])} 2>/dev/null`;
-    }
-}
-/**
- * Generate zsh completion command using native zsh commands
- */
-function getZshCompletionCommand(prefix, completionType) {
-    if (completionType === 'variable') {
-        // Variable completion - use zsh pattern matching for safe filtering
-        const varName = prefix.slice(1);
-        return `print -rl -- \${(k)parameters[(I)${quote([varName])}*]} 2>/dev/null`;
-    }
-    else if (completionType === 'file') {
-        // File completion with trailing slash for directories and trailing space for files
-        // Note: zsh glob expansion is safe from command injection (unlike bash for-in loops)
-        return `for f in ${quote([prefix])}*(N[1,${MAX_SHELL_COMPLETIONS}]); do [[ -d "$f" ]] && echo "$f/" || echo "$f "; done`;
-    }
-    else {
-        // Command completion - use zsh pattern matching for safe filtering
-        return `print -rl -- \${(k)commands[(I)${quote([prefix])}*]} 2>/dev/null`;
-    }
-}
-/**
- * Get completions for the given shell type
- */
-async function getCompletionsForShell(shellType, prefix, completionType, abortSignal) {
-    let command;
-    if (shellType === 'bash') {
-        command = getBashCompletionCommand(prefix, completionType);
-    }
-    else if (shellType === 'zsh') {
-        command = getZshCompletionCommand(prefix, completionType);
-    }
-    else {
-        // Unsupported shell type
-        return [];
-    }
-    const shellCommand = await Shell.exec(command, abortSignal, 'bash', {
-        timeout: SHELL_COMPLETION_TIMEOUT_MS,
-    });
-    const result = await shellCommand.result;
-    return result.stdout
-        .split('\n')
-        .filter((line) => line.trim())
-        .slice(0, MAX_SHELL_COMPLETIONS)
-        .map((text) => ({
-        id: text,
-        displayText: text,
-        description: undefined,
-        metadata: { completionType },
-    }));
-}
-/**
- * Get shell completions for the given input
- * Supports bash and zsh shells (matches Shell.ts execution support)
- */
-export async function getShellCompletions(input, cursorOffset, abortSignal) {
-    const shellType = getShellType();
-    // Only support bash/zsh (matches Shell.ts execution support)
-    if (shellType !== 'bash' && shellType !== 'zsh') {
-        return [];
-    }
-    try {
-        const { prefix, completionType } = parseInputContext(input, cursorOffset);
-        if (!prefix) {
-            return [];
-        }
-        const completions = await getCompletionsForShell(shellType, prefix, completionType, abortSignal);
-        // Add inputSnapshot to all suggestions so we can detect when input changes
-        return completions.map(suggestion => ({
-            ...suggestion,
-            metadata: {
-                ...suggestion.metadata,
-                inputSnapshot: input,
-            },
-        }));
-    }
-    catch (error) {
-        logForDebugging(`Shell completion failed: ${error}`);
-        return []; // Silent fail
-    }
-}

package/dist/src/utils/bash/shellPrefix.js

@@ -1,25 +0,0 @@
-import { quote } from './shellQuote.js';
-/**
- * Parses a shell prefix that may contain an executable path and arguments.
- *
- * Examples:
- * - "bash" -> quotes as 'bash'
- * - "/usr/bin/bash -c" -> quotes as '/usr/bin/bash' -c
- * - "C:\Program Files\Git\bin\bash.exe -c" -> quotes as 'C:\Program Files\Git\bin\bash.exe' -c
- *
- * @param prefix The shell prefix string containing executable and optional arguments
- * @param command The command to be executed
- * @returns The properly formatted command string with quoted components
- */
-export function formatShellPrefixCommand(prefix, command) {
-    // Split on the last space before a dash to separate executable from arguments
-    const spaceBeforeDash = prefix.lastIndexOf(' -');
-    if (spaceBeforeDash > 0) {
-        const execPath = prefix.substring(0, spaceBeforeDash);
-        const args = prefix.substring(spaceBeforeDash + 1);
-        return `${quote([execPath])} ${args} ${quote([command])}`;
-    }
-    else {
-        return `${quote([prefix])} ${quote([command])}`;
-    }
-}