shell-dsl 0.0.1 → 0.0.2

package/dist/cjs/src/shell-promise.cjs

@@ -0,0 +1,159 @@
+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/shell-promise.ts
+var exports_shell_promise = {};
+__export(exports_shell_promise, {
+  ShellPromise: () => ShellPromise
+});
+module.exports = __toCommonJS(exports_shell_promise);
+var import_errors = require("./errors.cjs");
+
+class ShellPromise {
+  executor;
+  cwdOverride;
+  envOverride;
+  shouldThrow;
+  isQuiet;
+  cachedResult;
+  constructor(options) {
+    this.executor = options.execute;
+    this.cwdOverride = options.cwdOverride;
+    this.envOverride = options.envOverride;
+    this.shouldThrow = options.shouldThrow ?? true;
+    this.isQuiet = options.quiet ?? false;
+  }
+  async run() {
+    if (!this.cachedResult) {
+      this.cachedResult = this.executor({
+        cwd: this.cwdOverride,
+        env: this.envOverride
+      });
+    }
+    const result = await this.cachedResult;
+    if (this.shouldThrow && result.exitCode !== 0) {
+      throw new import_errors.ShellError(`Command failed with exit code ${result.exitCode}`, result.stdout, result.stderr, result.exitCode);
+    }
+    return result;
+  }
+  then(onfulfilled, onrejected) {
+    return this.run().then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.run().catch(onrejected);
+  }
+  finally(onfinally) {
+    return this.run().finally(onfinally);
+  }
+  async text() {
+    const result = await this.run();
+    return result.stdout.toString("utf-8");
+  }
+  async json() {
+    const text = await this.text();
+    return JSON.parse(text);
+  }
+  async* lines() {
+    const text = await this.text();
+    const lines = text.split(`
+`);
+    if (lines[lines.length - 1] === "") {
+      lines.pop();
+    }
+    for (const line of lines) {
+      yield line;
+    }
+  }
+  async blob() {
+    const result = await this.run();
+    return new Blob([result.stdout]);
+  }
+  async buffer() {
+    const result = await this.run();
+    return result.stdout;
+  }
+  quiet() {
+    return new ShellPromise({
+      execute: this.executor,
+      cwdOverride: this.cwdOverride,
+      envOverride: this.envOverride,
+      shouldThrow: this.shouldThrow,
+      quiet: true
+    });
+  }
+  nothrow() {
+    return new ShellPromise({
+      execute: this.executor,
+      cwdOverride: this.cwdOverride,
+      envOverride: this.envOverride,
+      shouldThrow: false,
+      quiet: this.isQuiet
+    });
+  }
+  throws(enable) {
+    return new ShellPromise({
+      execute: this.executor,
+      cwdOverride: this.cwdOverride,
+      envOverride: this.envOverride,
+      shouldThrow: enable,
+      quiet: this.isQuiet
+    });
+  }
+  cwd(path) {
+    return new ShellPromise({
+      execute: this.executor,
+      cwdOverride: path,
+      envOverride: this.envOverride,
+      shouldThrow: this.shouldThrow,
+      quiet: this.isQuiet
+    });
+  }
+  env(vars) {
+    return new ShellPromise({
+      execute: this.executor,
+      cwdOverride: this.cwdOverride,
+      envOverride: { ...this.envOverride, ...vars },
+      shouldThrow: this.shouldThrow,
+      quiet: this.isQuiet
+    });
+  }
+  getCwdOverride() {
+    return this.cwdOverride;
+  }
+  getEnvOverride() {
+    return this.envOverride;
+  }
+  getShouldThrow() {
+    return this.shouldThrow;
+  }
+  getIsQuiet() {
+    return this.isQuiet;
+  }
+}
+
+//# debugId=EB0C45A42A4FCC6464756E2164756E21

