just-bash-nx 2.14.4

package/dist/interpreter/builtins/compopt.d.ts

@@ -0,0 +1,28 @@
+/**
+ * compopt - Modify completion options
+ *
+ * Usage:
+ *   compopt [-o option] [+o option] [name ...]
+ *   compopt -D [-o option] [+o option]
+ *   compopt -E [-o option] [+o option]
+ *
+ * Modifies completion options for the specified commands (names) or the
+ * currently executing completion when no names are provided.
+ *
+ * Options:
+ *   -o option  Enable completion option
+ *   +o option  Disable completion option
+ *   -D         Apply to default completion
+ *   -E         Apply to empty-line completion
+ *
+ * Valid completion options:
+ *   bashdefault, default, dirnames, filenames, noquote, nosort, nospace, plusdirs
+ *
+ * Returns:
+ *   0 on success
+ *   1 if not in a completion function and no command name is given
+ *   2 if an invalid option is specified
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleCompopt(ctx: InterpreterContext, args: string[]): ExecResult;

package/dist/interpreter/builtins/continue.d.ts

@@ -0,0 +1,6 @@
+/**
+ * continue - Skip to next loop iteration builtin
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleContinue(ctx: InterpreterContext, args: string[]): ExecResult;

package/dist/interpreter/builtins/declare-array-parsing.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Array Parsing Functions for declare/typeset
+ *
+ * Handles parsing of array literal syntax for the declare builtin.
+ */
+/**
+ * Parse array elements from content like "1 2 3" or "'a b' c d"
+ */
+export declare function parseArrayElements(content: string): string[];
+/**
+ * Parse associative array literal content like "['foo']=bar ['spam']=42"
+ * Returns array of [key, value] pairs
+ */
+export declare function parseAssocArrayLiteral(content: string): [string, string][];

package/dist/interpreter/builtins/declare-print.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Declare Print Mode Functions
+ *
+ * Handles printing and listing variables for the declare/typeset builtin.
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+/**
+ * Print specific variables with their declarations.
+ * Handles: declare -p varname1 varname2 ...
+ */
+export declare function printSpecificVariables(ctx: InterpreterContext, names: string[]): ExecResult;
+export interface PrintAllFilters {
+    filterExport: boolean;
+    filterReadonly: boolean;
+    filterNameref: boolean;
+    filterIndexedArray: boolean;
+    filterAssocArray: boolean;
+}
+/**
+ * Print all variables with their declarations and attributes.
+ * Handles: declare -p (with optional filters like -x, -r, -n, -a, -A)
+ */
+export declare function printAllVariables(ctx: InterpreterContext, filters: PrintAllFilters): ExecResult;
+/**
+ * List all associative arrays.
+ * Handles: declare -A (without arguments)
+ */
+export declare function listAssociativeArrays(ctx: InterpreterContext): ExecResult;
+/**
+ * List all indexed arrays.
+ * Handles: declare -a (without arguments)
+ */
+export declare function listIndexedArrays(ctx: InterpreterContext): ExecResult;
+/**
+ * List all variables without print mode (no attributes shown).
+ * Handles: declare (without -p and without arguments)
+ */
+export declare function listAllVariables(ctx: InterpreterContext): ExecResult;

package/dist/interpreter/builtins/declare.d.ts

@@ -0,0 +1,35 @@
+/**
+ * declare/typeset - Declare variables and give them attributes
+ *
+ * Usage:
+ *   declare              - List all variables
+ *   declare -p           - List all variables (same as no args)
+ *   declare NAME=value   - Declare variable with value
+ *   declare -a NAME      - Declare indexed array
+ *   declare -A NAME      - Declare associative array
+ *   declare -r NAME      - Declare readonly variable
+ *   declare -x NAME      - Export variable
+ *   declare -g NAME      - Declare global variable (inside functions)
+ *
+ * Also aliased as 'typeset'
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+/**
+ * Check if a variable has the integer attribute.
+ */
+export declare function isInteger(ctx: InterpreterContext, name: string): boolean;
+/**
+ * Apply case transformation based on variable attributes.
+ * Returns the transformed value.
+ */
+export declare function applyCaseTransform(ctx: InterpreterContext, name: string, value: string): string;
+export declare function handleDeclare(ctx: InterpreterContext, args: string[]): Promise<ExecResult>;
+/**
+ * readonly - Declare readonly variables
+ *
+ * Usage:
+ *   readonly NAME=value   - Declare readonly variable
+ *   readonly NAME         - Mark existing variable as readonly
+ */
+export declare function handleReadonly(ctx: InterpreterContext, args: string[]): Promise<ExecResult>;

