shell-dsl 0.0.32 → 0.0.34

package/README.md

@@ -36,6 +36,7 @@ bun add shell-dsl memfs
 - **Automatic escaping** — Interpolated values are escaped by default for safety
 - **POSIX-inspired syntax** — Pipes, redirects, control flow operators, and more
 - **Streaming pipelines** — Commands communicate via async iteration
+- **Version control** — Built-in VCS with commits, branches, checkout, and diffs on any virtual filesystem
 - **TypeScript-first** — Full type definitions included
 
 ## Getting Started
@@ -745,6 +746,130 @@ const fs = new FileSystem("/", {}, createWebUnderlyingFS(root));
 ```
 
 
+## Version Control
+
+`VersionControlSystem` adds git-like version control to any `VirtualFS`. It tracks changes as diffs, supports branching, and stores metadata in a `.vcs` directory.
+
+Ignore and attribute rules are configured directly on the constructor:
+
+```ts
+import { VersionControlSystem, createVirtualFS } from "shell-dsl";
+import { createFsFromVolume, Volume } from "memfs";
+
+const vol = new Volume();
+vol.fromJSON({
+  "/project/src/index.ts": 'console.log("hello")',
+  "/project/README.md": "# My Project",
+});
+const fs = createVirtualFS(createFsFromVolume(vol));
+
+const vcs = new VersionControlSystem({
+  fs,
+  path: "/project",
+  ignore: ["dist", "*.log"],
+  attributes: [
+    { pattern: "assets/*.png", diff: "binary" },
+    { pattern: "secrets/**", diff: "none" },
+  ],
+});
+```
+
+Ignore patterns apply only to untracked paths:
+
+- Ignored untracked files are skipped by `status()` and full `commit()`
+- Files already tracked by VCS remain tracked even if they later match an ignore rule
+- Full `checkout()` preserves ignored untracked files
+
+Attribute rules are applied in declaration order, with later matches winning. Supported properties:
+
+- `binary?: boolean`
+- `diff?: "text" | "binary" | "none"`
+
+### Committing Changes
+
+```ts
+// Commit all pending changes
+const rev = await vcs.commit("initial commit");
+
+// Selective commit with glob patterns (relative to root path)
+await vcs.commit("update src only", { paths: ["/src/**"] });
+```
+
+### Checking Status
+
+`status()` returns a `DiffEntry[]` describing uncommitted changes:
+
+```ts
+const changes = await vcs.status();
+for (const entry of changes) {
+  console.log(entry.type, entry.path, entry.diff, entry.binary);
+  // "add" | "modify" | "delete", "text" | "binary" | "none", boolean
+}
+```
+
+When `diff` is `"none"`, the entry still reports the path and change type, but omits `content` and `previousContent`.
+
+### Checkout
+
+```ts
+// Checkout a specific revision (errors if working tree is dirty)
+await vcs.checkout(1);
+
+// Force checkout, discarding uncommitted changes
+await vcs.checkout(1, { force: true });
+
+// Partial checkout — restore specific files without changing HEAD
+await vcs.checkout(1, { paths: ["/src/index.ts", "/**/*.txt"] });
+```
+
+### Branching
+
+```ts
+// Create a branch at HEAD
+await vcs.branch("feature");
+
+// Switch to a branch
+await vcs.checkout("feature");
+
+// List all branches
+const branches = await vcs.branches();
+// [{ name: "main", revision: 1, current: false },
+//  { name: "feature", revision: 1, current: true }]
+```
+
+### History and Diffs
+
+```ts
+// Revision history
+const entries = await vcs.log();
+const filtered = await vcs.log({ path: "src/index.ts", limit: 10 });
+
+// Diff between two revisions
+const diff = await vcs.diff(1, 2);
+for (const entry of diff) {
+  console.log(entry.type, entry.path, entry.diff);
+}
+
+// Current HEAD info
+const head = await vcs.head();
+// { branch: "main", revision: 2 }
+```
+
+### Separate VCS Storage
+
+By default, metadata lives in `{path}/.vcs`. You can store it on a different filesystem:
+
+```ts
+const vcs = new VersionControlSystem({
+  fs: workingTreeFs,
+  path: "/project",
+  vcsPath: {
+    fs: metadataFs,          // different VirtualFS instance
+    path: "/meta/.vcs",      // custom location
+  },
+});
+```
+
 ## Low-Level API
 
 For advanced use cases (custom tooling, AST inspection):
@@ -809,6 +934,11 @@ import type {
   Permission,
   PermissionRules,
   UnderlyingFS,
+  VCSConfig,
+  Revision,
+  DiffEntry,
+  LogEntry,
+  BranchInfo,
 } from "shell-dsl";
 ```
 

