shell-dsl 0.0.7 → 0.0.8

package/dist/cjs/src/commands/wc/wc.cjs

@@ -0,0 +1,116 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/commands/wc/wc.ts
+var exports_wc = {};
+__export(exports_wc, {
+  wc: () => wc
+});
+module.exports = __toCommonJS(exports_wc);
+var wc = async (ctx) => {
+  let showLines = false;
+  let showWords = false;
+  let showChars = false;
+  const files = [];
+  for (const arg of ctx.args) {
+    if (arg === "-l") {
+      showLines = true;
+    } else if (arg === "-w") {
+      showWords = true;
+    } else if (arg === "-c" || arg === "-m") {
+      showChars = true;
+    } else if (arg.startsWith("-")) {
+      for (const flag of arg.slice(1)) {
+        if (flag === "l")
+          showLines = true;
+        else if (flag === "w")
+          showWords = true;
+        else if (flag === "c" || flag === "m")
+          showChars = true;
+      }
+    } else {
+      files.push(arg);
+    }
+  }
+  if (!showLines && !showWords && !showChars) {
+    showLines = true;
+    showWords = true;
+    showChars = true;
+  }
+  const countContent = (content) => {
+    const lines = content.split(`
+`).length - (content.endsWith(`
+`) ? 1 : 0);
+    const words = content.split(/\s+/).filter((w) => w.length > 0).length;
+    const chars = content.length;
+    return { lines, words, chars };
+  };
+  const formatOutput = (counts, filename) => {
+    const parts = [];
+    if (showLines)
+      parts.push(String(counts.lines).padStart(8));
+    if (showWords)
+      parts.push(String(counts.words).padStart(8));
+    if (showChars)
+      parts.push(String(counts.chars).padStart(8));
+    if (filename)
+      parts.push(" " + filename);
+    return parts.join("") + `
+`;
+  };
+  if (files.length === 0) {
+    const content = await ctx.stdin.text();
+    const counts = countContent(content);
+    await ctx.stdout.writeText(formatOutput(counts));
+  } else {
+    let totalLines = 0;
+    let totalWords = 0;
+    let totalChars = 0;
+    for (const file of files) {
+      try {
+        const path = ctx.fs.resolve(ctx.cwd, file);
+        const content = (await ctx.fs.readFile(path)).toString();
+        const counts = countContent(content);
+        totalLines += counts.lines;
+        totalWords += counts.words;
+        totalChars += counts.chars;
+        await ctx.stdout.writeText(formatOutput(counts, file));
+      } catch (err) {
+        await ctx.stderr.writeText(`wc: ${file}: No such file or directory
+`);
+        return 1;
+      }
+    }
+    if (files.length > 1) {
+      await ctx.stdout.writeText(formatOutput({ lines: totalLines, words: totalWords, chars: totalChars }, "total"));
+    }
+  }
+  return 0;
+};
+
+//# debugId=075B5E90AE53867D64756E2164756E21