package/dist/interpreter/builtins/dirs.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Directory Stack Builtins: pushd, popd, dirs
+ *
+ * pushd [dir] - Push directory onto stack and cd to it
+ * popd - Pop directory from stack and cd to previous
+ * dirs [-clpv] - Display directory stack
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+/**
+ * pushd - Push directory onto stack and cd to it
+ *
+ * pushd [dir] - Push current dir, cd to dir
+ */
+export declare function handlePushd(ctx: InterpreterContext, args: string[]): Promise<ExecResult>;
+/**
+ * popd - Pop directory from stack and cd to it
+ */
+export declare function handlePopd(ctx: InterpreterContext, args: string[]): ExecResult;
+/**
+ * dirs - Display directory stack
+ *
+ * dirs [-clpv]
+ *   -c: Clear the stack
+ *   -l: Long format (no tilde substitution)
+ *   -p: One entry per line
+ *   -v: One entry per line with index numbers
+ */
+export declare function handleDirs(ctx: InterpreterContext, args: string[]): ExecResult;

package/dist/interpreter/builtins/eval.d.ts

@@ -0,0 +1,9 @@
+/**
+ * eval - Execute arguments as a shell command
+ *
+ * Concatenates all arguments and executes them as a shell command
+ * in the current environment (variables persist after eval).
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleEval(ctx: InterpreterContext, args: string[], stdin?: string): Promise<ExecResult>;

package/dist/interpreter/builtins/exit.d.ts

@@ -0,0 +1,5 @@
+/**
+ * exit - Exit shell builtin
+ */
+import type { InterpreterContext } from "../types.js";
+export declare function handleExit(ctx: InterpreterContext, args: string[]): never;

package/dist/interpreter/builtins/export.d.ts

@@ -0,0 +1,14 @@
+/**
+ * export - Set environment variables builtin
+ *
+ * Usage:
+ *   export              - List all exported variables
+ *   export -p           - List all exported variables (same as no args)
+ *   export NAME=value   - Set and export variable
+ *   export NAME+=value  - Append value and export variable
+ *   export NAME         - Export existing variable (or create empty)
+ *   export -n NAME      - Un-export variable (remove from env)
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleExport(ctx: InterpreterContext, args: string[]): ExecResult;

package/dist/interpreter/builtins/getopts.d.ts

@@ -0,0 +1,18 @@
+/**
+ * getopts - Parse positional parameters as options
+ *
+ * getopts optstring name [arg...]
+ *
+ * Parses options from positional parameters (or provided args).
+ * - optstring: string of valid option characters
+ * - If a character is followed by ':', it requires an argument
+ * - If optstring starts with ':', silent error reporting mode
+ * - name: variable to store the current option
+ * - OPTARG: set to the option argument (if any)
+ * - OPTIND: index of next argument to process (starts at 1)
+ *
+ * Returns 0 if option found, 1 if end of options or error.
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleGetopts(ctx: InterpreterContext, args: string[]): ExecResult;

package/dist/interpreter/builtins/hash.d.ts

@@ -0,0 +1,19 @@
+/**
+ * hash - Manage the hash table of remembered command locations
+ *
+ * hash [-lr] [-p pathname] [-dt] [name ...]
+ *
+ * Hash maintains a hash table of recently executed commands for faster lookup.
+ *
+ * Options:
+ *   (no args)  Display the hash table
+ *   name       Add name to the hash table (look up in PATH)
+ *   -r         Clear the hash table
+ *   -d name    Remove name from the hash table
+ *   -l         Display in a format that can be reused as input
+ *   -p path    Use path as the full pathname for name (hash -p /path name)
+ *   -t name    Print the remembered location of name
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleHash(ctx: InterpreterContext, args: string[]): Promise<ExecResult>;

package/dist/interpreter/builtins/help.d.ts

@@ -0,0 +1,12 @@
+/**
+ * help - Display helpful information about builtin commands
+ *
+ * Usage: help [-s] [pattern ...]
+ *
+ * If PATTERN is specified, gives detailed help on all commands matching PATTERN,
+ * otherwise a list of the builtins is printed. The -s option restricts the output
+ * for each builtin command matching PATTERN to a short usage synopsis.
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleHelp(_ctx: InterpreterContext, args: string[]): ExecResult;

package/dist/interpreter/builtins/index.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Built-in Command Handlers
+ *
+ * Shell built-in commands that modify interpreter state:
+ * - cd: Change directory
+ * - declare/typeset: Declare variables with attributes
+ * - export: Set environment variables
+ * - unset: Remove variables/functions
+ * - exit: Exit shell
+ * - local: Declare local variables in functions
+ * - readonly: Declare readonly variables
+ * - set: Set/unset shell options
+ * - break: Exit from loops
+ * - continue: Skip to next loop iteration
+ * - return: Return from a function
+ * - eval: Execute arguments as a shell command
+ * - let: Evaluate arithmetic expressions
+ * - shift: Shift positional parameters
+ * - read: Read a line of input
+ * - source/.: Execute commands from a file in current environment
+ */
+export { handleBreak } from "./break.js";
+export { handleCd } from "./cd.js";
+export { handleCompgen } from "./compgen.js";
+export { handleComplete } from "./complete.js";
+export { handleCompopt } from "./compopt.js";
+export { handleContinue } from "./continue.js";
+export { applyCaseTransform, handleDeclare, handleReadonly, isInteger, } from "./declare.js";
+export { handleDirs, handlePopd, handlePushd } from "./dirs.js";
+export { handleEval } from "./eval.js";
+export { handleExit } from "./exit.js";
+export { handleExport } from "./export.js";
+export { handleGetopts } from "./getopts.js";
+export { handleHash } from "./hash.js";
+export { handleHelp } from "./help.js";
+export { handleLet } from "./let.js";
+export { handleLocal } from "./local.js";
+export { handleMapfile } from "./mapfile.js";
+export { handleRead } from "./read.js";
+export { handleReturn } from "./return.js";
+export { handleSet } from "./set.js";
+export { handleShift } from "./shift.js";
+export { handleSource } from "./source.js";
+export { handleUnset } from "./unset.js";
+export { getLocalVarDepth } from "./variable-assignment.js";