package/dist/cjs/src/shell-promise.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/shell-promise.ts"],
+  "sourcesContent": [
+    "import type { ExecResult } from \"./types.cjs\";\nimport { ShellError } from \"./errors.cjs\";\n\nexport interface ExecuteOverrides {\n  cwd?: string;\n  env?: Record<string, string>;\n}\n\nexport interface ShellPromiseOptions {\n  execute: (overrides: ExecuteOverrides) => Promise<ExecResult>;\n  cwdOverride?: string;\n  envOverride?: Record<string, string>;\n  shouldThrow?: boolean;\n  quiet?: boolean;\n}\n\nexport class ShellPromise implements PromiseLike<ExecResult> {\n  private executor: (overrides: ExecuteOverrides) => Promise<ExecResult>;\n  private cwdOverride?: string;\n  private envOverride?: Record<string, string>;\n  private shouldThrow: boolean;\n  private isQuiet: boolean;\n  private cachedResult?: Promise<ExecResult>;\n\n  constructor(options: ShellPromiseOptions) {\n    this.executor = options.execute;\n    this.cwdOverride = options.cwdOverride;\n    this.envOverride = options.envOverride;\n    this.shouldThrow = options.shouldThrow ?? true;\n    this.isQuiet = options.quiet ?? false;\n  }\n\n  private async run(): Promise<ExecResult> {\n    if (!this.cachedResult) {\n      this.cachedResult = this.executor({\n        cwd: this.cwdOverride,\n        env: this.envOverride,\n      });\n    }\n\n    const result = await this.cachedResult;\n\n    if (this.shouldThrow && result.exitCode !== 0) {\n      throw new ShellError(\n        `Command failed with exit code ${result.exitCode}`,\n        result.stdout,\n        result.stderr,\n        result.exitCode\n      );\n    }\n\n    return result;\n  }\n\n  then<TResult1 = ExecResult, TResult2 = never>(\n    onfulfilled?: ((value: ExecResult) => TResult1 | PromiseLike<TResult1>) | null,\n    onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null\n  ): Promise<TResult1 | TResult2> {\n    return this.run().then(onfulfilled, onrejected);\n  }\n\n  catch<TResult = never>(\n    onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null\n  ): Promise<ExecResult | TResult> {\n    return this.run().catch(onrejected);\n  }\n\n  finally(onfinally?: (() => void) | null): Promise<ExecResult> {\n    return this.run().finally(onfinally);\n  }\n\n  // Output formats\n  async text(): Promise<string> {\n    const result = await this.run();\n    return result.stdout.toString(\"utf-8\");\n  }\n\n  async json<T = unknown>(): Promise<T> {\n    const text = await this.text();\n    return JSON.parse(text);\n  }\n\n  async *lines(): AsyncIterable<string> {\n    const text = await this.text();\n    const lines = text.split(\"\\n\");\n    // Remove trailing empty line if present\n    if (lines[lines.length - 1] === \"\") {\n      lines.pop();\n    }\n    for (const line of lines) {\n      yield line;\n    }\n  }\n\n  async blob(): Promise<Blob> {\n    const result = await this.run();\n    return new Blob([result.stdout]);\n  }\n\n  async buffer(): Promise<Buffer> {\n    const result = await this.run();\n    return result.stdout;\n  }\n\n  // Behavior modifiers - return new ShellPromise with modified options\n  quiet(): ShellPromise {\n    return new ShellPromise({\n      execute: this.executor,\n      cwdOverride: this.cwdOverride,\n      envOverride: this.envOverride,\n      shouldThrow: this.shouldThrow,\n      quiet: true,\n    });\n  }\n\n  nothrow(): ShellPromise {\n    return new ShellPromise({\n      execute: this.executor,\n      cwdOverride: this.cwdOverride,\n      envOverride: this.envOverride,\n      shouldThrow: false,\n      quiet: this.isQuiet,\n    });\n  }\n\n  throws(enable: boolean): ShellPromise {\n    return new ShellPromise({\n      execute: this.executor,\n      cwdOverride: this.cwdOverride,\n      envOverride: this.envOverride,\n      shouldThrow: enable,\n      quiet: this.isQuiet,\n    });\n  }\n\n  // Context overrides - these need to be handled by the shell\n  cwd(path: string): ShellPromise {\n    return new ShellPromise({\n      execute: this.executor,\n      cwdOverride: path,\n      envOverride: this.envOverride,\n      shouldThrow: this.shouldThrow,\n      quiet: this.isQuiet,\n    });\n  }\n\n  env(vars: Record<string, string>): ShellPromise {\n    return new ShellPromise({\n      execute: this.executor,\n      cwdOverride: this.cwdOverride,\n      envOverride: { ...this.envOverride, ...vars },\n      shouldThrow: this.shouldThrow,\n      quiet: this.isQuiet,\n    });\n  }\n\n  // Getters for internal state (used by ShellDSL)\n  getCwdOverride(): string | undefined {\n    return this.cwdOverride;\n  }\n\n  getEnvOverride(): Record<string, string> | undefined {\n    return this.envOverride;\n  }\n\n  getShouldThrow(): boolean {\n    return this.shouldThrow;\n  }\n\n  getIsQuiet(): boolean {\n    return this.isQuiet;\n  }\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "EB0C45A42A4FCC6464756E2164756E21",
+  "names": []
+}