package/dist/cjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "shell-dsl",
-  "version": "0.0.32",
+  "version": "0.0.34",
   "type": "commonjs"
 }

package/dist/cjs/src/index.cjs

@@ -70,6 +70,7 @@ __export(exports_src, {
   createShellDSL: () => import_shell_dsl.createShellDSL,
   createPipe: () => import_io2.createPipe,
   WebFileSystem: () => import_fs2.WebFileSystem,
+  VersionControlSystem: () => import_vcs.VersionControlSystem,
   StdinImpl: () => import_io.StdinImpl,
   ShellPromise: () => import_shell_promise.ShellPromise,
   ShellError: () => import_errors.ShellError,
@@ -100,5 +101,6 @@ var import_fs2 = require("./fs/index.cjs");
 var import_io = require("./io/index.cjs");
 var import_io2 = require("./io/index.cjs");
 var import_utils = require("./utils/index.cjs");
+var import_vcs = require("./vcs/index.cjs");
 
-//# debugId=76B4D83DA9C2C40964756E2164756E21
+//# debugId=27F0973A44539CA064756E2164756E21

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  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  WebFileSystem,\n  createWebUnderlyingFS,\n  type PathOps,\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, globVirtualFS } from \"./utils/index.cjs\";\nexport type { GlobVirtualFS, GlobOptions } 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  WebFileSystem,\n  createWebUnderlyingFS,\n  type PathOps,\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, globVirtualFS } from \"./utils/index.cjs\";\nexport type { GlobVirtualFS, GlobOptions } from \"./utils/index.cjs\";\n\n// Version Control\nexport { VersionControlSystem } from \"./vcs/index.cjs\";\nexport type {\n  VCSConfig,\n  VCSAttributeRule,\n  VCSResolvedAttributes,\n  VCSDiffMode,\n  Revision,\n  DiffEntry,\n  TreeManifest,\n  TreeEntry,\n  FileEntry,\n  DirectoryEntry,\n  CommitOptions,\n  CheckoutOptions,\n  LogOptions,\n  LogEntry,\n  BranchInfo,\n} from \"./vcs/index.cjs\";\n"
   ],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACuD,IAAvD;AACuD,IAAvD;AAgB2B,IAA3B;AAGiD,IAAjD;AAG0C,IAA1C;AAI8B,IAA9B;AAuCO,IAjBP;AAoBwF,IAAxF;AAGgC,IAAhC;AAUO,IATP;AAYuC,IAAvC;AACwF,IAAxF;AAG8D,IAA9D;",
-  "debugId": "76B4D83DA9C2C40964756E2164756E21",
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACuD,IAAvD;AACuD,IAAvD;AAgB2B,IAA3B;AAGiD,IAAjD;AAG0C,IAA1C;AAI8B,IAA9B;AAuCO,IAjBP;AAoBwF,IAAxF;AAGgC,IAAhC;AAUO,IATP;AAYuC,IAAvC;AACwF,IAAxF;AAG8D,IAA9D;AAIqC,IAArC;",
+  "debugId": "27F0973A44539CA064756E2164756E21",
   "names": []
 }

package/dist/cjs/src/vcs/diff.cjs