package/dist/interpreter/builtins/let.d.ts

@@ -0,0 +1,18 @@
+/**
+ * let - Evaluate arithmetic expressions
+ *
+ * Usage:
+ *   let expr [expr ...]
+ *   let "x=1" "y=x+2"
+ *
+ * Each argument is evaluated as an arithmetic expression.
+ * Returns 0 if the last expression evaluates to non-zero,
+ * returns 1 if it evaluates to zero.
+ *
+ * Note: In bash, `let x=( 1 )` passes separate args ["x=(", "1", ")"]
+ * when not quoted. The let builtin needs to handle this by joining
+ * arguments that are part of the same expression.
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleLet(ctx: InterpreterContext, args: string[]): Promise<ExecResult>;

package/dist/interpreter/builtins/local.d.ts

@@ -0,0 +1,6 @@
+/**
+ * local - Declare local variables in functions builtin
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleLocal(ctx: InterpreterContext, args: string[]): Promise<ExecResult>;

package/dist/interpreter/builtins/mapfile.d.ts

@@ -0,0 +1,17 @@
+/**
+ * mapfile/readarray - Read lines from stdin into an array
+ *
+ * Usage: mapfile [-d delim] [-n count] [-O origin] [-s count] [-t] [array]
+ *        readarray [-d delim] [-n count] [-O origin] [-s count] [-t] [array]
+ *
+ * Options:
+ *   -d delim   Use delim as line delimiter (default: newline)
+ *   -n count   Read at most count lines (0 = all)
+ *   -O origin  Start assigning at index origin (default: 0)
+ *   -s count   Skip first count lines
+ *   -t         Remove trailing delimiter from each line
+ *   array      Array name (default: MAPFILE)
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleMapfile(ctx: InterpreterContext, args: string[], stdin: string): ExecResult;

package/dist/interpreter/builtins/read.d.ts

@@ -0,0 +1,6 @@
+/**
+ * read - Read a line of input builtin
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleRead(ctx: InterpreterContext, args: string[], stdin: string, stdinSourceFd?: number): ExecResult;

package/dist/interpreter/builtins/return.d.ts

@@ -0,0 +1,6 @@
+/**
+ * return - Return from a function with an exit code
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleReturn(ctx: InterpreterContext, args: string[]): ExecResult;

package/dist/interpreter/builtins/set.d.ts

@@ -0,0 +1,9 @@
+/**
+ * set - Set/unset shell options builtin
+ *
+ * In POSIX mode (set -o posix), errors from set (like invalid options)
+ * cause the script to exit immediately.
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleSet(ctx: InterpreterContext, args: string[]): ExecResult;

package/dist/interpreter/builtins/shift.d.ts

@@ -0,0 +1,15 @@
+/**
+ * shift - Shift positional parameters
+ *
+ * shift [n]
+ *
+ * Shifts positional parameters to the left by n (default 1).
+ * $n+1 becomes $1, $n+2 becomes $2, etc.
+ * $# is decremented by n.
+ *
+ * In POSIX mode (set -o posix), errors from shift (like shift count
+ * exceeding available parameters) cause the script to exit immediately.
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleShift(ctx: InterpreterContext, args: string[]): ExecResult;

package/dist/interpreter/builtins/shopt.d.ts

@@ -0,0 +1,7 @@
+/**
+ * shopt builtin - Shell options
+ * Implements bash's shopt builtin for managing shell-specific options
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleShopt(ctx: InterpreterContext, args: string[]): ExecResult;

package/dist/interpreter/builtins/source.d.ts

@@ -0,0 +1,6 @@
+/**
+ * source/. - Execute commands from a file in current environment builtin
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleSource(ctx: InterpreterContext, args: string[]): Promise<ExecResult>;

package/dist/interpreter/builtins/unset.d.ts

@@ -0,0 +1,16 @@
+/**
+ * unset - Remove variables/functions builtin
+ *
+ * Supports:
+ * - unset VAR - remove variable
+ * - unset -v VAR - remove variable (explicit)
+ * - unset -f FUNC - remove function
+ * - unset 'a[i]' - remove array element (with arithmetic index support)
+ *
+ * Bash-specific unset scoping:
+ * - local-unset (same scope): value-unset - clears value but keeps local cell
+ * - dynamic-unset (different scope): cell-unset - removes local cell, exposes outer value
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+export declare function handleUnset(ctx: InterpreterContext, args: string[]): Promise<ExecResult>;

package/dist/interpreter/builtins/variable-assignment.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Variable assignment helpers for declare, readonly, local, export builtins.
+ */
+import type { ExecResult } from "../../types.js";
+import type { InterpreterContext } from "../types.js";
+/**
+ * Result of parsing an assignment argument.
+ */
+export interface ParsedAssignment {
+    name: string;
+    isArray: boolean;
+    arrayElements?: string[];
+    value?: string;
+    /** For array index assignment: a[index]=value */
+    arrayIndex?: string;
+}
+/**
+ * Parse an assignment argument like "name=value", "name=(a b c)", or "name[index]=value".
+ */
+export declare function parseAssignment(arg: string): ParsedAssignment;
+/**
+ * Options for setting a variable.
+ */
+export interface SetVariableOptions {
+    makeReadonly?: boolean;
+    checkReadonly?: boolean;
+}
+/**
+ * Set a variable from a parsed assignment.
+ * Returns an error result if the variable is readonly, otherwise null.
+ */
+export declare function setVariable(ctx: InterpreterContext, assignment: ParsedAssignment, options?: SetVariableOptions): Promise<ExecResult | null>;
+/**
+ * Mark a variable as being declared at the current call depth.
+ * Used for bash-specific unset scoping behavior.
+ */
+export declare function markLocalVarDepth(ctx: InterpreterContext, name: string): void;
+/**
+ * Get the call depth at which a local variable was declared.
+ * Returns undefined if the variable is not a local variable.
+ */
+export declare function getLocalVarDepth(ctx: InterpreterContext, name: string): number | undefined;
+/**
+ * Clear the local variable depth tracking for a variable.
+ * Called when a local variable is cell-unset (dynamic-unset).
+ */
+export declare function clearLocalVarDepth(ctx: InterpreterContext, name: string): void;
+/**
+ * Push the current value of a variable onto the local var stack.
+ * Used for bash's localvar-nest behavior where nested local declarations
+ * each create a new cell that can be unset independently.
+ */
+export declare function pushLocalVarStack(ctx: InterpreterContext, name: string, currentValue: string | undefined): void;
+/**
+ * Pop the top entry from the local var stack for a variable.
+ * Returns the saved value and scope index if there was an entry, or undefined if the stack was empty.
+ */
+export declare function popLocalVarStack(ctx: InterpreterContext, name: string): {
+    value: string | undefined;
+    scopeIndex: number;
+} | undefined;
+/**
+ * Clear all local var stack entries for a specific scope index.
+ * Called when a function returns and its local scope is popped.
+ */
+export declare function clearLocalVarStackForScope(ctx: InterpreterContext, scopeIndex: number): void;

