just-bash 1.1.0 → 1.2.0

package/dist/commands/awk/interpreter/interpreter.d.ts

@@ -0,0 +1,50 @@
+/**
+ * AWK Interpreter
+ *
+ * Main interpreter class that orchestrates AWK program execution.
+ */
+import type { AwkProgram } from "../ast.js";
+import type { AwkRuntimeContext } from "./context.js";
+export declare class AwkInterpreter {
+    private ctx;
+    private program;
+    private rangeStates;
+    constructor(ctx: AwkRuntimeContext);
+    /**
+     * Initialize the interpreter with a program.
+     * Must be called before executeBegin/executeLine/executeEnd.
+     */
+    execute(program: AwkProgram): void;
+    /**
+     * Execute all BEGIN blocks.
+     */
+    executeBegin(): Promise<void>;
+    /**
+     * Execute rules for a single input line.
+     */
+    executeLine(line: string): Promise<void>;
+    /**
+     * Execute all END blocks.
+     */
+    executeEnd(): Promise<void>;
+    /**
+     * Get the accumulated output.
+     */
+    getOutput(): string;
+    /**
+     * Get the exit code.
+     */
+    getExitCode(): number;
+    /**
+     * Get the runtime context (for access to control flow flags, etc.)
+     */
+    getContext(): AwkRuntimeContext;
+    /**
+     * Check if a rule matches the current line.
+     */
+    private matchesRule;
+    /**
+     * Check if a pattern matches.
+     */
+    private matchPattern;
+}

package/dist/commands/awk/interpreter/statements.d.ts

@@ -0,0 +1,11 @@
+/**
+ * AWK Statement Execution
+ *
+ * Async statement executor supporting file I/O operations.
+ */
+import type { AwkStmt } from "../ast.js";
+import type { AwkRuntimeContext } from "./context.js";
+/**
+ * Execute a block of statements.
+ */
+export declare function executeBlock(ctx: AwkRuntimeContext, statements: AwkStmt[]): Promise<void>;

package/dist/commands/awk/interpreter/types.d.ts

@@ -0,0 +1,13 @@
+/**
+ * AWK Interpreter Types
+ */
+export type AwkValue = string | number;
+/**
+ * File system interface for AWK file operations
+ */
+export interface AwkFileSystem {
+    readFile: (path: string) => Promise<string>;
+    writeFile: (path: string, content: string) => Promise<void>;
+    appendFile: (path: string, content: string) => Promise<void>;
+    resolvePath: (cwd: string, path: string) => string;
+}

package/dist/commands/awk/interpreter/variables.d.ts

@@ -0,0 +1,35 @@
+/**
+ * AWK Variable and Array Operations
+ *
+ * Handles user variables, built-in variables, and arrays.
+ */
+import type { AwkRuntimeContext } from "./context.js";
+import type { AwkValue } from "./types.js";
+/**
+ * Get a variable value. Handles built-in variables.
+ */
+export declare function getVariable(ctx: AwkRuntimeContext, name: string): AwkValue;
+/**
+ * Set a variable value. Handles built-in variables with special behavior.
+ */
+export declare function setVariable(ctx: AwkRuntimeContext, name: string, value: AwkValue): void;
+/**
+ * Get an array element value.
+ */
+export declare function getArrayElement(ctx: AwkRuntimeContext, array: string, key: string): AwkValue;
+/**
+ * Set an array element value.
+ */
+export declare function setArrayElement(ctx: AwkRuntimeContext, array: string, key: string, value: AwkValue): void;
+/**
+ * Check if an array element exists.
+ */
+export declare function hasArrayElement(ctx: AwkRuntimeContext, array: string, key: string): boolean;
+/**
+ * Delete an array element.
+ */
+export declare function deleteArrayElement(ctx: AwkRuntimeContext, array: string, key: string): void;
+/**
+ * Delete an entire array.
+ */
+export declare function deleteArray(ctx: AwkRuntimeContext, array: string): void;

package/dist/commands/awk/interpreter2.d.ts