@@ -0,0 +1,107 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/vcs/diff.ts
+var exports_diff = {};
+__export(exports_diff, {
+  diffWorkingTree: () => diffWorkingTree,
+  diffManifests: () => diffManifests
+});
+module.exports = __toCommonJS(exports_diff);
+var import_rules = require("./rules.cjs");
+var import_snapshot = require("./snapshot.cjs");
+function diffManifests(before, after, rules = new import_rules.VCSRules) {
+  const entries = [];
+  const allPaths = new Set([...Object.keys(before), ...Object.keys(after)]);
+  for (const path of allPaths) {
+    const prev = before[path];
+    const curr = after[path];
+    if (!prev && curr) {
+      entries.push(createDiffEntry("add", path, curr, undefined, rules));
+    } else if (prev && !curr) {
+      entries.push(createDiffEntry("delete", path, undefined, prev, rules));
+    } else if (prev && curr && !entriesEqual(prev, curr)) {
+      entries.push(createDiffEntry("modify", path, curr, prev, rules));
+    }
+  }
+  return entries.sort((a, b) => a.path.localeCompare(b.path));
+}
+async function diffWorkingTree(fs, rootPath, manifest, rules = new import_rules.VCSRules({ internalDirName: ".vcs" })) {
+  const workingManifest = await import_snapshot.buildTreeManifest(fs, rootPath, {
+    rules,
+    trackedPaths: Object.keys(manifest)
+  });
+  return diffManifests(manifest, workingManifest, rules);
+}
+function createDiffEntry(type, path, current, previous, rules) {
+  const attributes = rules.resolveAttributes(path);
+  const entryKind = getEntryKind(current ?? previous);
+  const previousEntryKind = previous ? getEntryKind(previous) : undefined;
+  const entry = {
+    type,
+    path,
+    binary: attributes.binary,
+    diff: attributes.diff,
+    entryKind,
+    previousEntryKind
+  };
+  if (attributes.diff !== "none") {
+    if (isFileEntry(current)) {
+      entry.content = current.content;
+    }
+    if (isFileEntry(previous)) {
+      entry.previousContent = previous.content;
+    }
+  }
+  return entry;
+}
+function entriesEqual(a, b) {
+  if (getEntryKind(a) !== getEntryKind(b))
+    return false;
+  if (!isFileEntry(a) || !isFileEntry(b))
+    return true;
+  return a.content === b.content;
+}
+function getEntryKind(entry) {
+  return entry?.kind === "directory" ? "directory" : "file";
+}
+function isFileEntry(entry) {
+  return !!entry && entry.kind !== "directory";
+}
+
+//# debugId=F0849DE3546011FF64756E2164756E21