package/dist/cjs/src/commands/wc/wc.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/commands/wc/wc.ts"],
+  "sourcesContent": [
+    "import type { Command } from \"../../types.cjs\";\n\nexport const wc: Command = async (ctx) => {\n  let showLines = false;\n  let showWords = false;\n  let showChars = false;\n  const files: string[] = [];\n\n  // Parse arguments\n  for (const arg of ctx.args) {\n    if (arg === \"-l\") {\n      showLines = true;\n    } else if (arg === \"-w\") {\n      showWords = true;\n    } else if (arg === \"-c\" || arg === \"-m\") {\n      showChars = true;\n    } else if (arg.startsWith(\"-\")) {\n      // Handle combined flags\n      for (const flag of arg.slice(1)) {\n        if (flag === \"l\") showLines = true;\n        else if (flag === \"w\") showWords = true;\n        else if (flag === \"c\" || flag === \"m\") showChars = true;\n      }\n    } else {\n      files.push(arg);\n    }\n  }\n\n  // Default: show all\n  if (!showLines && !showWords && !showChars) {\n    showLines = true;\n    showWords = true;\n    showChars = true;\n  }\n\n  const countContent = (content: string) => {\n    const lines = content.split(\"\\n\").length - (content.endsWith(\"\\n\") ? 1 : 0);\n    const words = content.split(/\\s+/).filter((w) => w.length > 0).length;\n    const chars = content.length;\n    return { lines, words, chars };\n  };\n\n  const formatOutput = (counts: { lines: number; words: number; chars: number }, filename?: string) => {\n    const parts: string[] = [];\n    if (showLines) parts.push(String(counts.lines).padStart(8));\n    if (showWords) parts.push(String(counts.words).padStart(8));\n    if (showChars) parts.push(String(counts.chars).padStart(8));\n    if (filename) parts.push(\" \" + filename);\n    return parts.join(\"\") + \"\\n\";\n  };\n\n  if (files.length === 0) {\n    // Read from stdin\n    const content = await ctx.stdin.text();\n    const counts = countContent(content);\n    await ctx.stdout.writeText(formatOutput(counts));\n  } else {\n    let totalLines = 0;\n    let totalWords = 0;\n    let totalChars = 0;\n\n    for (const file of files) {\n      try {\n        const path = ctx.fs.resolve(ctx.cwd, file);\n        const content = (await ctx.fs.readFile(path)).toString();\n        const counts = countContent(content);\n        totalLines += counts.lines;\n        totalWords += counts.words;\n        totalChars += counts.chars;\n        await ctx.stdout.writeText(formatOutput(counts, file));\n      } catch (err) {\n        await ctx.stderr.writeText(`wc: ${file}: No such file or directory\\n`);\n        return 1;\n      }\n    }\n\n    if (files.length > 1) {\n      await ctx.stdout.writeText(\n        formatOutput({ lines: totalLines, words: totalWords, chars: totalChars }, \"total\")\n      );\n    }\n  }\n\n  return 0;\n};\n"
+  ],
+  "mappings": "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",
+  "debugId": "075B5E90AE53867D64756E2164756E21",
+  "names": []
+}

package/dist/cjs/src/index.cjs

