@xortex/xcode 3.0.0

package/utils/bash/parser.ts

@@ -0,0 +1,230 @@
+import { feature } from 'bun:bundle'
+import { logEvent } from '../../services/analytics/index.js'
+import { logForDebugging } from '../debug.js'
+import {
+  ensureParserInitialized,
+  getParserModule,
+  type TsNode,
+} from './bashParser.js'
+
+export type Node = TsNode
+
+export interface ParsedCommandData {
+  rootNode: Node
+  envVars: string[]
+  commandNode: Node | null
+  originalCommand: string
+}
+
+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: boolean): void {
+  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(): Promise<void> {
+  if (feature('TREE_SITTER_BASH') || feature('TREE_SITTER_BASH_SHADOW')) {
+    await ensureParserInitialized()
+  }
+}
+
+export async function parseCommand(
+  command: string,
+): Promise<ParsedCommandData | null> {
+  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: string,
+): Promise<Node | null | typeof PARSE_ABORTED> {
+  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: Node, parent: Node | null): Node | null {
+  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: Node | null): string[] {
+  if (!commandNode || commandNode.type !== 'command') return []
+
+  const envVars: string[] = []
+  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: Node): string[] {
+  // Declaration commands
+  if (commandNode.type === 'declaration_command') {
+    const firstChild = commandNode.children[0]
+    return firstChild && DECLARATION_COMMANDS.has(firstChild.text)
+      ? [firstChild.text]
+      : []
+  }
+
+  const args: string[] = []
+  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: string): string {
+  return text.length >= 2 &&
+    ((text[0] === '"' && text.at(-1) === '"') ||
+      (text[0] === "'" && text.at(-1) === "'"))
+    ? text.slice(1, -1)
+    : text
+}

package/utils/bash/prefix.ts

@@ -0,0 +1,204 @@
+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 = <T>(val: T | T[]): T[] => (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: string,
+  spec: { subcommands?: { name: string | string[] }[] } | null,
+): boolean {
+  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: string,
+  recursionDepth = 0,
+  wrapperCount = 0,
+): Promise<{ commandPrefix: string | null } | null> {
+  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: string,
+  args: string[],
+  recursionDepth: number,
+  wrapperCount: number,
+): Promise<string | null> {
+  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: string,
+  excludeSubcommand?: (subcommand: string) => boolean,
+): Promise<string[]> {
+  const subcommands = splitCommand_DEPRECATED(command)
+  if (subcommands.length <= 1) {
+    const result = await getCommandPrefixStatic(command)
+    return result?.commandPrefix ? [result.commandPrefix] : []
+  }
+
+  const prefixes: string[] = []
+  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<string, string[]>()
+  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: string[] = []
+  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: string[]): string {
+  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/utils/bash/registry.ts

@@ -0,0 +1,53 @@
+import { memoizeWithLRU } from '../memoize.js'
+import specs from './specs/index.js'
+
+export type CommandSpec = {
+  name: string
+  description?: string
+  subcommands?: CommandSpec[]
+  args?: Argument | Argument[]
+  options?: Option[]
+}
+
+export type Argument = {
+  name?: string
+  description?: string
+  isDangerous?: boolean
+  isVariadic?: boolean // repeats infinitely e.g. echo hello world
+  isOptional?: boolean
+  isCommand?: boolean // wrapper commands e.g. timeout, sudo
+  isModule?: string | boolean // for python -m and similar module args
+  isScript?: boolean // script files e.g. node script.js
+}
+
+export type Option = {
+  name: string | string[]
+  description?: string
+  args?: Argument | Argument[]
+  isRequired?: boolean
+}
+
+export async function loadFigSpec(
+  command: string,
+): Promise<CommandSpec | null> {
+  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: string): Promise<CommandSpec | null> => {
+    const spec =
+      specs.find(s => s.name === command) ||
+      (await loadFigSpec(command)) ||
+      null
+    return spec
+  },
+  (command: string) => command,
+)