package/dist/cjs/src/vcs/diff.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/vcs/diff.ts"],
+  "sourcesContent": [
+    "import type { VirtualFS } from \"../types.cjs\";\nimport type { TreeManifest, DiffEntry, TreeEntry } from \"./types.cjs\";\nimport { VCSRules } from \"./rules.cjs\";\nimport { buildTreeManifest } from \"./snapshot.cjs\";\n\n/**\n * Compute diff entries between two tree manifests.\n */\nexport function diffManifests(\n  before: TreeManifest,\n  after: TreeManifest,\n  rules: VCSRules = new VCSRules(),\n): DiffEntry[] {\n  const entries: DiffEntry[] = [];\n  const allPaths = new Set([...Object.keys(before), ...Object.keys(after)]);\n\n  for (const path of allPaths) {\n    const prev = before[path];\n    const curr = after[path];\n\n    if (!prev && curr) {\n      entries.push(createDiffEntry(\"add\", path, curr, undefined, rules));\n    } else if (prev && !curr) {\n      entries.push(createDiffEntry(\"delete\", path, undefined, prev, rules));\n    } else if (prev && curr && !entriesEqual(prev, curr)) {\n      entries.push(createDiffEntry(\"modify\", path, curr, prev, rules));\n    }\n  }\n\n  return entries.sort((a, b) => a.path.localeCompare(b.path));\n}\n\n/**\n * Compute diff between a tree manifest and the current working tree.\n */\nexport async function diffWorkingTree(\n  fs: VirtualFS,\n  rootPath: string,\n  manifest: TreeManifest,\n  rules: VCSRules = new VCSRules({ internalDirName: \".vcs\" }),\n): Promise<DiffEntry[]> {\n  const workingManifest = await buildTreeManifest(fs, rootPath, {\n    rules,\n    trackedPaths: Object.keys(manifest),\n  });\n  return diffManifests(manifest, workingManifest, rules);\n}\n\nfunction createDiffEntry(\n  type: DiffEntry[\"type\"],\n  path: string,\n  current: TreeEntry | undefined,\n  previous: TreeEntry | undefined,\n  rules: VCSRules,\n): DiffEntry {\n  const attributes = rules.resolveAttributes(path);\n  const entryKind = getEntryKind(current ?? previous);\n  const previousEntryKind = previous ? getEntryKind(previous) : undefined;\n  const entry: DiffEntry = {\n    type,\n    path,\n    binary: attributes.binary,\n    diff: attributes.diff,\n    entryKind,\n    previousEntryKind,\n  };\n\n  if (attributes.diff !== \"none\") {\n    if (isFileEntry(current)) {\n      entry.content = current.content;\n    }\n    if (isFileEntry(previous)) {\n      entry.previousContent = previous.content;\n    }\n  }\n\n  return entry;\n}\n\nfunction entriesEqual(a: TreeEntry, b: TreeEntry): boolean {\n  if (getEntryKind(a) !== getEntryKind(b)) return false;\n  if (!isFileEntry(a) || !isFileEntry(b)) return true;\n  return a.content === b.content;\n}\n\nfunction getEntryKind(entry: TreeEntry | undefined): \"file\" | \"directory\" {\n  return entry?.kind === \"directory\" ? \"directory\" : \"file\";\n}\n\nfunction isFileEntry(entry: TreeEntry | undefined): entry is Extract<TreeEntry, { kind?: \"file\" }> {\n  return !!entry && entry.kind !== \"directory\";\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEyB,IAAzB;AACkC,IAAlC;AAKO,SAAS,aAAa,CAC3B,QACA,OACA,QAAkB,IAAI,uBACT;AAAA,EACb,MAAM,UAAuB,CAAC;AAAA,EAC9B,MAAM,WAAW,IAAI,IAAI,CAAC,GAAG,OAAO,KAAK,MAAM,GAAG,GAAG,OAAO,KAAK,KAAK,CAAC,CAAC;AAAA,EAExE,WAAW,QAAQ,UAAU;AAAA,IAC3B,MAAM,OAAO,OAAO;AAAA,IACpB,MAAM,OAAO,MAAM;AAAA,IAEnB,IAAI,CAAC,QAAQ,MAAM;AAAA,MACjB,QAAQ,KAAK,gBAAgB,OAAO,MAAM,MAAM,WAAW,KAAK,CAAC;AAAA,IACnE,EAAO,SAAI,QAAQ,CAAC,MAAM;AAAA,MACxB,QAAQ,KAAK,gBAAgB,UAAU,MAAM,WAAW,MAAM,KAAK,CAAC;AAAA,IACtE,EAAO,SAAI,QAAQ,QAAQ,CAAC,aAAa,MAAM,IAAI,GAAG;AAAA,MACpD,QAAQ,KAAK,gBAAgB,UAAU,MAAM,MAAM,MAAM,KAAK,CAAC;AAAA,IACjE;AAAA,EACF;AAAA,EAEA,OAAO,QAAQ,KAAK,CAAC,GAAG,MAAM,EAAE,KAAK,cAAc,EAAE,IAAI,CAAC;AAAA;AAM5D,eAAsB,eAAe,CACnC,IACA,UACA,UACA,QAAkB,IAAI,sBAAS,EAAE,iBAAiB,OAAO,CAAC,GACpC;AAAA,EACtB,MAAM,kBAAkB,MAAM,kCAAkB,IAAI,UAAU;AAAA,IAC5D;AAAA,IACA,cAAc,OAAO,KAAK,QAAQ;AAAA,EACpC,CAAC;AAAA,EACD,OAAO,cAAc,UAAU,iBAAiB,KAAK;AAAA;AAGvD,SAAS,eAAe,CACtB,MACA,MACA,SACA,UACA,OACW;AAAA,EACX,MAAM,aAAa,MAAM,kBAAkB,IAAI;AAAA,EAC/C,MAAM,YAAY,aAAa,WAAW,QAAQ;AAAA,EAClD,MAAM,oBAAoB,WAAW,aAAa,QAAQ,IAAI;AAAA,EAC9D,MAAM,QAAmB;AAAA,IACvB;AAAA,IACA;AAAA,IACA,QAAQ,WAAW;AAAA,IACnB,MAAM,WAAW;AAAA,IACjB;AAAA,IACA;AAAA,EACF;AAAA,EAEA,IAAI,WAAW,SAAS,QAAQ;AAAA,IAC9B,IAAI,YAAY,OAAO,GAAG;AAAA,MACxB,MAAM,UAAU,QAAQ;AAAA,IAC1B;AAAA,IACA,IAAI,YAAY,QAAQ,GAAG;AAAA,MACzB,MAAM,kBAAkB,SAAS;AAAA,IACnC;AAAA,EACF;AAAA,EAEA,OAAO;AAAA;AAGT,SAAS,YAAY,CAAC,GAAc,GAAuB;AAAA,EACzD,IAAI,aAAa,CAAC,MAAM,aAAa,CAAC;AAAA,IAAG,OAAO;AAAA,EAChD,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,YAAY,CAAC;AAAA,IAAG,OAAO;AAAA,EAC/C,OAAO,EAAE,YAAY,EAAE;AAAA;AAGzB,SAAS,YAAY,CAAC,OAAoD;AAAA,EACxE,OAAO,OAAO,SAAS,cAAc,cAAc;AAAA;AAGrD,SAAS,WAAW,CAAC,OAA8E;AAAA,EACjG,OAAO,CAAC,CAAC,SAAS,MAAM,SAAS;AAAA;",
+  "debugId": "F0849DE3546011FF64756E2164756E21",
+  "names": []
+}