package/dist/cjs/src/types.cjs

@@ -0,0 +1,39 @@
+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/types.ts
+var exports_types = {};
+__export(exports_types, {
+  isRawValue: () => isRawValue
+});
+module.exports = __toCommonJS(exports_types);
+function isRawValue(value) {
+  return typeof value === "object" && value !== null && "raw" in value && typeof value.raw === "string";
+}
+
+//# debugId=113D0A18F6A625F664756E2164756E21

package/dist/cjs/src/types.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/types.ts"],
+  "sourcesContent": [
+    "// Virtual Filesystem Interface\nexport interface VirtualFS {\n  readFile(path: string): Promise<Buffer>;\n  readdir(path: string): Promise<string[]>;\n  stat(path: string): Promise<FileStat>;\n  exists(path: string): Promise<boolean>;\n\n  writeFile(path: string, data: Buffer | string): Promise<void>;\n  appendFile(path: string, data: Buffer | string): Promise<void>;\n  mkdir(path: string, opts?: { recursive?: boolean }): Promise<void>;\n\n  rm(path: string, opts?: { recursive?: boolean; force?: boolean }): Promise<void>;\n\n  resolve(...paths: string[]): string;\n  dirname(path: string): string;\n  basename(path: string): string;\n  glob(pattern: string, opts?: { cwd?: string }): Promise<string[]>;\n}\n\nexport interface FileStat {\n  isFile(): boolean;\n  isDirectory(): boolean;\n  size: number;\n  mtime: Date;\n}\n\n// Command Interfaces\nexport type Command = (ctx: CommandContext) => Promise<number>;\n\nexport interface CommandContext {\n  args: string[];\n  stdin: Stdin;\n  stdout: Stdout;\n  stderr: Stderr;\n  fs: VirtualFS;\n  cwd: string;\n  env: Record<string, string>;\n}\n\nexport interface Stdin {\n  stream(): AsyncIterable<Uint8Array>;\n  buffer(): Promise<Buffer>;\n  text(): Promise<string>;\n  lines(): AsyncIterable<string>;\n}\n\nexport interface Stdout {\n  write(chunk: Uint8Array): Promise<void>;\n  writeText(str: string): Promise<void>;\n}\n\nexport interface Stderr {\n  write(chunk: Uint8Array): Promise<void>;\n  writeText(str: string): Promise<void>;\n}\n\nexport interface OutputCollector extends Stdout {\n  close(): void;\n  collect(): Promise<Buffer>;\n  getReadableStream(): AsyncIterable<Uint8Array>;\n}\n\n// Execution Result\nexport interface ExecResult {\n  stdout: Buffer;\n  stderr: Buffer;\n  exitCode: number;\n}\n\n// Shell Configuration\nexport interface ShellConfig {\n  fs: VirtualFS;\n  cwd: string;\n  env: Record<string, string>;\n  commands: Record<string, Command>;\n}\n\n// Raw escape hatch type\nexport interface RawValue {\n  raw: string;\n}\n\nexport function isRawValue(value: unknown): value is RawValue {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    \"raw\" in value &&\n    typeof (value as RawValue).raw === \"string\"\n  );\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkFO,SAAS,UAAU,CAAC,OAAmC;AAAA,EAC5D,OACE,OAAO,UAAU,YACjB,UAAU,QACV,SAAS,SACT,OAAQ,MAAmB,QAAQ;AAAA;",
+  "debugId": "113D0A18F6A625F664756E2164756E21",
+  "names": []
+}