@@ -0,0 +1,90 @@
+/**
+ * AWK Interpreter
+ *
+ * Tree-walking interpreter that executes an AWK AST.
+ */
+import type { AwkExpr, AwkFunctionDef, AwkProgram } from "./ast.js";
+export type AwkValue = string | number;
+export interface AwkRuntimeContext {
+    FS: string;
+    OFS: string;
+    ORS: string;
+    NR: number;
+    NF: number;
+    FNR: number;
+    FILENAME: string;
+    RSTART: number;
+    RLENGTH: number;
+    SUBSEP: string;
+    fields: string[];
+    line: string;
+    vars: Record<string, AwkValue>;
+    arrays: Record<string, Record<string, AwkValue>>;
+    functions: Map<string, AwkFunctionDef>;
+    lines?: string[];
+    lineIndex?: number;
+    fieldSep: RegExp;
+    maxIterations: number;
+    maxRecursionDepth: number;
+    currentRecursionDepth: number;
+    exitCode: number;
+    shouldExit: boolean;
+    shouldNext: boolean;
+    loopBreak: boolean;
+    loopContinue: boolean;
+    returnValue?: AwkValue;
+    hasReturn: boolean;
+    output: string;
+    random?: () => number;
+}
+export declare function createRuntimeContext(fieldSep?: RegExp, maxIterations?: number): AwkRuntimeContext;
+export declare class AwkInterpreter {
+    private ctx;
+    private program;
+    private rangeStates;
+    constructor(ctx: AwkRuntimeContext);
+    execute(program: AwkProgram): string;
+    executeBegin(): void;
+    executeLine(line: string): void;
+    executeEnd(): void;
+    getOutput(): string;
+    getExitCode(): number;
+    private splitFields;
+    private matchesRule;
+    private matchPattern;
+    private matchRegex;
+    private executeBlock;
+    private executeStmt;
+    private executePrint;
+    private executePrintf;
+    private executeIf;
+    private executeWhile;
+    private executeDoWhile;
+    private executeFor;
+    private executeForIn;
+    private executeDelete;
+    evalExpr(expr: AwkExpr): AwkValue;
+    private getField;
+    private setField;
+    private getVariable;
+    private setVariable;
+    private getArrayElement;
+    private setArrayElement;
+    private evalBinaryOp;
+    private isComparisonOp;
+    private evalComparison;
+    private looksLikeNumber;
+    private evalUnaryOp;
+    private evalFunctionCall;
+    private callUserFunction;
+    private evalAssignment;
+    private evalPreIncrement;
+    private evalPreDecrement;
+    private evalPostIncrement;
+    private evalPostDecrement;
+    private evalInExpr;
+    private evalGetline;
+    isTruthy(val: AwkValue): boolean;
+    toNumber(val: AwkValue): number;
+    toString(val: AwkValue): string;
+}

package/dist/commands/awk/lexer.d.ts

@@ -0,0 +1,100 @@
+/**
+ * AWK Lexer
+ *
+ * Tokenizes AWK source code into a stream of tokens.
+ */
+export declare enum TokenType {
+    NUMBER = "NUMBER",
+    STRING = "STRING",
+    REGEX = "REGEX",
+    IDENT = "IDENT",
+    BEGIN = "BEGIN",
+    END = "END",
+    IF = "IF",
+    ELSE = "ELSE",
+    WHILE = "WHILE",
+    DO = "DO",
+    FOR = "FOR",
+    IN = "IN",
+    BREAK = "BREAK",
+    CONTINUE = "CONTINUE",
+    NEXT = "NEXT",
+    NEXTFILE = "NEXTFILE",
+    EXIT = "EXIT",
+    RETURN = "RETURN",
+    DELETE = "DELETE",
+    FUNCTION = "FUNCTION",
+    PRINT = "PRINT",
+    PRINTF = "PRINTF",
+    GETLINE = "GETLINE",
+    PLUS = "PLUS",
+    MINUS = "MINUS",
+    STAR = "STAR",
+    SLASH = "SLASH",
+    PERCENT = "PERCENT",
+    CARET = "CARET",
+    EQ = "EQ",
+    NE = "NE",
+    LT = "LT",
+    GT = "GT",
+    LE = "LE",
+    GE = "GE",
+    MATCH = "MATCH",
+    NOT_MATCH = "NOT_MATCH",
+    AND = "AND",
+    OR = "OR",
+    NOT = "NOT",
+    ASSIGN = "ASSIGN",
+    PLUS_ASSIGN = "PLUS_ASSIGN",
+    MINUS_ASSIGN = "MINUS_ASSIGN",
+    STAR_ASSIGN = "STAR_ASSIGN",
+    SLASH_ASSIGN = "SLASH_ASSIGN",
+    PERCENT_ASSIGN = "PERCENT_ASSIGN",
+    CARET_ASSIGN = "CARET_ASSIGN",
+    INCREMENT = "INCREMENT",
+    DECREMENT = "DECREMENT",
+    QUESTION = "QUESTION",
+    COLON = "COLON",
+    COMMA = "COMMA",
+    SEMICOLON = "SEMICOLON",
+    NEWLINE = "NEWLINE",
+    LPAREN = "LPAREN",
+    RPAREN = "RPAREN",
+    LBRACE = "LBRACE",
+    RBRACE = "RBRACE",
+    LBRACKET = "LBRACKET",
+    RBRACKET = "RBRACKET",
+    DOLLAR = "DOLLAR",
+    APPEND = "APPEND",
+    PIPE = "PIPE",
+    EOF = "EOF"
+}
+export interface Token {
+    type: TokenType;
+    value: string | number;
+    line: number;
+    column: number;
+}
+export declare class AwkLexer {
+    private input;
+    private pos;
+    private line;
+    private column;
+    private lastTokenType;
+    constructor(input: string);
+    tokenize(): Token[];
+    private makeToken;
+    private peek;
+    private advance;
+    private skipWhitespace;
+    private nextToken;
+    private canBeRegex;
+    private readString;
+    private readRegex;
+    private readNumber;
+    private readIdentifier;
+    private readOperator;
+    private isDigit;
+    private isAlpha;
+    private isAlphaNumeric;
+}