@@ -32,16 +32,22 @@ __export(exports_src, {
   tokenToString: () => import_lexer.tokenToString,
   parse: () => import_parser.parse,
   lex: () => import_lexer.lex,
+  isWhileNode: () => import_parser2.isWhileNode,
   isVariableNode: () => import_parser2.isVariableNode,
+  isUntilNode: () => import_parser2.isUntilNode,
   isSubstitutionNode: () => import_parser2.isSubstitutionNode,
   isSequenceNode: () => import_parser2.isSequenceNode,
   isRawValue: () => import_types.isRawValue,
   isPipelineNode: () => import_parser2.isPipelineNode,
   isOrNode: () => import_parser2.isOrNode,
   isLiteralNode: () => import_parser2.isLiteralNode,
+  isIfNode: () => import_parser2.isIfNode,
   isGlobNode: () => import_parser2.isGlobNode,
+  isForNode: () => import_parser2.isForNode,
   isConcatNode: () => import_parser2.isConcatNode,
   isCommandNode: () => import_parser2.isCommandNode,
+  isCaseNode: () => import_parser2.isCaseNode,
+  isArithmeticNode: () => import_parser2.isArithmeticNode,
   isAndNode: () => import_parser2.isAndNode,
   escapeForInterpolation: () => import_utils.escapeForInterpolation,
   escape: () => import_utils.escape,
@@ -63,7 +69,9 @@ __export(exports_src, {
   Lexer: () => import_lexer.Lexer,
   LexError: () => import_errors.LexError,
   Interpreter: () => import_interpreter.Interpreter,
-  FileSystem: () => import_fs2.FileSystem
+  FileSystem: () => import_fs2.FileSystem,
+  ContinueException: () => import_interpreter.ContinueException,
+  BreakException: () => import_interpreter.BreakException
 });
 module.exports = __toCommonJS(exports_src);
 var import_shell_dsl = require("./shell-dsl.cjs");
@@ -80,4 +88,4 @@ var import_io = require("./io/index.cjs");
 var import_io2 = require("./io/index.cjs");
 var import_utils = require("./utils/index.cjs");
 
-//# debugId=308511120A1E796164756E2164756E21
+//# debugId=A00B7F9271C525C564756E2164756E21

package/dist/cjs/src/index.cjs.map

@@ -2,9 +2,9 @@
   "version": 3,
   "sources": ["../../../src/index.ts"],
   "sourcesContent": [
-    "// Main class exports\nexport { ShellDSL, createShellDSL, type Program } from \"./shell-dsl.cjs\";\nexport { ShellPromise, type ShellPromiseOptions } from \"./shell-promise.cjs\";\n\n// Types\nexport type {\n  VirtualFS,\n  FileStat,\n  Command,\n  CommandContext,\n  Stdin,\n  Stdout,\n  Stderr,\n  OutputCollector,\n  ExecResult,\n  ShellConfig,\n  RawValue,\n} from \"./types.cjs\";\nexport { isRawValue } from \"./types.cjs\";\n\n// Errors\nexport { ShellError, LexError, ParseError } from \"./errors.cjs\";\n\n// Lexer\nexport { Lexer, lex, tokenToString } from \"./lexer/index.cjs\";\nexport type { Token, RedirectMode } from \"./lexer/index.cjs\";\n\n// Parser\nexport { Parser, parse } from \"./parser/index.cjs\";\nexport type {\n  ASTNode,\n  Redirect,\n  CommandNode,\n  PipelineNode,\n  AndNode,\n  OrNode,\n  SequenceNode,\n  LiteralNode,\n  VariableNode,\n  SubstitutionNode,\n  GlobNode,\n  ConcatNode,\n} from \"./parser/index.cjs\";\nexport {\n  isCommandNode,\n  isPipelineNode,\n  isAndNode,\n  isOrNode,\n  isSequenceNode,\n  isLiteralNode,\n  isVariableNode,\n  isSubstitutionNode,\n  isGlobNode,\n  isConcatNode,\n} from \"./parser/index.cjs\";\n\n// Interpreter\nexport { Interpreter, type InterpreterOptions } from \"./interpreter/index.cjs\";\n\n// Filesystem\nexport { createVirtualFS } from \"./fs/index.cjs\";\nexport {\n  FileSystem,\n  ReadOnlyFileSystem,\n  type Permission,\n  type PermissionRules,\n  type UnderlyingFS,\n} from \"./fs/index.cjs\";\n\n// I/O\nexport { createStdin, StdinImpl } from \"./io/index.cjs\";\nexport { createStdout, createStderr, createPipe, OutputCollectorImpl, PipeBuffer } from \"./io/index.cjs\";\n\n// Utilities\nexport { escape, escapeForInterpolation } from \"./utils/index.cjs\";\n"
+    "// Main class exports\nexport { ShellDSL, createShellDSL, type Program } from \"./shell-dsl.cjs\";\nexport { ShellPromise, type ShellPromiseOptions } from \"./shell-promise.cjs\";\n\n// Types\nexport type {\n  VirtualFS,\n  FileStat,\n  Command,\n  CommandContext,\n  Stdin,\n  Stdout,\n  Stderr,\n  OutputCollector,\n  ExecResult,\n  ShellConfig,\n  RawValue,\n} from \"./types.cjs\";\nexport { isRawValue } from \"./types.cjs\";\n\n// Errors\nexport { ShellError, LexError, ParseError } from \"./errors.cjs\";\n\n// Lexer\nexport { Lexer, lex, tokenToString } from \"./lexer/index.cjs\";\nexport type { Token, RedirectMode } from \"./lexer/index.cjs\";\n\n// Parser\nexport { Parser, parse } from \"./parser/index.cjs\";\nexport type {\n  ASTNode,\n  Redirect,\n  CommandNode,\n  PipelineNode,\n  AndNode,\n  OrNode,\n  SequenceNode,\n  LiteralNode,\n  VariableNode,\n  SubstitutionNode,\n  GlobNode,\n  ConcatNode,\n  IfNode,\n  ForNode,\n  WhileNode,\n  UntilNode,\n  CaseNode,\n  CaseClause,\n  ArithmeticNode,\n} from \"./parser/index.cjs\";\nexport {\n  isCommandNode,\n  isPipelineNode,\n  isAndNode,\n  isOrNode,\n  isSequenceNode,\n  isLiteralNode,\n  isVariableNode,\n  isSubstitutionNode,\n  isGlobNode,\n  isConcatNode,\n  isIfNode,\n  isForNode,\n  isWhileNode,\n  isUntilNode,\n  isCaseNode,\n  isArithmeticNode,\n} from \"./parser/index.cjs\";\n\n// Interpreter\nexport { Interpreter, type InterpreterOptions, BreakException, ContinueException } from \"./interpreter/index.cjs\";\n\n// Filesystem\nexport { createVirtualFS } from \"./fs/index.cjs\";\nexport {\n  FileSystem,\n  ReadOnlyFileSystem,\n  type Permission,\n  type PermissionRules,\n  type UnderlyingFS,\n} from \"./fs/index.cjs\";\n\n// I/O\nexport { createStdin, StdinImpl } from \"./io/index.cjs\";\nexport { createStdout, createStderr, createPipe, OutputCollectorImpl, PipeBuffer } from \"./io/index.cjs\";\n\n// Utilities\nexport { escape, escapeForInterpolation } from \"./utils/index.cjs\";\n"
   ],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACuD,IAAvD;AACuD,IAAvD;AAgB2B,IAA3B;AAGiD,IAAjD;AAG0C,IAA1C;AAI8B,IAA9B;AA0BO,IAXP;AAcqD,IAArD;AAGgC,IAAhC;AAOO,IANP;AASuC,IAAvC;AACwF,IAAxF;AAG+C,IAA/C;",
-  "debugId": "308511120A1E796164756E2164756E21",
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACuD,IAAvD;AACuD,IAAvD;AAgB2B,IAA3B;AAGiD,IAAjD;AAG0C,IAA1C;AAI8B,IAA9B;AAuCO,IAjBP;AAoBwF,IAAxF;AAGgC,IAAhC;AAOO,IANP;AASuC,IAAvC;AACwF,IAAxF;AAG+C,IAA/C;",
+  "debugId": "A00B7F9271C525C564756E2164756E21",
   "names": []
 }

package/dist/cjs/src/interpreter/index.cjs

@@ -30,10 +30,12 @@ var __export = (target, all) => {
 var exports_interpreter = {};
 __export(exports_interpreter, {
   createCommandContext: () => import_context.createCommandContext,
-  Interpreter: () => import_interpreter.Interpreter
+  Interpreter: () => import_interpreter.Interpreter,
+  ContinueException: () => import_interpreter.ContinueException,
+  BreakException: () => import_interpreter.BreakException
 });
 module.exports = __toCommonJS(exports_interpreter);
 var import_interpreter = require("./interpreter.cjs");
 var import_context = require("./context.cjs");
 
-//# debugId=1DFD5D0BB70402B864756E2164756E21
+//# debugId=50C2A317A8EA744B64756E2164756E21

package/dist/cjs/src/interpreter/index.cjs.map

@@ -2,9 +2,9 @@
   "version": 3,
   "sources": ["../../../../src/interpreter/index.ts"],
   "sourcesContent": [
-    "export { Interpreter, type InterpreterOptions } from \"./interpreter.cjs\";\nexport { createCommandContext, type ContextOptions } from \"./context.cjs\";\n"
+    "export { Interpreter, type InterpreterOptions, BreakException, ContinueException } from \"./interpreter.cjs\";\nexport { createCommandContext, type ContextOptions } from \"./context.cjs\";\n"
   ],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAqD,IAArD;AAC0D,IAA1D;",
-  "debugId": "1DFD5D0BB70402B864756E2164756E21",
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAwF,IAAxF;AAC0D,IAA1D;",
+  "debugId": "50C2A317A8EA744B64756E2164756E21",
   "names": []
 }

package/dist/cjs/src/interpreter/interpreter.cjs

@@ -29,19 +29,38 @@ var __export = (target, all) => {
 // src/interpreter/interpreter.ts
 var exports_interpreter = {};
 __export(exports_interpreter, {
-  Interpreter: () => Interpreter
+  Interpreter: () => Interpreter,
+  ContinueException: () => ContinueException,
+  BreakException: () => BreakException
 });
 module.exports = __toCommonJS(exports_interpreter);
 var import_context = require("./context.cjs");
 var import_stdin = require("../io/stdin.cjs");
 var import_stdout = require("../io/stdout.cjs");
 
+class BreakException extends Error {
+  levels;
+  constructor(levels = 1) {
+    super("break");
+    this.levels = levels;
+  }
+}
+
+class ContinueException extends Error {
+  levels;
+  constructor(levels = 1) {
+    super("continue");
+    this.levels = levels;
+  }
+}
+
 class Interpreter {
   fs;
   cwd;
   env;
   commands;
   redirectObjects;
+  loopDepth = 0;
   constructor(options) {
     this.fs = options.fs;
     this.cwd = options.cwd;
@@ -49,6 +68,9 @@ class Interpreter {
     this.commands = options.commands;
     this.redirectObjects = options.redirectObjects ?? {};
   }
+  getLoopDepth() {
+    return this.loopDepth;
+  }
   async execute(ast) {
     const stdout = import_stdout.createStdout();
     const stderr = import_stdout.createStderr();
@@ -73,6 +95,16 @@ class Interpreter {
         return this.executeAnd(node.left, node.right, stdinSource, stdout, stderr);
       case "or":
         return this.executeOr(node.left, node.right, stdinSource, stdout, stderr);
+      case "if":
+        return this.executeIf(node, stdinSource, stdout, stderr);
+      case "for":
+        return this.executeFor(node, stdinSource, stdout, stderr);
+      case "while":
+        return this.executeWhile(node, stdinSource, stdout, stderr);
+      case "until":
+        return this.executeUntil(node, stdinSource, stdout, stderr);
+      case "case":
+        return this.executeCase(node, stdinSource, stdout, stderr);
       default:
         throw new Error(`Cannot execute node type: ${node.type}`);
     }
@@ -145,6 +177,9 @@ class Interpreter {
     try {
       exitCode = await command(ctx);
     } catch (err) {
+      if (err instanceof BreakException || err instanceof ContinueException) {
+        throw err;
+      }
       const message = err instanceof Error ? err.message : String(err);
       await stderr.writeText(`${name}: ${message}
 `);
@@ -348,6 +383,183 @@ class Interpreter {
     }
     return this.executeNode(right, stdinSource, stdout, stderr);
   }
+  async executeIf(node, stdinSource, stdout, stderr) {
+    const conditionCode = await this.executeNode(node.condition, stdinSource, stdout, stderr);
+    if (conditionCode === 0) {
+      return this.executeNode(node.thenBranch, stdinSource, stdout, stderr);
+    }
+    for (const elif of node.elifBranches) {
+      const elifConditionCode = await this.executeNode(elif.condition, stdinSource, stdout, stderr);
+      if (elifConditionCode === 0) {
+        return this.executeNode(elif.body, stdinSource, stdout, stderr);
+      }
+    }
+    if (node.elseBranch) {
+      return this.executeNode(node.elseBranch, stdinSource, stdout, stderr);
+    }
+    return 0;
+  }
+  async executeFor(node, stdinSource, stdout, stderr) {
+    const expandedItems = [];
+    for (const item of node.items) {
+      const evaluated = await this.evaluateNode(item);
+      if (item.type === "glob") {
+        const matches = await this.fs.glob(evaluated, { cwd: this.cwd });
+        if (matches.length > 0) {
+          expandedItems.push(...matches);
+        } else {
+          expandedItems.push(evaluated);
+        }
+      } else {
+        expandedItems.push(evaluated);
+      }
+    }
+    if (expandedItems.length === 0) {
+      return 0;
+    }
+    let lastExitCode = 0;
+    this.loopDepth++;
+    try {
+      for (const value of expandedItems) {
+        this.env[node.variable] = value;
+        try {
+          lastExitCode = await this.executeNode(node.body, stdinSource, stdout, stderr);
+        } catch (e) {
+          if (e instanceof ContinueException) {
+            if (e.levels > 1) {
+              e.levels--;
+              throw e;
+            }
+            continue;
+          }
+          if (e instanceof BreakException) {
+            if (e.levels > 1) {
+              e.levels--;
+              throw e;
+            }
+            break;
+          }
+          throw e;
+        }
+      }
+    } finally {
+      this.loopDepth--;
+    }
+    return lastExitCode;
+  }
+  async executeWhile(node, stdinSource, stdout, stderr) {
+    let lastExitCode = 0;
+    this.loopDepth++;
+    try {
+      while (true) {
+        const conditionCode = await this.executeNode(node.condition, stdinSource, stdout, stderr);
+        if (conditionCode !== 0) {
+          break;
+        }
+        try {
+          lastExitCode = await this.executeNode(node.body, stdinSource, stdout, stderr);
+        } catch (e) {
+          if (e instanceof ContinueException) {
+            if (e.levels > 1) {
+              e.levels--;
+              throw e;
+            }
+            continue;
+          }
+          if (e instanceof BreakException) {
+            if (e.levels > 1) {
+              e.levels--;
+              throw e;
+            }
+            break;
+          }
+          throw e;
+        }
+      }
+    } finally {
+      this.loopDepth--;
+    }
+    return lastExitCode;
+  }
+  async executeUntil(node, stdinSource, stdout, stderr) {
+    let lastExitCode = 0;
+    this.loopDepth++;
+    try {
+      while (true) {
+        const conditionCode = await this.executeNode(node.condition, stdinSource, stdout, stderr);
+        if (conditionCode === 0) {
+          break;
+        }
+        try {
+          lastExitCode = await this.executeNode(node.body, stdinSource, stdout, stderr);
+        } catch (e) {
+          if (e instanceof ContinueException) {
+            if (e.levels > 1) {
+              e.levels--;
+              throw e;
+            }
+            continue;
+          }
+          if (e instanceof BreakException) {
+            if (e.levels > 1) {
+              e.levels--;
+              throw e;
+            }
+            break;
+          }
+          throw e;
+        }
+      }
+    } finally {
+      this.loopDepth--;
+    }
+    return lastExitCode;
+  }
+  async executeCase(node, stdinSource, stdout, stderr) {
+    const word = await this.evaluateNode(node.word);
+    for (const clause of node.clauses) {
+      for (const patternNode of clause.patterns) {
+        const pattern = await this.evaluateNode(patternNode);
+        if (this.matchCasePattern(word, pattern)) {
+          return this.executeNode(clause.body, stdinSource, stdout, stderr);
+        }
+      }
+    }
+    return 0;
+  }
+  matchCasePattern(word, pattern) {
+    let regexStr = "^";
+    for (let i = 0;i < pattern.length; i++) {
+      const char = pattern[i];
+      if (char === "*") {
+        regexStr += ".*";
+      } else if (char === "?") {
+        regexStr += ".";
+      } else if (char === "[") {
+        let j = i + 1;
+        while (j < pattern.length && pattern[j] !== "]") {
+          j++;
+        }
+        if (j < pattern.length) {
+          regexStr += pattern.slice(i, j + 1);
+          i = j;
+        } else {
+          regexStr += "\\[";
+        }
+      } else if (/[.+^${}()|\\]/.test(char)) {
+        regexStr += "\\" + char;
+      } else {
+        regexStr += char;
+      }
+    }
+    regexStr += "$";
+    try {
+      const regex = new RegExp(regexStr);
+      return regex.test(word);
+    } catch {
+      return word === pattern;
+    }
+  }
   async evaluateNode(node, localEnv) {
     const env = localEnv ?? this.env;
     switch (node.type) {
@@ -369,10 +581,177 @@ class Interpreter {
         const output = await subStdout.collect();
         return output.toString("utf-8").replace(/\n+$/, "");
       }
+      case "arithmetic": {
+        const result = this.evaluateArithmetic(node.expression, env);
+        return String(result);
+      }
       default:
         throw new Error(`Cannot evaluate node type: ${node.type}`);
     }
   }
+  evaluateArithmetic(expression, env) {
+    let expandedExpr = expression;
+    expandedExpr = expandedExpr.replace(/\$\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g, (_, name) => {
+      return env[name] ?? "0";
+    });
+    expandedExpr = expandedExpr.replace(/\$([a-zA-Z_][a-zA-Z0-9_]*)/g, (_, name) => {
+      return env[name] ?? "0";
+    });
+    expandedExpr = expandedExpr.replace(/\b([a-zA-Z_][a-zA-Z0-9_]*)\b/g, (match) => {
+      if (/^\d+$/.test(match))
+        return match;
+      return env[match] ?? "0";
+    });
+    return this.parseArithmeticExpr(expandedExpr.trim());
+  }
+  parseArithmeticExpr(expr) {
+    let pos = 0;
+    const skipWhitespace = () => {
+      while (pos < expr.length && /\s/.test(expr[pos]))
+        pos++;
+    };
+    const parseNumber = () => {
+      skipWhitespace();
+      let numStr = "";
+      const negative = expr[pos] === "-";
+      if (negative) {
+        pos++;
+        skipWhitespace();
+      }
+      while (pos < expr.length && /[0-9]/.test(expr[pos])) {
+        numStr += expr[pos];
+        pos++;
+      }
+      if (numStr === "")
+        return 0;
+      return negative ? -parseInt(numStr, 10) : parseInt(numStr, 10);
+    };
+    const parsePrimary = () => {
+      skipWhitespace();
+      if (expr[pos] === "(") {
+        pos++;
+        const result = parseOr();
+        skipWhitespace();
+        if (expr[pos] === ")")
+          pos++;
+        return result;
+      }
+      return parseNumber();
+    };
+    const parseUnary = () => {
+      skipWhitespace();
+      if (expr[pos] === "-" && !/[0-9]/.test(expr[pos + 1] ?? "")) {
+        pos++;
+        return -parseUnary();
+      }
+      if (expr[pos] === "!") {
+        pos++;
+        return parseUnary() === 0 ? 1 : 0;
+      }
+      return parsePrimary();
+    };
+    const parseMulDiv = () => {
+      let left = parseUnary();
+      while (true) {
+        skipWhitespace();
+        const op = expr[pos];
+        if (op === "*" || op === "/" || op === "%") {
+          pos++;
+          const right = parseUnary();
+          if (op === "*")
+            left = left * right;
+          else if (op === "/")
+            left = right === 0 ? 0 : Math.trunc(left / right);
+          else
+            left = right === 0 ? 0 : left % right;
+        } else {
+          break;
+        }
+      }
+      return left;
+    };
+    const parseAddSub = () => {
+      let left = parseMulDiv();
+      while (true) {
+        skipWhitespace();
+        const op = expr[pos];
+        if (op === "+" || op === "-" && !/[0-9]/.test(expr[pos + 1] ?? "")) {
+          pos++;
+          const right = parseMulDiv();
+          if (op === "+")
+            left = left + right;
+          else
+            left = left - right;
+        } else {
+          break;
+        }
+      }
+      return left;
+    };
+    const parseComparison = () => {
+      let left = parseAddSub();
+      while (true) {
+        skipWhitespace();
+        if (expr.slice(pos, pos + 2) === "<=") {
+          pos += 2;
+          const right = parseAddSub();
+          left = left <= right ? 1 : 0;
+        } else if (expr.slice(pos, pos + 2) === ">=") {
+          pos += 2;
+          const right = parseAddSub();
+          left = left >= right ? 1 : 0;
+        } else if (expr.slice(pos, pos + 2) === "==") {
+          pos += 2;
+          const right = parseAddSub();
+          left = left === right ? 1 : 0;
+        } else if (expr.slice(pos, pos + 2) === "!=") {
+          pos += 2;
+          const right = parseAddSub();
+          left = left !== right ? 1 : 0;
+        } else if (expr[pos] === "<") {
+          pos++;
+          const right = parseAddSub();
+          left = left < right ? 1 : 0;
+        } else if (expr[pos] === ">") {
+          pos++;
+          const right = parseAddSub();
+          left = left > right ? 1 : 0;
+        } else {
+          break;
+        }
+      }
+      return left;
+    };
+    const parseAnd = () => {
+      let left = parseComparison();
+      while (true) {
+        skipWhitespace();
+        if (expr.slice(pos, pos + 2) === "&&") {
+          pos += 2;
+          const right = parseComparison();
+          left = left !== 0 && right !== 0 ? 1 : 0;
+        } else {
+          break;
+        }
+      }
+      return left;
+    };
+    const parseOr = () => {
+      let left = parseAnd();
+      while (true) {
+        skipWhitespace();
+        if (expr.slice(pos, pos + 2) === "||") {
+          pos += 2;
+          const right = parseAnd();
+          left = left !== 0 || right !== 0 ? 1 : 0;
+        } else {
+          break;
+        }
+      }
+      return left;
+    };
+    return parseOr();
+  }
   setCwd(cwd) {
     this.cwd = cwd;
   }
@@ -387,4 +766,4 @@ class Interpreter {
   }
 }
 
-//# debugId=5AFD9CE7FC1DFBCF64756E2164756E21
+//# debugId=E87B7B56CD04A5F564756E2164756E21