package/dist/cjs/src/utils/escape.cjs

@@ -0,0 +1,53 @@
+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/utils/escape.ts
+var exports_escape = {};
+__export(exports_escape, {
+  escapeForInterpolation: () => escapeForInterpolation,
+  escape: () => escape
+});
+module.exports = __toCommonJS(exports_escape);
+var SHELL_SPECIAL_CHARS = /[|&;<>()$`\\\"' \t\n*?[\]#~=%]/;
+function escape(str) {
+  if (str === "")
+    return "''";
+  if (!SHELL_SPECIAL_CHARS.test(str)) {
+    return str;
+  }
+  return "'" + str.replace(/'/g, "'\\''") + "'";
+}
+function escapeForInterpolation(value) {
+  if (value === null || value === undefined) {
+    return "";
+  }
+  const str = String(value);
+  return str.replace(/([|&;<>()$`\\\"' \t\n*?[\]#~=%])/g, "\\$1");
+}
+
+//# debugId=5EB64E92B679686C64756E2164756E21

package/dist/cjs/src/utils/escape.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/utils/escape.ts"],
+  "sourcesContent": [
+    "const SHELL_SPECIAL_CHARS = /[|&;<>()$`\\\\\\\"' \\t\\n*?[\\]#~=%]/;\n\nexport function escape(str: string): string {\n  if (str === \"\") return \"''\";\n\n  if (!SHELL_SPECIAL_CHARS.test(str)) {\n    return str;\n  }\n\n  // Escape using single quotes, handling embedded single quotes\n  return \"'\" + str.replace(/'/g, \"'\\\\''\") + \"'\";\n}\n\nexport function escapeForInterpolation(value: unknown): string {\n  if (value === null || value === undefined) {\n    return \"\";\n  }\n\n  const str = String(value);\n\n  // Escape shell special characters\n  return str.replace(/([|&;<>()$`\\\\\\\"' \\t\\n*?[\\]#~=%])/g, \"\\\\$1\");\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAM,sBAAsB;AAErB,SAAS,MAAM,CAAC,KAAqB;AAAA,EAC1C,IAAI,QAAQ;AAAA,IAAI,OAAO;AAAA,EAEvB,IAAI,CAAC,oBAAoB,KAAK,GAAG,GAAG;AAAA,IAClC,OAAO;AAAA,EACT;AAAA,EAGA,OAAO,MAAM,IAAI,QAAQ,MAAM,OAAO,IAAI;AAAA;AAGrC,SAAS,sBAAsB,CAAC,OAAwB;AAAA,EAC7D,IAAI,UAAU,QAAQ,UAAU,WAAW;AAAA,IACzC,OAAO;AAAA,EACT;AAAA,EAEA,MAAM,MAAM,OAAO,KAAK;AAAA,EAGxB,OAAO,IAAI,QAAQ,qCAAqC,MAAM;AAAA;",
+  "debugId": "5EB64E92B679686C64756E2164756E21",
+  "names": []
+}

package/dist/cjs/src/utils/index.cjs