package/dist/commands/awk/parser2.d.ts

@@ -0,0 +1,73 @@
+/**
+ * AWK Parser
+ *
+ * Recursive descent parser that builds an AST from tokens.
+ */
+import type { AwkProgram } from "./ast.js";
+export declare class AwkParser {
+    private tokens;
+    private pos;
+    parse(input: string): AwkProgram;
+    private current;
+    private advance;
+    private match;
+    private check;
+    private expect;
+    private skipNewlines;
+    private skipTerminators;
+    private parseProgram;
+    private parseFunction;
+    private parseRule;
+    private parseBlock;
+    private parseStatement;
+    private parseIf;
+    private parseWhile;
+    private parseDoWhile;
+    private parseFor;
+    private parsePrint;
+    /**
+     * Parse a print argument - same as ternary but treats > and >> at the TOP LEVEL
+     * (not inside ternary) as redirection rather than comparison operators.
+     */
+    private parsePrintArg;
+    /**
+     * Look ahead to see if there's a ternary ? operator before the next statement terminator.
+     * This tells us whether > is comparison (in ternary condition) or redirection.
+     */
+    private lookAheadForTernary;
+    private parsePrintOr;
+    private parsePrintAnd;
+    private parsePrintIn;
+    private parsePrintMatch;
+    /**
+     * Like parseComparison but doesn't consume > and >> (for print redirection)
+     */
+    private parsePrintComparison;
+    private parsePrintf;
+    private parseExpression;
+    private parseAssignment;
+    private parseTernary;
+    private parseOr;
+    /**
+     * Continue parsing a logical OR/AND expression from a given left-hand side.
+     * Used when we've already parsed part of an expression (e.g., a regex in pattern context).
+     */
+    private parseLogicalOrRest;
+    /**
+     * Continue parsing a logical AND expression from a given left-hand side.
+     */
+    private parseLogicalAndRest;
+    private parseAnd;
+    private parseIn;
+    private parseMatch;
+    private parseComparison;
+    private parseConcatenation;
+    private canStartExpression;
+    private isComparisonOrHigherOp;
+    private parseAddSub;
+    private parseMulDiv;
+    private parseUnary;
+    private parsePower;
+    private parsePostfix;
+    private parsePrimary;
+}

package/dist/commands/find/matcher.d.ts

@@ -1,3 +1,7 @@
-import type { EvalContext, Expression } from "./types.js";
-export declare function evaluateExpression(expr: Expression, ctx: EvalContext): boolean;
+import type { EvalContext, EvalResult, Expression } from "./types.js";
+/**
+ * Evaluate a find expression and return both match result and prune flag.
+ * The prune flag is set when -prune is evaluated and returns true.
+ */
+export declare function evaluateExpressionWithPrune(expr: Expression, ctx: EvalContext): EvalResult;
 export declare function collectNewerRefs(expr: Expression | null): string[];

package/dist/commands/find/types.d.ts