package/dist/interpreter/command-resolution.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Command Resolution
+ *
+ * Handles PATH-based command resolution and lookup for external commands.
+ */
+import type { IFileSystem } from "../fs/interface.js";
+import type { Command, CommandRegistry } from "../types.js";
+import type { InterpreterState } from "./types.js";
+/**
+ * Context needed for command resolution
+ */
+export interface CommandResolutionContext {
+    fs: IFileSystem;
+    state: InterpreterState;
+    commands: CommandRegistry;
+}
+/**
+ * Result type for command resolution
+ */
+export type ResolveCommandResult = {
+    cmd: Command;
+    path: string;
+} | {
+    script: true;
+    path: string;
+} | {
+    error: "not_found" | "permission_denied";
+    path?: string;
+} | null;
+/**
+ * Resolve a command name to its implementation via PATH lookup.
+ * Returns the command and its resolved path, or null if not found.
+ *
+ * Resolution order:
+ * 1. If command contains "/", resolve as a path
+ * 2. Search PATH directories for the command file
+ * 3. Fall back to registry lookup (for non-InMemoryFs filesystems like OverlayFs)
+ */
+export declare function resolveCommand(ctx: CommandResolutionContext, commandName: string, pathOverride?: string): Promise<ResolveCommandResult>;
+/**
+ * Find all paths for a command in PATH (for `which -a`).
+ */
+export declare function findCommandInPath(ctx: CommandResolutionContext, commandName: string): Promise<string[]>;