@@ -0,0 +1,38 @@
+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/utils/index.ts
+var exports_utils = {};
+__export(exports_utils, {
+  escapeForInterpolation: () => import_escape.escapeForInterpolation,
+  escape: () => import_escape.escape
+});
+module.exports = __toCommonJS(exports_utils);
+var import_escape = require("./escape.cjs");
+
+//# debugId=FEDAA6A2654D061F64756E2164756E21

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

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/utils/index.ts"],
+  "sourcesContent": [
+    "export { escape, escapeForInterpolation } from \"./escape.cjs\";\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAA+C,IAA/C;",
+  "debugId": "FEDAA6A2654D061F64756E2164756E21",
+  "names": []
+}

package/dist/mjs/index.mjs

@@ -0,0 +1,42 @@
+// index.ts
+export * from "./src/index.mjs";
+import { builtinCommands } from "./commands/index.mjs";
+import {
+  echo,
+  cat,
+  grep,
+  wc,
+  head,
+  tail,
+  sort,
+  uniq,
+  pwd,
+  ls,
+  mkdir,
+  rm,
+  test,
+  bracket,
+  trueCmd,
+  falseCmd
+} from "./commands/index.mjs";
+export {
+  wc,
+  uniq,
+  trueCmd,
+  test,
+  tail,
+  sort,
+  rm,
+  pwd,
+  mkdir,
+  ls,
+  head,
+  grep,
+  falseCmd,
+  echo,
+  cat,
+  builtinCommands,
+  bracket
+};
+
+//# debugId=8985A8E9C45DB77F64756E2164756E21

package/dist/mjs/index.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../index.ts"],
+  "sourcesContent": [
+    "// Re-export everything from src\nexport * from \"./src/index.mjs\";\n\n// Re-export built-in commands\nexport { builtinCommands } from \"./commands/index.mjs\";\nexport {\n  echo,\n  cat,\n  grep,\n  wc,\n  head,\n  tail,\n  sort,\n  uniq,\n  pwd,\n  ls,\n  mkdir,\n  rm,\n  test,\n  bracket,\n  trueCmd,\n  falseCmd,\n} from \"./commands/index.mjs\";\n"
+  ],
+  "mappings": ";AACA;AAGA;AACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;",
+  "debugId": "8985A8E9C45DB77F64756E2164756E21",
+  "names": []
+}

package/dist/mjs/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "shell-dsl",
+  "version": "0.0.2",
+  "type": "module"
+}

package/dist/mjs/src/errors.mjs

@@ -0,0 +1,42 @@
+// src/errors.ts
+class ShellError extends Error {
+  stdout;
+  stderr;
+  exitCode;
+  constructor(message, stdout, stderr, exitCode) {
+    super(message);
+    this.name = "ShellError";
+    this.stdout = stdout;
+    this.stderr = stderr;
+    this.exitCode = exitCode;
+  }
+}
+
+class LexError extends Error {
+  position;
+  line;
+  column;
+  constructor(message, position, line, column) {
+    super(`Lex error at line ${line}, column ${column}: ${message}`);
+    this.name = "LexError";
+    this.position = position;
+    this.line = line;
+    this.column = column;
+  }
+}
+
+class ParseError extends Error {
+  position;
+  constructor(message, position) {
+    super(message);
+    this.name = "ParseError";
+    this.position = position;
+  }
+}
+export {
+  ShellError,
+  ParseError,
+  LexError
+};
+
+//# debugId=A9B170F479E4EAA464756E2164756E21

