just-bash 1.1.0 → 1.2.1

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/dist/interpreter/errors.d.ts

@@ -99,6 +99,14 @@ export declare class ExecutionLimitError extends ControlFlowError {
     static readonly EXIT_CODE = 126;
     constructor(message: string, limitType: "recursion" | "commands" | "iterations", stdout?: string, stderr?: string);
 }
+/**
+ * Error thrown when break/continue is called in a subshell that was
+ * spawned from within a loop context. Causes the subshell to exit cleanly.
+ */
+export declare class SubshellExitError extends ControlFlowError {
+    readonly name = "SubshellExitError";
+    constructor(stdout?: string, stderr?: string);
+}
 /**
  * Type guard for errors that exit the current scope (return, break, continue).
  * These need special handling vs errexit/nounset which terminate execution.

package/dist/interpreter/types.d.ts

@@ -37,6 +37,8 @@ export interface InterpreterState {
     inCondition: boolean;
     /** Current loop nesting depth (for break/continue) */
     loopDepth: number;
+    /** True if this subshell was spawned from within a loop context (for break/continue to exit subshell) */
+    parentHasLoopContext?: boolean;
     /** Stdin available for commands in compound commands (groups, subshells, while loops with piped input) */
     groupStdin?: string;
     /** Set of variable names that are readonly */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "just-bash",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "A simulated bash environment with virtual filesystem",
   "repository": {
     "type": "git",
@@ -97,6 +97,7 @@
     "test:dist": "vitest run src/cli/just-bash.bundle.test.ts",
     "test:unit": "vitest run --config vitest.unit.config.ts",
     "test:comparison": "vitest run --config vitest.comparison.config.ts",
+    "test:comparison:record": "RECORD_FIXTURES=1 vitest run --config vitest.comparison.config.ts",
     "shell": "npx tsx src/cli/shell.ts",
     "dev:exec": "npx tsx src/cli/exec.ts"
   }