package/dist/cjs/src/vcs/index.cjs

@@ -0,0 +1,47 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/vcs/index.ts
+var exports_vcs = {};
+__export(exports_vcs, {
+  VersionControlSystem: () => import_vcs.VersionControlSystem
+});
+module.exports = __toCommonJS(exports_vcs);
+var import_vcs = require("./vcs.cjs");
+
+//# debugId=882B2013CEEDB5D864756E2164756E21

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

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/vcs/index.ts"],
+  "sourcesContent": [
+    "export { VersionControlSystem } from \"./vcs.cjs\";\nexport type {\n  VCSConfig,\n  VCSAttributeRule,\n  VCSResolvedAttributes,\n  VCSDiffMode,\n  Revision,\n  DiffEntry,\n  TreeManifest,\n  TreeEntry,\n  FileEntry,\n  DirectoryEntry,\n  CommitOptions,\n  CheckoutOptions,\n  LogOptions,\n  LogEntry,\n  BranchInfo,\n} from \"./types.cjs\";\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAqC,IAArC;",
+  "debugId": "882B2013CEEDB5D864756E2164756E21",
+  "names": []
+}

package/dist/cjs/src/vcs/match.cjs

@@ -0,0 +1,106 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/vcs/match.ts
+var exports_match = {};
+__export(exports_match, {
+  matchGlobPath: () => matchGlobPath
+});
+module.exports = __toCommonJS(exports_match);
+function matchGlobPath(pattern, filePath) {
+  const p = pattern.startsWith("/") ? pattern.slice(1) : pattern;
+  const f = filePath.startsWith("/") ? filePath.slice(1) : filePath;
+  const patternParts = p.split("/");
+  const pathParts = f.split("/");
+  return matchParts(patternParts, pathParts, 0, 0);
+}
+function matchParts(pattern, path, pi, fi) {
+  while (pi < pattern.length && fi < path.length) {
+    const seg = pattern[pi];
+    if (seg === "**") {
+      for (let i = fi;i <= path.length; i++) {
+        if (matchParts(pattern, path, pi + 1, i))
+          return true;
+      }
+      return false;
+    }
+    if (!matchSegment(seg, path[fi]))
+      return false;
+    pi++;
+    fi++;
+  }
+  while (pi < pattern.length && pattern[pi] === "**")
+    pi++;
+  return pi === pattern.length && fi === path.length;
+}
+function matchSegment(pattern, segment) {
+  let regex = "^";
+  for (let i = 0;i < pattern.length; i++) {
+    const c = pattern[i];
+    switch (c) {
+      case "*":
+        regex += "[^/]*";
+        break;
+      case "?":
+        regex += "[^/]";
+        break;
+      case ".":
+      case "^":
+      case "$":
+      case "+":
+      case "{":
+      case "}":
+      case "(":
+      case ")":
+      case "|":
+      case "\\":
+        regex += "\\" + c;
+        break;
+      default:
+        regex += c;
+    }
+  }
+  regex += "$";
+  try {
+    return new RegExp(regex).test(segment);
+  } catch {
+    return false;
+  }
+}
+
+//# debugId=9C038AE3F1837D4764756E2164756E21