package/dist/mjs/src/errors.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/errors.ts"],
+  "sourcesContent": [
+    "export class ShellError extends Error {\n  stdout: Buffer;\n  stderr: Buffer;\n  exitCode: number;\n\n  constructor(message: string, stdout: Buffer, stderr: Buffer, exitCode: number) {\n    super(message);\n    this.name = \"ShellError\";\n    this.stdout = stdout;\n    this.stderr = stderr;\n    this.exitCode = exitCode;\n  }\n}\n\nexport class LexError extends Error {\n  position: number;\n  line: number;\n  column: number;\n\n  constructor(message: string, position: number, line: number, column: number) {\n    super(`Lex error at line ${line}, column ${column}: ${message}`);\n    this.name = \"LexError\";\n    this.position = position;\n    this.line = line;\n    this.column = column;\n  }\n}\n\nexport class ParseError extends Error {\n  position?: number;\n\n  constructor(message: string, position?: number) {\n    super(message);\n    this.name = \"ParseError\";\n    this.position = position;\n  }\n}\n"
+  ],
+  "mappings": ";AAAO,MAAM,mBAAmB,MAAM;AAAA,EACpC;AAAA,EACA;AAAA,EACA;AAAA,EAEA,WAAW,CAAC,SAAiB,QAAgB,QAAgB,UAAkB;AAAA,IAC7E,MAAM,OAAO;AAAA,IACb,KAAK,OAAO;AAAA,IACZ,KAAK,SAAS;AAAA,IACd,KAAK,SAAS;AAAA,IACd,KAAK,WAAW;AAAA;AAEpB;AAAA;AAEO,MAAM,iBAAiB,MAAM;AAAA,EAClC;AAAA,EACA;AAAA,EACA;AAAA,EAEA,WAAW,CAAC,SAAiB,UAAkB,MAAc,QAAgB;AAAA,IAC3E,MAAM,qBAAqB,gBAAgB,WAAW,SAAS;AAAA,IAC/D,KAAK,OAAO;AAAA,IACZ,KAAK,WAAW;AAAA,IAChB,KAAK,OAAO;AAAA,IACZ,KAAK,SAAS;AAAA;AAElB;AAAA;AAEO,MAAM,mBAAmB,MAAM;AAAA,EACpC;AAAA,EAEA,WAAW,CAAC,SAAiB,UAAmB;AAAA,IAC9C,MAAM,OAAO;AAAA,IACb,KAAK,OAAO;AAAA,IACZ,KAAK,WAAW;AAAA;AAEpB;",
+  "debugId": "A9B170F479E4EAA464756E2164756E21",
+  "names": []
+}

package/dist/mjs/src/fs/index.mjs

@@ -0,0 +1,7 @@
+// src/fs/index.ts
+import { createVirtualFS } from "./memfs-adapter.mjs";
+export {
+  createVirtualFS
+};
+
+//# debugId=6662852DAB957AC264756E2164756E21

package/dist/mjs/src/fs/index.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/fs/index.ts"],
+  "sourcesContent": [
+    "export { createVirtualFS } from \"./memfs-adapter.mjs\";\n"
+  ],
+  "mappings": ";AAAA;",
+  "debugId": "6662852DAB957AC264756E2164756E21",
+  "names": []
+}

package/dist/mjs/src/fs/memfs-adapter.mjs