@@ -6,6 +6,10 @@ export type Expression = {
     type: "path";
     pattern: string;
     ignoreCase?: boolean;
+} | {
+    type: "regex";
+    pattern: string;
+    ignoreCase?: boolean;
 } | {
     type: "type";
     fileType: "f" | "d";
@@ -27,6 +31,10 @@ export type Expression = {
     type: "perm";
     mode: number;
     matchType: "exact" | "all" | "any";
+} | {
+    type: "prune";
+} | {
+    type: "print";
 } | {
     type: "not";
     expr: Expression;
@@ -62,6 +70,11 @@ export interface EvalContext {
     mode: number;
     newerRefTimes: Map<string, number>;
 }
+export interface EvalResult {
+    matches: boolean;
+    pruned: boolean;
+    printed: boolean;
+}
 export interface ParseResult {
     expr: Expression | null;
     pathIndex: number;

package/dist/commands/sed/executor.d.ts

@@ -1,5 +1,5 @@
 import type { SedCommand, SedExecutionLimits, SedState } from "./types.js";
-export declare function createInitialState(totalLines: number): SedState;
+export declare function createInitialState(totalLines: number, filename?: string, rangeStates?: Map<string, import("./types.js").RangeState>): SedState;
 export interface ExecuteContext {
     lines: string[];
     currentLineIndex: number;

package/dist/commands/sed/lexer.d.ts

@@ -0,0 +1,74 @@
+/**
+ * SED Lexer
+ *
+ * Tokenizes sed scripts into a stream of tokens.
+ * Sed has context-sensitive tokenization - the meaning of characters
+ * depends heavily on what command is being parsed.
+ */
+export declare enum SedTokenType {
+    NUMBER = "NUMBER",
+    DOLLAR = "DOLLAR",// $ - last line
+    PATTERN = "PATTERN",// /regex/
+    STEP = "STEP",// first~step
+    LBRACE = "LBRACE",// {
+    RBRACE = "RBRACE",// }
+    SEMICOLON = "SEMICOLON",// ;
+    NEWLINE = "NEWLINE",
+    COMMA = "COMMA",// , - address range separator
+    COMMAND = "COMMAND",// p, d, h, H, g, G, x, n, N, P, D, q, Q, z, =, l, F, v
+    SUBSTITUTE = "SUBSTITUTE",// s/pattern/replacement/flags
+    TRANSLITERATE = "TRANSLITERATE",// y/source/dest/
+    LABEL_DEF = "LABEL_DEF",// :name
+    BRANCH = "BRANCH",// b [label]
+    BRANCH_ON_SUBST = "BRANCH_ON_SUBST",// t [label]
+    BRANCH_ON_NO_SUBST = "BRANCH_ON_NO_SUBST",// T [label]
+    TEXT_CMD = "TEXT_CMD",// a\, i\, c\ with text
+    FILE_READ = "FILE_READ",// r filename
+    FILE_READ_LINE = "FILE_READ_LINE",// R filename
+    FILE_WRITE = "FILE_WRITE",// w filename
+    FILE_WRITE_LINE = "FILE_WRITE_LINE",// W filename
+    EXECUTE = "EXECUTE",// e [command]
+    EOF = "EOF",
+    ERROR = "ERROR"
+}
+export interface SedToken {
+    type: SedTokenType;
+    value: string | number;
+    pattern?: string;
+    replacement?: string;
+    flags?: string;
+    source?: string;
+    dest?: string;
+    text?: string;
+    label?: string;
+    filename?: string;
+    command?: string;
+    first?: number;
+    step?: number;
+    line: number;
+    column: number;
+}
+export declare class SedLexer {
+    private input;
+    private pos;
+    private line;
+    private column;
+    constructor(input: string);
+    tokenize(): SedToken[];
+    private makeToken;
+    private peek;
+    private advance;
+    private skipWhitespace;
+    private nextToken;
+    private readNumber;
+    private readPattern;
+    private readLabelDef;
+    private readCommand;
+    private readSubstitute;
+    private readTransliterate;
+    private readTextCommand;
+    private readBranch;
+    private readFileCommand;
+    private readExecute;
+    private isDigit;
+}

package/dist/commands/sed/parser.d.ts

@@ -1,4 +1,8 @@
 import type { SedCommand } from "./types.js";
+/**
+ * Parse multiple sed scripts into a list of commands.
+ * This is the main entry point for parsing sed scripts.
+ */
 export declare function parseMultipleScripts(scripts: string[], extendedRegex?: boolean): {
     commands: SedCommand[];
     error?: string;

package/dist/commands/sed/types.d.ts

@@ -9,7 +9,7 @@ export interface AddressRange {
     start?: SedAddress;
     end?: SedAddress;
 }
-export type SedCommandType = "substitute" | "print" | "printFirstLine" | "delete" | "deleteFirstLine" | "append" | "insert" | "change" | "hold" | "holdAppend" | "get" | "getAppend" | "exchange" | "next" | "nextAppend" | "quit" | "transliterate" | "lineNumber" | "branch" | "branchOnSubst" | "branchOnNoSubst" | "label" | "zap" | "group";
+export type SedCommandType = "substitute" | "print" | "printFirstLine" | "delete" | "deleteFirstLine" | "append" | "insert" | "change" | "hold" | "holdAppend" | "get" | "getAppend" | "exchange" | "next" | "nextAppend" | "quit" | "quitSilent" | "transliterate" | "lineNumber" | "branch" | "branchOnSubst" | "branchOnNoSubst" | "label" | "zap" | "group" | "list" | "printFilename" | "version" | "readFile" | "readFileLine" | "writeFile" | "writeFirstLine" | "execute";
 export interface SubstituteCommand {
     type: "substitute";
     address?: AddressRange;
@@ -71,6 +71,12 @@ export interface NextCommand {
 export interface QuitCommand {
     type: "quit";
     address?: AddressRange;
+    exitCode?: number;
+}
+export interface QuitSilentCommand {
+    type: "quitSilent";
+    address?: AddressRange;
+    exitCode?: number;
 }
 export interface NextAppendCommand {
     type: "nextAppend";
@@ -122,7 +128,45 @@ export interface GroupCommand {
     address?: AddressRange;
     commands: SedCommand[];
 }
-export type SedCommand = SubstituteCommand | PrintCommand | PrintFirstLineCommand | DeleteCommand | DeleteFirstLineCommand | AppendCommand | InsertCommand | ChangeCommand | HoldCommand | HoldAppendCommand | GetCommand | GetAppendCommand | ExchangeCommand | NextCommand | QuitCommand | NextAppendCommand | TransliterateCommand | LineNumberCommand | BranchCommand | BranchOnSubstCommand | BranchOnNoSubstCommand | LabelCommand | ZapCommand | GroupCommand;
+export interface ListCommand {
+    type: "list";
+    address?: AddressRange;
+}
+export interface PrintFilenameCommand {
+    type: "printFilename";
+    address?: AddressRange;
+}
+export interface VersionCommand {
+    type: "version";
+    address?: AddressRange;
+    minVersion?: string;
+}
+export interface ReadFileCommand {
+    type: "readFile";
+    address?: AddressRange;
+    filename: string;
+}
+export interface ReadFileLineCommand {
+    type: "readFileLine";
+    address?: AddressRange;
+    filename: string;
+}
+export interface WriteFileCommand {
+    type: "writeFile";
+    address?: AddressRange;
+    filename: string;
+}
+export interface WriteFirstLineCommand {
+    type: "writeFirstLine";
+    address?: AddressRange;
+    filename: string;
+}
+export interface ExecuteCommand {
+    type: "execute";
+    address?: AddressRange;
+    command?: string;
+}
+export type SedCommand = SubstituteCommand | PrintCommand | PrintFirstLineCommand | DeleteCommand | DeleteFirstLineCommand | AppendCommand | InsertCommand | ChangeCommand | HoldCommand | HoldAppendCommand | GetCommand | GetAppendCommand | ExchangeCommand | NextCommand | QuitCommand | QuitSilentCommand | NextAppendCommand | TransliterateCommand | LineNumberCommand | BranchCommand | BranchOnSubstCommand | BranchOnNoSubstCommand | LabelCommand | ZapCommand | GroupCommand | ListCommand | PrintFilenameCommand | VersionCommand | ReadFileCommand | ReadFileLineCommand | WriteFileCommand | WriteFirstLineCommand | ExecuteCommand;
 export interface SedState {
     patternSpace: string;
     holdSpace: string;
@@ -131,10 +175,30 @@ export interface SedState {
     deleted: boolean;
     printed: boolean;
     quit: boolean;
+    quitSilent: boolean;
+    exitCode?: number;
     appendBuffer: string[];
     substitutionMade: boolean;
     lineNumberOutput: string[];
     restartCycle: boolean;
+    currentFilename?: string;
+    pendingFileReads: Array<{
+        filename: string;
+        wholeFile: boolean;
+    }>;
+    pendingFileWrites: Array<{
+        filename: string;
+        content: string;
+    }>;
+    pendingExecute?: {
+        command: string;
+        replacePattern: boolean;
+    };
+    rangeStates: Map<string, RangeState>;
+}
+export interface RangeState {
+    active: boolean;
+    startLine?: number;
 }
 export interface SedExecutionLimits {
     maxIterations: number;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export type { BashOptions, ExecOptions } from "./Bash.js";
+export type { BashLogger, BashOptions, ExecOptions } from "./Bash.js";
 export { Bash } from "./Bash.js";
 export type { AllCommandName, CommandName, NetworkCommandName, } from "./commands/registry.js";
 export { getCommandNames, getNetworkCommandNames, } from "./commands/registry.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "just-bash",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "A simulated bash environment with virtual filesystem",
   "repository": {
     "type": "git",