package/dist/cjs/src/vcs/match.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/vcs/match.ts"],
+  "sourcesContent": [
+    "/**\n * Match a file path against a glob pattern.\n * Supports `**` for recursive directory matching, `*` for single segment wildcard.\n */\nexport function matchGlobPath(pattern: string, filePath: string): boolean {\n  // Normalize: strip leading slashes\n  const p = pattern.startsWith(\"/\") ? pattern.slice(1) : pattern;\n  const f = filePath.startsWith(\"/\") ? filePath.slice(1) : filePath;\n\n  const patternParts = p.split(\"/\");\n  const pathParts = f.split(\"/\");\n\n  return matchParts(patternParts, pathParts, 0, 0);\n}\n\nfunction matchParts(\n  pattern: string[],\n  path: string[],\n  pi: number,\n  fi: number,\n): boolean {\n  while (pi < pattern.length && fi < path.length) {\n    const seg = pattern[pi]!;\n\n    if (seg === \"**\") {\n      // ** matches zero or more path segments\n      // Try matching rest of pattern against current position and all subsequent positions\n      for (let i = fi; i <= path.length; i++) {\n        if (matchParts(pattern, path, pi + 1, i)) return true;\n      }\n      return false;\n    }\n\n    if (!matchSegment(seg, path[fi]!)) return false;\n    pi++;\n    fi++;\n  }\n\n  // Skip trailing ** patterns\n  while (pi < pattern.length && pattern[pi] === \"**\") pi++;\n\n  return pi === pattern.length && fi === path.length;\n}\n\nfunction matchSegment(pattern: string, segment: string): boolean {\n  // Convert glob segment to regex\n  let regex = \"^\";\n  for (let i = 0; i < pattern.length; i++) {\n    const c = pattern[i]!;\n    switch (c) {\n      case \"*\":\n        regex += \"[^/]*\";\n        break;\n      case \"?\":\n        regex += \"[^/]\";\n        break;\n      case \".\":\n      case \"^\":\n      case \"$\":\n      case \"+\":\n      case \"{\":\n      case \"}\":\n      case \"(\":\n      case \")\":\n      case \"|\":\n      case \"\\\\\":\n        regex += \"\\\\\" + c;\n        break;\n      default:\n        regex += c;\n    }\n  }\n  regex += \"$\";\n\n  try {\n    return new RegExp(regex).test(segment);\n  } catch {\n    return false;\n  }\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIO,SAAS,aAAa,CAAC,SAAiB,UAA2B;AAAA,EAExE,MAAM,IAAI,QAAQ,WAAW,GAAG,IAAI,QAAQ,MAAM,CAAC,IAAI;AAAA,EACvD,MAAM,IAAI,SAAS,WAAW,GAAG,IAAI,SAAS,MAAM,CAAC,IAAI;AAAA,EAEzD,MAAM,eAAe,EAAE,MAAM,GAAG;AAAA,EAChC,MAAM,YAAY,EAAE,MAAM,GAAG;AAAA,EAE7B,OAAO,WAAW,cAAc,WAAW,GAAG,CAAC;AAAA;AAGjD,SAAS,UAAU,CACjB,SACA,MACA,IACA,IACS;AAAA,EACT,OAAO,KAAK,QAAQ,UAAU,KAAK,KAAK,QAAQ;AAAA,IAC9C,MAAM,MAAM,QAAQ;AAAA,IAEpB,IAAI,QAAQ,MAAM;AAAA,MAGhB,SAAS,IAAI,GAAI,KAAK,KAAK,QAAQ,KAAK;AAAA,QACtC,IAAI,WAAW,SAAS,MAAM,KAAK,GAAG,CAAC;AAAA,UAAG,OAAO;AAAA,MACnD;AAAA,MACA,OAAO;AAAA,IACT;AAAA,IAEA,IAAI,CAAC,aAAa,KAAK,KAAK,GAAI;AAAA,MAAG,OAAO;AAAA,IAC1C;AAAA,IACA;AAAA,EACF;AAAA,EAGA,OAAO,KAAK,QAAQ,UAAU,QAAQ,QAAQ;AAAA,IAAM;AAAA,EAEpD,OAAO,OAAO,QAAQ,UAAU,OAAO,KAAK;AAAA;AAG9C,SAAS,YAAY,CAAC,SAAiB,SAA0B;AAAA,EAE/D,IAAI,QAAQ;AAAA,EACZ,SAAS,IAAI,EAAG,IAAI,QAAQ,QAAQ,KAAK;AAAA,IACvC,MAAM,IAAI,QAAQ;AAAA,IAClB,QAAQ;AAAA,WACD;AAAA,QACH,SAAS;AAAA,QACT;AAAA,WACG;AAAA,QACH,SAAS;AAAA,QACT;AAAA,WACG;AAAA,WACA;AAAA,WACA;AAAA,WACA;AAAA,WACA;AAAA,WACA;AAAA,WACA;AAAA,WACA;AAAA,WACA;AAAA,WACA;AAAA,QACH,SAAS,OAAO;AAAA,QAChB;AAAA;AAAA,QAEA,SAAS;AAAA;AAAA,EAEf;AAAA,EACA,SAAS;AAAA,EAET,IAAI;AAAA,IACF,OAAO,IAAI,OAAO,KAAK,EAAE,KAAK,OAAO;AAAA,IACrC,MAAM;AAAA,IACN,OAAO;AAAA;AAAA;",
+  "debugId": "9C038AE3F1837D4764756E2164756E21",
+  "names": []
+}