@@ -0,0 +1,178 @@
+// src/fs/memfs-adapter.ts
+import * as pathModule from "path";
+function createVirtualFS(memfs) {
+  const { promises: fs } = memfs;
+  return {
+    async readFile(path) {
+      const content = await fs.readFile(path);
+      return Buffer.from(content);
+    },
+    async readdir(path) {
+      const entries = await fs.readdir(path);
+      return entries.map(String);
+    },
+    async stat(path) {
+      const stats = await fs.stat(path);
+      return {
+        isFile: () => stats.isFile(),
+        isDirectory: () => stats.isDirectory(),
+        size: Number(stats.size),
+        mtime: new Date(stats.mtime)
+      };
+    },
+    async exists(path) {
+      try {
+        await fs.stat(path);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    async writeFile(path, data) {
+      await fs.writeFile(path, data);
+    },
+    async appendFile(path, data) {
+      await fs.appendFile(path, data);
+    },
+    async mkdir(path, opts) {
+      await fs.mkdir(path, opts);
+    },
+    async rm(path, opts) {
+      try {
+        const stats = await fs.stat(path);
+        if (stats.isDirectory()) {
+          await fs.rmdir(path, { recursive: opts?.recursive });
+        } else {
+          await fs.unlink(path);
+        }
+      } catch (err) {
+        if (!opts?.force)
+          throw err;
+      }
+    },
+    resolve(...paths) {
+      return pathModule.resolve(...paths);
+    },
+    dirname(path) {
+      return pathModule.dirname(path);
+    },
+    basename(path) {
+      return pathModule.basename(path);
+    },
+    async glob(pattern, opts) {
+      const cwd = opts?.cwd ?? "/";
+      return expandGlob(memfs, pattern, cwd);
+    }
+  };
+}
+async function expandGlob(memfs, pattern, cwd) {
+  const { promises: fs } = memfs;
+  const patterns = expandBraces(pattern);
+  const allMatches = [];
+  for (const pat of patterns) {
+    const matches = await matchPattern(fs, pat, cwd);
+    allMatches.push(...matches);
+  }
+  return [...new Set(allMatches)].sort();
+}
+function expandBraces(pattern) {
+  const braceMatch = pattern.match(/\{([^{}]+)\}/);
+  if (!braceMatch)
+    return [pattern];
+  const before = pattern.slice(0, braceMatch.index);
+  const after = pattern.slice(braceMatch.index + braceMatch[0].length);
+  const options = braceMatch[1].split(",");
+  const results = [];
+  for (const opt of options) {
+    const expanded = expandBraces(before + opt + after);
+    results.push(...expanded);
+  }
+  return results;
+}
+async function matchPattern(fs, pattern, cwd) {
+  const parts = pattern.split("/").filter((p) => p !== "");
+  const isAbsolute = pattern.startsWith("/");
+  const startDir = isAbsolute ? "/" : cwd;
+  return matchParts(fs, parts, startDir, isAbsolute);
+}
+async function matchParts(fs, parts, currentPath, isAbsolute) {
+  if (parts.length === 0) {
+    return [currentPath];
+  }
+  const [part, ...rest] = parts;
+  if (part === "**") {
+    const results = [];
+    const withoutStar = await matchParts(fs, rest, currentPath, isAbsolute);
+    results.push(...withoutStar);
+    try {
+      const entries = await fs.readdir(currentPath);
+      for (const entry of entries) {
+        const entryPath = pathModule.join(currentPath, String(entry));
+        try {
+          const stat = await fs.stat(entryPath);
+          if (stat.isDirectory()) {
+            const subMatches = await matchParts(fs, parts, entryPath, isAbsolute);
+            results.push(...subMatches);
+          }
+        } catch {}
+      }
+    } catch {}
+    return results;
+  }
+  const regex = globToRegex(part);
+  try {
+    const entries = await fs.readdir(currentPath);
+    const results = [];
+    for (const entry of entries) {
+      const entryName = String(entry);
+      if (regex.test(entryName)) {
+        const entryPath = pathModule.join(currentPath, entryName);
+        if (rest.length === 0) {
+          results.push(entryPath);
+        } else {
+          try {
+            const stat = await fs.stat(entryPath);
+            if (stat.isDirectory()) {
+              const subMatches = await matchParts(fs, rest, entryPath, isAbsolute);
+              results.push(...subMatches);
+            }
+          } catch {}
+        }
+      }
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+function globToRegex(pattern) {
+  let regex = "^";
+  for (let i = 0;i < pattern.length; i++) {
+    const char = pattern[i];
+    if (char === "*") {
+      regex += "[^/]*";
+    } else if (char === "?") {
+      regex += "[^/]";
+    } else if (char === "[") {
+      let j = i + 1;
+      let classContent = "";
+      while (j < pattern.length && pattern[j] !== "]") {
+        classContent += pattern[j];
+        j++;
+      }
+      regex += `[${classContent}]`;
+      i = j;
+    } else if (".+^${}()|\\".includes(char)) {
+      regex += "\\" + char;
+    } else {
+      regex += char;
+    }
+  }
+  regex += "$";
+  return new RegExp(regex);
+}
+export {
+  createVirtualFS
+};
+
+//# debugId=018A285E726F353D64756E2164756E21