package/dist/interpreter/conditionals.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Conditional Expression Evaluation
+ *
+ * Handles:
+ * - [[ ... ]] conditional commands
+ * - [ ... ] and test commands
+ * - File tests (-f, -d, -e, etc.)
+ * - String tests (-z, -n, =, !=)
+ * - Numeric comparisons (-eq, -ne, -lt, etc.)
+ * - Pattern matching (==, =~)
+ */
+import type { ConditionalExpressionNode } from "../ast/types.js";
+import type { ExecResult } from "../types.js";
+import type { InterpreterContext } from "./types.js";
+export declare function evaluateConditional(ctx: InterpreterContext, expr: ConditionalExpressionNode): Promise<boolean>;
+export declare function evaluateTestArgs(ctx: InterpreterContext, args: string[]): Promise<ExecResult>;
+export declare function matchPattern(value: string, pattern: string, nocasematch?: boolean, extglob?: boolean): boolean;

package/dist/interpreter/control-flow.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Control Flow Execution
+ *
+ * Handles control flow constructs:
+ * - if/elif/else
+ * - for loops
+ * - C-style for loops
+ * - while loops
+ * - until loops
+ * - case statements
+ * - break/continue
+ */
+import type { CaseNode, CStyleForNode, ForNode, IfNode, UntilNode, WhileNode } from "../ast/types.js";
+import type { ExecResult } from "../types.js";
+import type { InterpreterContext } from "./types.js";
+export declare function executeIf(ctx: InterpreterContext, node: IfNode): Promise<ExecResult>;
+export declare function executeFor(ctx: InterpreterContext, node: ForNode): Promise<ExecResult>;
+export declare function executeCStyleFor(ctx: InterpreterContext, node: CStyleForNode): Promise<ExecResult>;
+export declare function executeWhile(ctx: InterpreterContext, node: WhileNode, stdin?: string): Promise<ExecResult>;
+export declare function executeUntil(ctx: InterpreterContext, node: UntilNode): Promise<ExecResult>;
+export declare function executeCase(ctx: InterpreterContext, node: CaseNode): Promise<ExecResult>;

package/dist/interpreter/defense-aware-command-context.d.ts

@@ -0,0 +1,6 @@
+import type { CommandContext } from "../types.js";
+/**
+ * Wrap command context APIs so async boundaries are fail-closed if defense
+ * context is expected but missing.
+ */
+export declare function createDefenseAwareCommandContext(ctx: CommandContext, commandName: string): CommandContext;