shell-dsl 0.0.32 → 0.0.33

package/dist/cjs/src/vcs/storage.cjs

@@ -0,0 +1,120 @@
+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/storage.ts
+var exports_storage = {};
+__export(exports_storage, {
+  VCSStorage: () => VCSStorage
+});
+module.exports = __toCommonJS(exports_storage);
+
+class VCSStorage {
+  fs;
+  basePath;
+  constructor(fs, basePath) {
+    this.fs = fs;
+    this.basePath = basePath;
+  }
+  path(...segments) {
+    return this.fs.resolve(this.basePath, ...segments);
+  }
+  async isInitialized() {
+    return this.fs.exists(this.path("HEAD"));
+  }
+  async initialize(defaultBranch = "main") {
+    await this.fs.mkdir(this.basePath, { recursive: true });
+    await this.fs.mkdir(this.path("refs", "heads"), { recursive: true });
+    await this.fs.mkdir(this.path("revisions"), { recursive: true });
+    await this.writeHead({ ref: `refs/heads/${defaultBranch}` });
+    await this.writeJSON(["counter.json"], { next: 1 });
+    await this.writeJSON(["config.json"], { defaultBranch });
+  }
+  async readHead() {
+    return this.readJSON("HEAD");
+  }
+  async writeHead(head) {
+    await this.writeJSON(["HEAD"], head);
+  }
+  async readBranch(name) {
+    const branchPath = this.path("refs", "heads", name);
+    if (!await this.fs.exists(branchPath))
+      return null;
+    return this.readJSON("refs", "heads", name);
+  }
+  async writeBranch(name, ref) {
+    await this.writeJSON(["refs", "heads", name], ref);
+  }
+  async deleteBranch(name) {
+    const branchPath = this.path("refs", "heads", name);
+    await this.fs.rm(branchPath);
+  }
+  async listBranches() {
+    const headsPath = this.path("refs", "heads");
+    try {
+      return await this.fs.readdir(headsPath);
+    } catch {
+      return [];
+    }
+  }
+  async readRevision(id) {
+    return this.readJSON("revisions", `${id}.json`);
+  }
+  async writeRevision(rev) {
+    await this.writeJSON(["revisions", `${rev.id}.json`], rev);
+  }
+  async nextRevisionId() {
+    const counter = await this.readJSON("counter.json");
+    const id = counter.next;
+    await this.writeJSON(["counter.json"], { next: id + 1 });
+    return id;
+  }
+  async readConfig() {
+    return this.readJSON("config.json");
+  }
+  async readJSON(...segments) {
+    const filePath = this.path(...segments);
+    const content = await this.fs.readFile(filePath, "utf8");
+    return JSON.parse(content);
+  }
+  async writeJSON(segments, data) {
+    const filePath = this.path(...segments);
+    await this.fs.writeFile(filePath, JSON.stringify(data, null, 2));
+  }
+}
+
+//# debugId=E27DBCC23E16A74564756E2164756E21

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

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/vcs/storage.ts"],
+  "sourcesContent": [
+    "import type { VirtualFS } from \"../types.cjs\";\nimport type {\n  HeadRef,\n  BranchRef,\n  RevisionCounter,\n  VCSConfigFile,\n  Revision,\n} from \"./types.cjs\";\n\nexport class VCSStorage {\n  constructor(\n    private readonly fs: VirtualFS,\n    private readonly basePath: string,\n  ) {}\n\n  private path(...segments: string[]): string {\n    return this.fs.resolve(this.basePath, ...segments);\n  }\n\n  // --- Init ---\n\n  async isInitialized(): Promise<boolean> {\n    return this.fs.exists(this.path(\"HEAD\"));\n  }\n\n  async initialize(defaultBranch: string = \"main\"): Promise<void> {\n    await this.fs.mkdir(this.basePath, { recursive: true });\n    await this.fs.mkdir(this.path(\"refs\", \"heads\"), { recursive: true });\n    await this.fs.mkdir(this.path(\"revisions\"), { recursive: true });\n\n    await this.writeHead({ ref: `refs/heads/${defaultBranch}` });\n    await this.writeJSON([\"counter.json\"], { next: 1 } satisfies RevisionCounter);\n    await this.writeJSON([\"config.json\"], { defaultBranch } satisfies VCSConfigFile);\n  }\n\n  // --- HEAD ---\n\n  async readHead(): Promise<HeadRef> {\n    return this.readJSON<HeadRef>(\"HEAD\");\n  }\n\n  async writeHead(head: HeadRef): Promise<void> {\n    await this.writeJSON([\"HEAD\"], head);\n  }\n\n  // --- Branches ---\n\n  async readBranch(name: string): Promise<BranchRef | null> {\n    const branchPath = this.path(\"refs\", \"heads\", name);\n    if (!(await this.fs.exists(branchPath))) return null;\n    return this.readJSON<BranchRef>(\"refs\", \"heads\", name);\n  }\n\n  async writeBranch(name: string, ref: BranchRef): Promise<void> {\n    await this.writeJSON([\"refs\", \"heads\", name], ref);\n  }\n\n  async deleteBranch(name: string): Promise<void> {\n    const branchPath = this.path(\"refs\", \"heads\", name);\n    await this.fs.rm(branchPath);\n  }\n\n  async listBranches(): Promise<string[]> {\n    const headsPath = this.path(\"refs\", \"heads\");\n    try {\n      return await this.fs.readdir(headsPath);\n    } catch {\n      return [];\n    }\n  }\n\n  // --- Revisions ---\n\n  async readRevision(id: number): Promise<Revision> {\n    return this.readJSON<Revision>(\"revisions\", `${id}.json`);\n  }\n\n  async writeRevision(rev: Revision): Promise<void> {\n    await this.writeJSON([\"revisions\", `${rev.id}.json`], rev);\n  }\n\n  // --- Counter ---\n\n  async nextRevisionId(): Promise<number> {\n    const counter = await this.readJSON<RevisionCounter>(\"counter.json\");\n    const id = counter.next;\n    await this.writeJSON([\"counter.json\"], { next: id + 1 } satisfies RevisionCounter);\n    return id;\n  }\n\n  // --- Config ---\n\n  async readConfig(): Promise<VCSConfigFile> {\n    return this.readJSON<VCSConfigFile>(\"config.json\");\n  }\n\n  // --- Helpers ---\n\n  private async readJSON<T>(...segments: string[]): Promise<T> {\n    const filePath = this.path(...segments);\n    const content = await this.fs.readFile(filePath, \"utf8\");\n    return JSON.parse(content) as T;\n  }\n\n  private async writeJSON(segments: string[], data: unknown): Promise<void> {\n    const filePath = this.path(...segments);\n    await this.fs.writeFile(filePath, JSON.stringify(data, null, 2));\n  }\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASO,MAAM,WAAW;AAAA,EAEH;AAAA,EACA;AAAA,EAFnB,WAAW,CACQ,IACA,UACjB;AAAA,IAFiB;AAAA,IACA;AAAA;AAAA,EAGX,IAAI,IAAI,UAA4B;AAAA,IAC1C,OAAO,KAAK,GAAG,QAAQ,KAAK,UAAU,GAAG,QAAQ;AAAA;AAAA,OAK7C,cAAa,GAAqB;AAAA,IACtC,OAAO,KAAK,GAAG,OAAO,KAAK,KAAK,MAAM,CAAC;AAAA;AAAA,OAGnC,WAAU,CAAC,gBAAwB,QAAuB;AAAA,IAC9D,MAAM,KAAK,GAAG,MAAM,KAAK,UAAU,EAAE,WAAW,KAAK,CAAC;AAAA,IACtD,MAAM,KAAK,GAAG,MAAM,KAAK,KAAK,QAAQ,OAAO,GAAG,EAAE,WAAW,KAAK,CAAC;AAAA,IACnE,MAAM,KAAK,GAAG,MAAM,KAAK,KAAK,WAAW,GAAG,EAAE,WAAW,KAAK,CAAC;AAAA,IAE/D,MAAM,KAAK,UAAU,EAAE,KAAK,cAAc,gBAAgB,CAAC;AAAA,IAC3D,MAAM,KAAK,UAAU,CAAC,cAAc,GAAG,EAAE,MAAM,EAAE,CAA2B;AAAA,IAC5E,MAAM,KAAK,UAAU,CAAC,aAAa,GAAG,EAAE,cAAc,CAAyB;AAAA;AAAA,OAK3E,SAAQ,GAAqB;AAAA,IACjC,OAAO,KAAK,SAAkB,MAAM;AAAA;AAAA,OAGhC,UAAS,CAAC,MAA8B;AAAA,IAC5C,MAAM,KAAK,UAAU,CAAC,MAAM,GAAG,IAAI;AAAA;AAAA,OAK/B,WAAU,CAAC,MAAyC;AAAA,IACxD,MAAM,aAAa,KAAK,KAAK,QAAQ,SAAS,IAAI;AAAA,IAClD,IAAI,CAAE,MAAM,KAAK,GAAG,OAAO,UAAU;AAAA,MAAI,OAAO;AAAA,IAChD,OAAO,KAAK,SAAoB,QAAQ,SAAS,IAAI;AAAA;AAAA,OAGjD,YAAW,CAAC,MAAc,KAA+B;AAAA,IAC7D,MAAM,KAAK,UAAU,CAAC,QAAQ,SAAS,IAAI,GAAG,GAAG;AAAA;AAAA,OAG7C,aAAY,CAAC,MAA6B;AAAA,IAC9C,MAAM,aAAa,KAAK,KAAK,QAAQ,SAAS,IAAI;AAAA,IAClD,MAAM,KAAK,GAAG,GAAG,UAAU;AAAA;AAAA,OAGvB,aAAY,GAAsB;AAAA,IACtC,MAAM,YAAY,KAAK,KAAK,QAAQ,OAAO;AAAA,IAC3C,IAAI;AAAA,MACF,OAAO,MAAM,KAAK,GAAG,QAAQ,SAAS;AAAA,MACtC,MAAM;AAAA,MACN,OAAO,CAAC;AAAA;AAAA;AAAA,OAMN,aAAY,CAAC,IAA+B;AAAA,IAChD,OAAO,KAAK,SAAmB,aAAa,GAAG,SAAS;AAAA;AAAA,OAGpD,cAAa,CAAC,KAA8B;AAAA,IAChD,MAAM,KAAK,UAAU,CAAC,aAAa,GAAG,IAAI,SAAS,GAAG,GAAG;AAAA;AAAA,OAKrD,eAAc,GAAoB;AAAA,IACtC,MAAM,UAAU,MAAM,KAAK,SAA0B,cAAc;AAAA,IACnE,MAAM,KAAK,QAAQ;AAAA,IACnB,MAAM,KAAK,UAAU,CAAC,cAAc,GAAG,EAAE,MAAM,KAAK,EAAE,CAA2B;AAAA,IACjF,OAAO;AAAA;AAAA,OAKH,WAAU,GAA2B;AAAA,IACzC,OAAO,KAAK,SAAwB,aAAa;AAAA;AAAA,OAKrC,SAAW,IAAI,UAAgC;AAAA,IAC3D,MAAM,WAAW,KAAK,KAAK,GAAG,QAAQ;AAAA,IACtC,MAAM,UAAU,MAAM,KAAK,GAAG,SAAS,UAAU,MAAM;AAAA,IACvD,OAAO,KAAK,MAAM,OAAO;AAAA;AAAA,OAGb,UAAS,CAAC,UAAoB,MAA8B;AAAA,IACxE,MAAM,WAAW,KAAK,KAAK,GAAG,QAAQ;AAAA,IACtC,MAAM,KAAK,GAAG,UAAU,UAAU,KAAK,UAAU,MAAM,MAAM,CAAC,CAAC;AAAA;AAEnE;",
+  "debugId": "E27DBCC23E16A74564756E2164756E21",
+  "names": []
+}

package/dist/cjs/src/vcs/types.cjs

@@ -0,0 +1,30 @@
+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;
+
+// src/vcs/types.ts
+var exports_types = {};
+module.exports = __toCommonJS(exports_types);
+
+//# debugId=0D69226887DD202F64756E2164756E21

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

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "0D69226887DD202F64756E2164756E21",
+  "names": []
+}

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

@@ -0,0 +1,305 @@
+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/vcs.ts
+var exports_vcs = {};
+__export(exports_vcs, {
+  VersionControlSystem: () => VersionControlSystem
+});
+module.exports = __toCommonJS(exports_vcs);
+var import_storage = require("./storage.cjs");
+var import_diff = require("./diff.cjs");
+var import_snapshot = require("./snapshot.cjs");
+var import_match = require("./match.cjs");
+
+class VersionControlSystem {
+  workFs;
+  workPath;
+  storage;
+  vcsDirName;
+  constructor(config) {
+    this.workFs = config.fs;
+    this.workPath = config.fs.resolve(config.path);
+    const metaFs = config.vcsPath?.fs ?? config.fs;
+    const metaPath = config.vcsPath?.path ?? metaFs.resolve(config.path, ".vcs");
+    this.storage = new import_storage.VCSStorage(metaFs, metaPath);
+    const resolvedMeta = metaFs.resolve(metaPath);
+    const resolvedWork = this.workPath;
+    if (resolvedMeta.startsWith(resolvedWork + "/") || resolvedMeta.startsWith(resolvedWork + "\\")) {
+      const rel = resolvedMeta.slice(resolvedWork.length + 1);
+      this.vcsDirName = rel.split("/")[0] ?? ".vcs";
+    } else {
+      this.vcsDirName = "";
+    }
+  }
+  get excludeDirs() {
+    return this.vcsDirName ? [this.vcsDirName] : [];
+  }
+  async init() {
+    if (await this.storage.isInitialized())
+      return;
+    await this.storage.initialize();
+  }
+  async ensureInit() {
+    if (!await this.storage.isInitialized()) {
+      await this.init();
+    }
+  }
+  async resolveHead() {
+    const head = await this.storage.readHead();
+    if (head.revision !== undefined) {
+      return { branch: null, revision: head.revision };
+    }
+    if (head.ref) {
+      const branchName = head.ref.replace("refs/heads/", "");
+      const branchRef = await this.storage.readBranch(branchName);
+      return { branch: branchName, revision: branchRef?.revision ?? null };
+    }
+    return { branch: null, revision: null };
+  }
+  async headManifest() {
+    const { revision } = await this.resolveHead();
+    if (revision === null)
+      return {};
+    const rev = await this.storage.readRevision(revision);
+    return rev.tree;
+  }
+  async commit(message, opts) {
+    await this.ensureInit();
+    const { branch, revision: parentId } = await this.resolveHead();
+    const parentManifest = parentId !== null ? (await this.storage.readRevision(parentId)).tree : {};
+    let newTree;
+    let changes;
+    if (opts?.paths && opts.paths.length > 0) {
+      const fullManifest = await import_snapshot.buildTreeManifest(this.workFs, this.workPath, this.excludeDirs);
+      const matchedPaths = filterPathsByGlobs(Object.keys(fullManifest), opts.paths);
+      newTree = { ...parentManifest };
+      const parentMatchedPaths = filterPathsByGlobs(Object.keys(parentManifest), opts.paths);
+      for (const p of parentMatchedPaths) {
+        if (!fullManifest[p]) {
+          delete newTree[p];
+        }
+      }
+      for (const p of matchedPaths) {
+        newTree[p] = fullManifest[p];
+      }
+      const relevantBefore = {};
+      const relevantAfter = {};
+      const allRelevant = new Set([...matchedPaths, ...parentMatchedPaths]);
+      for (const p of allRelevant) {
+        if (parentManifest[p])
+          relevantBefore[p] = parentManifest[p];
+        if (newTree[p])
+          relevantAfter[p] = newTree[p];
+      }
+      changes = import_diff.diffManifests(relevantBefore, relevantAfter);
+    } else {
+      newTree = await import_snapshot.buildTreeManifest(this.workFs, this.workPath, this.excludeDirs);
+      changes = import_diff.diffManifests(parentManifest, newTree);
+    }
+    if (changes.length === 0) {
+      throw new Error("nothing to commit");
+    }
+    const id = await this.storage.nextRevisionId();
+    const rev = {
+      id,
+      parent: parentId,
+      branch: branch ?? "detached",
+      message,
+      timestamp: new Date().toISOString(),
+      changes,
+      tree: newTree
+    };
+    await this.storage.writeRevision(rev);
+    if (branch) {
+      await this.storage.writeBranch(branch, { revision: id });
+    } else {
+      await this.storage.writeHead({ revision: id });
+    }
+    return rev;
+  }
+  async checkout(target, opts) {
+    await this.ensureInit();
+    const isPartial = opts?.paths && opts.paths.length > 0;
+    let targetRevision;
+    let targetBranch = null;
+    if (typeof target === "string") {
+      const branchRef = await this.storage.readBranch(target);
+      if (branchRef) {
+        targetBranch = target;
+        targetRevision = branchRef.revision;
+      } else {
+        throw new Error(`unknown branch or revision: "${target}"`);
+      }
+    } else {
+      targetRevision = target;
+    }
+    let rev;
+    try {
+      rev = await this.storage.readRevision(targetRevision);
+    } catch {
+      throw new Error(`revision ${targetRevision} not found`);
+    }
+    if (isPartial) {
+      const matchedPaths = filterPathsByGlobs(Object.keys(rev.tree), opts.paths);
+      const filteredManifest = {};
+      for (const p of matchedPaths) {
+        filteredManifest[p] = rev.tree[p];
+      }
+      await import_snapshot.restoreTree(this.workFs, this.workPath, filteredManifest, {
+        fullRestore: false,
+        paths: matchedPaths
+      });
+    } else {
+      if (!opts?.force) {
+        const changes = await this.status();
+        if (changes.length > 0) {
+          throw new Error("working tree has uncommitted changes (use force to discard)");
+        }
+      }
+      await import_snapshot.restoreTree(this.workFs, this.workPath, rev.tree, { fullRestore: true });
+      if (targetBranch) {
+        await this.storage.writeHead({ ref: `refs/heads/${targetBranch}` });
+      } else {
+        await this.storage.writeHead({ revision: targetRevision });
+      }
+    }
+  }
+  async branch(name) {
+    await this.ensureInit();
+    const existing = await this.storage.readBranch(name);
+    if (existing) {
+      throw new Error(`branch "${name}" already exists`);
+    }
+    const { revision } = await this.resolveHead();
+    if (revision === null) {
+      throw new Error("cannot create branch: no commits yet");
+    }
+    await this.storage.writeBranch(name, { revision });
+  }
+  async branches() {
+    await this.ensureInit();
+    const names = await this.storage.listBranches();
+    const head = await this.resolveHead();
+    const result = [];
+    for (const name of names) {
+      const ref = await this.storage.readBranch(name);
+      if (ref) {
+        result.push({
+          name,
+          revision: ref.revision,
+          current: head.branch === name
+        });
+      }
+    }
+    return result.sort((a, b) => a.name.localeCompare(b.name));
+  }
+  async log(opts) {
+    await this.ensureInit();
+    let startRevision;
+    if (opts?.branch) {
+      const branchRef = await this.storage.readBranch(opts.branch);
+      if (!branchRef)
+        throw new Error(`branch "${opts.branch}" not found`);
+      startRevision = branchRef.revision;
+    } else {
+      const { revision } = await this.resolveHead();
+      startRevision = revision;
+    }
+    if (startRevision === null)
+      return [];
+    const entries = [];
+    let currentId = startRevision;
+    while (currentId !== null) {
+      if (opts?.limit && entries.length >= opts.limit)
+        break;
+      let rev;
+      try {
+        rev = await this.storage.readRevision(currentId);
+      } catch {
+        break;
+      }
+      const changedPaths = rev.changes.map((c) => c.path);
+      if (opts?.path) {
+        const matchesPath = changedPaths.some((p) => import_match.matchGlobPath(opts.path, p));
+        if (matchesPath) {
+          entries.push({
+            id: rev.id,
+            parent: rev.parent,
+            branch: rev.branch,
+            message: rev.message,
+            timestamp: rev.timestamp,
+            paths: changedPaths
+          });
+        }
+      } else {
+        entries.push({
+          id: rev.id,
+          parent: rev.parent,
+          branch: rev.branch,
+          message: rev.message,
+          timestamp: rev.timestamp,
+          paths: changedPaths
+        });
+      }
+      currentId = rev.parent;
+    }
+    return entries;
+  }
+  async status() {
+    await this.ensureInit();
+    const manifest = await this.headManifest();
+    return import_diff.diffWorkingTree(this.workFs, this.workPath, manifest, this.excludeDirs);
+  }
+  async diff(revA, revB) {
+    await this.ensureInit();
+    const a = await this.storage.readRevision(revA);
+    const b = await this.storage.readRevision(revB);
+    return import_diff.diffManifests(a.tree, b.tree);
+  }
+  async head() {
+    await this.ensureInit();
+    return this.resolveHead();
+  }
+}
+function filterPathsByGlobs(paths, patterns) {
+  const normalizedPatterns = patterns.map((p) => p.startsWith("/") ? p.slice(1) : p);
+  return paths.filter((filePath) => normalizedPatterns.some((pattern) => import_match.matchGlobPath(pattern, filePath)));
+}
+
+//# debugId=C0D26E6B9D66359264756E2164756E21

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

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/vcs/vcs.ts"],
+  "sourcesContent": [
+    "import type { VirtualFS } from \"../types.cjs\";\nimport type {\n  VCSConfig,\n  Revision,\n  DiffEntry,\n  TreeManifest,\n  CommitOptions,\n  CheckoutOptions,\n  LogOptions,\n  LogEntry,\n  BranchInfo,\n} from \"./types.cjs\";\nimport { VCSStorage } from \"./storage.cjs\";\nimport { diffManifests, diffWorkingTree } from \"./diff.cjs\";\nimport { buildTreeManifest, restoreTree } from \"./snapshot.cjs\";\nimport { matchGlobPath } from \"./match.cjs\";\n\nexport class VersionControlSystem {\n  private readonly workFs: VirtualFS;\n  private readonly workPath: string;\n  private readonly storage: VCSStorage;\n  private readonly vcsDirName: string;\n\n  constructor(config: VCSConfig) {\n    this.workFs = config.fs;\n    this.workPath = config.fs.resolve(config.path);\n\n    const metaFs = config.vcsPath?.fs ?? config.fs;\n    const metaPath = config.vcsPath?.path ?? metaFs.resolve(config.path, \".vcs\");\n    this.storage = new VCSStorage(metaFs, metaPath);\n\n    // Determine the vcs directory name relative to workPath for exclusion\n    const resolvedMeta = metaFs.resolve(metaPath);\n    const resolvedWork = this.workPath;\n    if (resolvedMeta.startsWith(resolvedWork + \"/\") || resolvedMeta.startsWith(resolvedWork + \"\\\\\")) {\n      const rel = resolvedMeta.slice(resolvedWork.length + 1);\n      this.vcsDirName = rel.split(\"/\")[0] ?? \".vcs\";\n    } else {\n      // VCS dir is outside the work tree, no exclusion needed\n      this.vcsDirName = \"\";\n    }\n  }\n\n  private get excludeDirs(): string[] {\n    return this.vcsDirName ? [this.vcsDirName] : [];\n  }\n\n  /** Initialize the .vcs directory. Called automatically on first operation if needed. */\n  async init(): Promise<void> {\n    if (await this.storage.isInitialized()) return;\n    await this.storage.initialize();\n  }\n\n  private async ensureInit(): Promise<void> {\n    if (!(await this.storage.isInitialized())) {\n      await this.init();\n    }\n  }\n\n  /** Get the current HEAD revision number, or null if no commits yet. */\n  private async resolveHead(): Promise<{ branch: string | null; revision: number | null }> {\n    const head = await this.storage.readHead();\n    if (head.revision !== undefined) {\n      return { branch: null, revision: head.revision };\n    }\n    if (head.ref) {\n      const branchName = head.ref.replace(\"refs/heads/\", \"\");\n      const branchRef = await this.storage.readBranch(branchName);\n      return { branch: branchName, revision: branchRef?.revision ?? null };\n    }\n    return { branch: null, revision: null };\n  }\n\n  /** Get current HEAD manifest, or empty if no commits. */\n  private async headManifest(): Promise<TreeManifest> {\n    const { revision } = await this.resolveHead();\n    if (revision === null) return {};\n    const rev = await this.storage.readRevision(revision);\n    return rev.tree;\n  }\n\n  /** Commit all pending changes, or selective changes if paths are provided. */\n  async commit(message: string, opts?: CommitOptions): Promise<Revision> {\n    await this.ensureInit();\n\n    const { branch, revision: parentId } = await this.resolveHead();\n    const parentManifest = parentId !== null\n      ? (await this.storage.readRevision(parentId)).tree\n      : {};\n\n    let newTree: TreeManifest;\n    let changes: DiffEntry[];\n\n    if (opts?.paths && opts.paths.length > 0) {\n      // Selective commit: only include matching files\n      const fullManifest = await buildTreeManifest(this.workFs, this.workPath, this.excludeDirs);\n      const matchedPaths = filterPathsByGlobs(Object.keys(fullManifest), opts.paths);\n\n      // Start with parent manifest, overlay matched files from working tree\n      newTree = { ...parentManifest };\n\n      // Also check for deletions: files in parent that match patterns but are gone from working tree\n      const parentMatchedPaths = filterPathsByGlobs(Object.keys(parentManifest), opts.paths);\n      for (const p of parentMatchedPaths) {\n        if (!fullManifest[p]) {\n          delete newTree[p]; // file was deleted\n        }\n      }\n\n      for (const p of matchedPaths) {\n        newTree[p] = fullManifest[p]!;\n      }\n\n      // Compute changes only for matched paths\n      const relevantBefore: TreeManifest = {};\n      const relevantAfter: TreeManifest = {};\n      const allRelevant = new Set([...matchedPaths, ...parentMatchedPaths]);\n      for (const p of allRelevant) {\n        if (parentManifest[p]) relevantBefore[p] = parentManifest[p]!;\n        if (newTree[p]) relevantAfter[p] = newTree[p]!;\n      }\n      changes = diffManifests(relevantBefore, relevantAfter);\n    } else {\n      // Full commit\n      newTree = await buildTreeManifest(this.workFs, this.workPath, this.excludeDirs);\n      changes = diffManifests(parentManifest, newTree);\n    }\n\n    if (changes.length === 0) {\n      throw new Error(\"nothing to commit\");\n    }\n\n    const id = await this.storage.nextRevisionId();\n    const rev: Revision = {\n      id,\n      parent: parentId,\n      branch: branch ?? \"detached\",\n      message,\n      timestamp: new Date().toISOString(),\n      changes,\n      tree: newTree,\n    };\n\n    await this.storage.writeRevision(rev);\n\n    // Update branch ref or HEAD\n    if (branch) {\n      await this.storage.writeBranch(branch, { revision: id });\n    } else {\n      await this.storage.writeHead({ revision: id });\n    }\n\n    return rev;\n  }\n\n  /** Checkout a revision number or branch name. */\n  async checkout(target: string | number, opts?: CheckoutOptions): Promise<void> {\n    await this.ensureInit();\n\n    const isPartial = opts?.paths && opts.paths.length > 0;\n\n    let targetRevision: number;\n    let targetBranch: string | null = null;\n\n    if (typeof target === \"string\") {\n      // Check if it's a branch name\n      const branchRef = await this.storage.readBranch(target);\n      if (branchRef) {\n        targetBranch = target;\n        targetRevision = branchRef.revision;\n      } else {\n        throw new Error(`unknown branch or revision: \"${target}\"`);\n      }\n    } else {\n      targetRevision = target;\n    }\n\n    // Verify revision exists\n    let rev: Revision;\n    try {\n      rev = await this.storage.readRevision(targetRevision);\n    } catch {\n      throw new Error(`revision ${targetRevision} not found`);\n    }\n\n    if (isPartial) {\n      // Partial checkout: restore specific files, don't update HEAD\n      const matchedPaths = filterPathsByGlobs(Object.keys(rev.tree), opts!.paths!);\n      const filteredManifest: TreeManifest = {};\n      for (const p of matchedPaths) {\n        filteredManifest[p] = rev.tree[p]!;\n      }\n      await restoreTree(this.workFs, this.workPath, filteredManifest, {\n        fullRestore: false,\n        paths: matchedPaths,\n      });\n    } else {\n      // Full checkout\n      if (!opts?.force) {\n        const changes = await this.status();\n        if (changes.length > 0) {\n          throw new Error(\"working tree has uncommitted changes (use force to discard)\");\n        }\n      }\n\n      await restoreTree(this.workFs, this.workPath, rev.tree, { fullRestore: true });\n\n      // Update HEAD\n      if (targetBranch) {\n        await this.storage.writeHead({ ref: `refs/heads/${targetBranch}` });\n      } else {\n        await this.storage.writeHead({ revision: targetRevision });\n      }\n    }\n  }\n\n  /** Create a new branch at HEAD. */\n  async branch(name: string): Promise<void> {\n    await this.ensureInit();\n\n    const existing = await this.storage.readBranch(name);\n    if (existing) {\n      throw new Error(`branch \"${name}\" already exists`);\n    }\n\n    const { revision } = await this.resolveHead();\n    if (revision === null) {\n      throw new Error(\"cannot create branch: no commits yet\");\n    }\n\n    await this.storage.writeBranch(name, { revision });\n  }\n\n  /** List all branches. */\n  async branches(): Promise<BranchInfo[]> {\n    await this.ensureInit();\n\n    const names = await this.storage.listBranches();\n    const head = await this.resolveHead();\n    const result: BranchInfo[] = [];\n\n    for (const name of names) {\n      const ref = await this.storage.readBranch(name);\n      if (ref) {\n        result.push({\n          name,\n          revision: ref.revision,\n          current: head.branch === name,\n        });\n      }\n    }\n\n    return result.sort((a, b) => a.name.localeCompare(b.name));\n  }\n\n  /** Get revision history. */\n  async log(opts?: LogOptions): Promise<LogEntry[]> {\n    await this.ensureInit();\n\n    let startRevision: number | null;\n\n    if (opts?.branch) {\n      const branchRef = await this.storage.readBranch(opts.branch);\n      if (!branchRef) throw new Error(`branch \"${opts.branch}\" not found`);\n      startRevision = branchRef.revision;\n    } else {\n      const { revision } = await this.resolveHead();\n      startRevision = revision;\n    }\n\n    if (startRevision === null) return [];\n\n    const entries: LogEntry[] = [];\n    let currentId: number | null = startRevision;\n\n    while (currentId !== null) {\n      if (opts?.limit && entries.length >= opts.limit) break;\n\n      let rev: Revision;\n      try {\n        rev = await this.storage.readRevision(currentId);\n      } catch {\n        break;\n      }\n\n      const changedPaths = rev.changes.map((c) => c.path);\n\n      if (opts?.path) {\n        // Filter: only include if this revision touches the specified path\n        const matchesPath = changedPaths.some((p) => matchGlobPath(opts.path!, p));\n        if (matchesPath) {\n          entries.push({\n            id: rev.id,\n            parent: rev.parent,\n            branch: rev.branch,\n            message: rev.message,\n            timestamp: rev.timestamp,\n            paths: changedPaths,\n          });\n        }\n      } else {\n        entries.push({\n          id: rev.id,\n          parent: rev.parent,\n          branch: rev.branch,\n          message: rev.message,\n          timestamp: rev.timestamp,\n          paths: changedPaths,\n        });\n      }\n\n      currentId = rev.parent;\n    }\n\n    return entries;\n  }\n\n  /** Get uncommitted changes as DiffEntry[]. */\n  async status(): Promise<DiffEntry[]> {\n    await this.ensureInit();\n    const manifest = await this.headManifest();\n    return diffWorkingTree(this.workFs, this.workPath, manifest, this.excludeDirs);\n  }\n\n  /** Diff between two revisions. */\n  async diff(revA: number, revB: number): Promise<DiffEntry[]> {\n    await this.ensureInit();\n    const a = await this.storage.readRevision(revA);\n    const b = await this.storage.readRevision(revB);\n    return diffManifests(a.tree, b.tree);\n  }\n\n  /** Get current HEAD info. */\n  async head(): Promise<{ branch: string | null; revision: number | null }> {\n    await this.ensureInit();\n    return this.resolveHead();\n  }\n}\n\n/**\n * Filter a list of paths to only those matching any of the given glob patterns.\n * Patterns may start with `/` which is stripped before matching.\n */\nfunction filterPathsByGlobs(paths: string[], patterns: string[]): string[] {\n  const normalizedPatterns = patterns.map((p) => (p.startsWith(\"/\") ? p.slice(1) : p));\n  return paths.filter((filePath) =>\n    normalizedPatterns.some((pattern) => matchGlobPath(pattern, filePath)),\n  );\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAY2B,IAA3B;AAC+C,IAA/C;AAC+C,IAA/C;AAC8B,IAA9B;AAAA;AAEO,MAAM,qBAAqB;AAAA,EACf;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAEjB,WAAW,CAAC,QAAmB;AAAA,IAC7B,KAAK,SAAS,OAAO;AAAA,IACrB,KAAK,WAAW,OAAO,GAAG,QAAQ,OAAO,IAAI;AAAA,IAE7C,MAAM,SAAS,OAAO,SAAS,MAAM,OAAO;AAAA,IAC5C,MAAM,WAAW,OAAO,SAAS,QAAQ,OAAO,QAAQ,OAAO,MAAM,MAAM;AAAA,IAC3E,KAAK,UAAU,IAAI,0BAAW,QAAQ,QAAQ;AAAA,IAG9C,MAAM,eAAe,OAAO,QAAQ,QAAQ;AAAA,IAC5C,MAAM,eAAe,KAAK;AAAA,IAC1B,IAAI,aAAa,WAAW,eAAe,GAAG,KAAK,aAAa,WAAW,eAAe,IAAI,GAAG;AAAA,MAC/F,MAAM,MAAM,aAAa,MAAM,aAAa,SAAS,CAAC;AAAA,MACtD,KAAK,aAAa,IAAI,MAAM,GAAG,EAAE,MAAM;AAAA,IACzC,EAAO;AAAA,MAEL,KAAK,aAAa;AAAA;AAAA;AAAA,MAIV,WAAW,GAAa;AAAA,IAClC,OAAO,KAAK,aAAa,CAAC,KAAK,UAAU,IAAI,CAAC;AAAA;AAAA,OAI1C,KAAI,GAAkB;AAAA,IAC1B,IAAI,MAAM,KAAK,QAAQ,cAAc;AAAA,MAAG;AAAA,IACxC,MAAM,KAAK,QAAQ,WAAW;AAAA;AAAA,OAGlB,WAAU,GAAkB;AAAA,IACxC,IAAI,CAAE,MAAM,KAAK,QAAQ,cAAc,GAAI;AAAA,MACzC,MAAM,KAAK,KAAK;AAAA,IAClB;AAAA;AAAA,OAIY,YAAW,GAAgE;AAAA,IACvF,MAAM,OAAO,MAAM,KAAK,QAAQ,SAAS;AAAA,IACzC,IAAI,KAAK,aAAa,WAAW;AAAA,MAC/B,OAAO,EAAE,QAAQ,MAAM,UAAU,KAAK,SAAS;AAAA,IACjD;AAAA,IACA,IAAI,KAAK,KAAK;AAAA,MACZ,MAAM,aAAa,KAAK,IAAI,QAAQ,eAAe,EAAE;AAAA,MACrD,MAAM,YAAY,MAAM,KAAK,QAAQ,WAAW,UAAU;AAAA,MAC1D,OAAO,EAAE,QAAQ,YAAY,UAAU,WAAW,YAAY,KAAK;AAAA,IACrE;AAAA,IACA,OAAO,EAAE,QAAQ,MAAM,UAAU,KAAK;AAAA;AAAA,OAI1B,aAAY,GAA0B;AAAA,IAClD,QAAQ,aAAa,MAAM,KAAK,YAAY;AAAA,IAC5C,IAAI,aAAa;AAAA,MAAM,OAAO,CAAC;AAAA,IAC/B,MAAM,MAAM,MAAM,KAAK,QAAQ,aAAa,QAAQ;AAAA,IACpD,OAAO,IAAI;AAAA;AAAA,OAIP,OAAM,CAAC,SAAiB,MAAyC;AAAA,IACrE,MAAM,KAAK,WAAW;AAAA,IAEtB,QAAQ,QAAQ,UAAU,aAAa,MAAM,KAAK,YAAY;AAAA,IAC9D,MAAM,iBAAiB,aAAa,QAC/B,MAAM,KAAK,QAAQ,aAAa,QAAQ,GAAG,OAC5C,CAAC;AAAA,IAEL,IAAI;AAAA,IACJ,IAAI;AAAA,IAEJ,IAAI,MAAM,SAAS,KAAK,MAAM,SAAS,GAAG;AAAA,MAExC,MAAM,eAAe,MAAM,kCAAkB,KAAK,QAAQ,KAAK,UAAU,KAAK,WAAW;AAAA,MACzF,MAAM,eAAe,mBAAmB,OAAO,KAAK,YAAY,GAAG,KAAK,KAAK;AAAA,MAG7E,UAAU,KAAK,eAAe;AAAA,MAG9B,MAAM,qBAAqB,mBAAmB,OAAO,KAAK,cAAc,GAAG,KAAK,KAAK;AAAA,MACrF,WAAW,KAAK,oBAAoB;AAAA,QAClC,IAAI,CAAC,aAAa,IAAI;AAAA,UACpB,OAAO,QAAQ;AAAA,QACjB;AAAA,MACF;AAAA,MAEA,WAAW,KAAK,cAAc;AAAA,QAC5B,QAAQ,KAAK,aAAa;AAAA,MAC5B;AAAA,MAGA,MAAM,iBAA+B,CAAC;AAAA,MACtC,MAAM,gBAA8B,CAAC;AAAA,MACrC,MAAM,cAAc,IAAI,IAAI,CAAC,GAAG,cAAc,GAAG,kBAAkB,CAAC;AAAA,MACpE,WAAW,KAAK,aAAa;AAAA,QAC3B,IAAI,eAAe;AAAA,UAAI,eAAe,KAAK,eAAe;AAAA,QAC1D,IAAI,QAAQ;AAAA,UAAI,cAAc,KAAK,QAAQ;AAAA,MAC7C;AAAA,MACA,UAAU,0BAAc,gBAAgB,aAAa;AAAA,IACvD,EAAO;AAAA,MAEL,UAAU,MAAM,kCAAkB,KAAK,QAAQ,KAAK,UAAU,KAAK,WAAW;AAAA,MAC9E,UAAU,0BAAc,gBAAgB,OAAO;AAAA;AAAA,IAGjD,IAAI,QAAQ,WAAW,GAAG;AAAA,MACxB,MAAM,IAAI,MAAM,mBAAmB;AAAA,IACrC;AAAA,IAEA,MAAM,KAAK,MAAM,KAAK,QAAQ,eAAe;AAAA,IAC7C,MAAM,MAAgB;AAAA,MACpB;AAAA,MACA,QAAQ;AAAA,MACR,QAAQ,UAAU;AAAA,MAClB;AAAA,MACA,WAAW,IAAI,KAAK,EAAE,YAAY;AAAA,MAClC;AAAA,MACA,MAAM;AAAA,IACR;AAAA,IAEA,MAAM,KAAK,QAAQ,cAAc,GAAG;AAAA,IAGpC,IAAI,QAAQ;AAAA,MACV,MAAM,KAAK,QAAQ,YAAY,QAAQ,EAAE,UAAU,GAAG,CAAC;AAAA,IACzD,EAAO;AAAA,MACL,MAAM,KAAK,QAAQ,UAAU,EAAE,UAAU,GAAG,CAAC;AAAA;AAAA,IAG/C,OAAO;AAAA;AAAA,OAIH,SAAQ,CAAC,QAAyB,MAAuC;AAAA,IAC7E,MAAM,KAAK,WAAW;AAAA,IAEtB,MAAM,YAAY,MAAM,SAAS,KAAK,MAAM,SAAS;AAAA,IAErD,IAAI;AAAA,IACJ,IAAI,eAA8B;AAAA,IAElC,IAAI,OAAO,WAAW,UAAU;AAAA,MAE9B,MAAM,YAAY,MAAM,KAAK,QAAQ,WAAW,MAAM;AAAA,MACtD,IAAI,WAAW;AAAA,QACb,eAAe;AAAA,QACf,iBAAiB,UAAU;AAAA,MAC7B,EAAO;AAAA,QACL,MAAM,IAAI,MAAM,gCAAgC,SAAS;AAAA;AAAA,IAE7D,EAAO;AAAA,MACL,iBAAiB;AAAA;AAAA,IAInB,IAAI;AAAA,IACJ,IAAI;AAAA,MACF,MAAM,MAAM,KAAK,QAAQ,aAAa,cAAc;AAAA,MACpD,MAAM;AAAA,MACN,MAAM,IAAI,MAAM,YAAY,0BAA0B;AAAA;AAAA,IAGxD,IAAI,WAAW;AAAA,MAEb,MAAM,eAAe,mBAAmB,OAAO,KAAK,IAAI,IAAI,GAAG,KAAM,KAAM;AAAA,MAC3E,MAAM,mBAAiC,CAAC;AAAA,MACxC,WAAW,KAAK,cAAc;AAAA,QAC5B,iBAAiB,KAAK,IAAI,KAAK;AAAA,MACjC;AAAA,MACA,MAAM,4BAAY,KAAK,QAAQ,KAAK,UAAU,kBAAkB;AAAA,QAC9D,aAAa;AAAA,QACb,OAAO;AAAA,MACT,CAAC;AAAA,IACH,EAAO;AAAA,MAEL,IAAI,CAAC,MAAM,OAAO;AAAA,QAChB,MAAM,UAAU,MAAM,KAAK,OAAO;AAAA,QAClC,IAAI,QAAQ,SAAS,GAAG;AAAA,UACtB,MAAM,IAAI,MAAM,6DAA6D;AAAA,QAC/E;AAAA,MACF;AAAA,MAEA,MAAM,4BAAY,KAAK,QAAQ,KAAK,UAAU,IAAI,MAAM,EAAE,aAAa,KAAK,CAAC;AAAA,MAG7E,IAAI,cAAc;AAAA,QAChB,MAAM,KAAK,QAAQ,UAAU,EAAE,KAAK,cAAc,eAAe,CAAC;AAAA,MACpE,EAAO;AAAA,QACL,MAAM,KAAK,QAAQ,UAAU,EAAE,UAAU,eAAe,CAAC;AAAA;AAAA;AAAA;AAAA,OAMzD,OAAM,CAAC,MAA6B;AAAA,IACxC,MAAM,KAAK,WAAW;AAAA,IAEtB,MAAM,WAAW,MAAM,KAAK,QAAQ,WAAW,IAAI;AAAA,IACnD,IAAI,UAAU;AAAA,MACZ,MAAM,IAAI,MAAM,WAAW,sBAAsB;AAAA,IACnD;AAAA,IAEA,QAAQ,aAAa,MAAM,KAAK,YAAY;AAAA,IAC5C,IAAI,aAAa,MAAM;AAAA,MACrB,MAAM,IAAI,MAAM,sCAAsC;AAAA,IACxD;AAAA,IAEA,MAAM,KAAK,QAAQ,YAAY,MAAM,EAAE,SAAS,CAAC;AAAA;AAAA,OAI7C,SAAQ,GAA0B;AAAA,IACtC,MAAM,KAAK,WAAW;AAAA,IAEtB,MAAM,QAAQ,MAAM,KAAK,QAAQ,aAAa;AAAA,IAC9C,MAAM,OAAO,MAAM,KAAK,YAAY;AAAA,IACpC,MAAM,SAAuB,CAAC;AAAA,IAE9B,WAAW,QAAQ,OAAO;AAAA,MACxB,MAAM,MAAM,MAAM,KAAK,QAAQ,WAAW,IAAI;AAAA,MAC9C,IAAI,KAAK;AAAA,QACP,OAAO,KAAK;AAAA,UACV;AAAA,UACA,UAAU,IAAI;AAAA,UACd,SAAS,KAAK,WAAW;AAAA,QAC3B,CAAC;AAAA,MACH;AAAA,IACF;AAAA,IAEA,OAAO,OAAO,KAAK,CAAC,GAAG,MAAM,EAAE,KAAK,cAAc,EAAE,IAAI,CAAC;AAAA;AAAA,OAIrD,IAAG,CAAC,MAAwC;AAAA,IAChD,MAAM,KAAK,WAAW;AAAA,IAEtB,IAAI;AAAA,IAEJ,IAAI,MAAM,QAAQ;AAAA,MAChB,MAAM,YAAY,MAAM,KAAK,QAAQ,WAAW,KAAK,MAAM;AAAA,MAC3D,IAAI,CAAC;AAAA,QAAW,MAAM,IAAI,MAAM,WAAW,KAAK,mBAAmB;AAAA,MACnE,gBAAgB,UAAU;AAAA,IAC5B,EAAO;AAAA,MACL,QAAQ,aAAa,MAAM,KAAK,YAAY;AAAA,MAC5C,gBAAgB;AAAA;AAAA,IAGlB,IAAI,kBAAkB;AAAA,MAAM,OAAO,CAAC;AAAA,IAEpC,MAAM,UAAsB,CAAC;AAAA,IAC7B,IAAI,YAA2B;AAAA,IAE/B,OAAO,cAAc,MAAM;AAAA,MACzB,IAAI,MAAM,SAAS,QAAQ,UAAU,KAAK;AAAA,QAAO;AAAA,MAEjD,IAAI;AAAA,MACJ,IAAI;AAAA,QACF,MAAM,MAAM,KAAK,QAAQ,aAAa,SAAS;AAAA,QAC/C,MAAM;AAAA,QACN;AAAA;AAAA,MAGF,MAAM,eAAe,IAAI,QAAQ,IAAI,CAAC,MAAM,EAAE,IAAI;AAAA,MAElD,IAAI,MAAM,MAAM;AAAA,QAEd,MAAM,cAAc,aAAa,KAAK,CAAC,MAAM,2BAAc,KAAK,MAAO,CAAC,CAAC;AAAA,QACzE,IAAI,aAAa;AAAA,UACf,QAAQ,KAAK;AAAA,YACX,IAAI,IAAI;AAAA,YACR,QAAQ,IAAI;AAAA,YACZ,QAAQ,IAAI;AAAA,YACZ,SAAS,IAAI;AAAA,YACb,WAAW,IAAI;AAAA,YACf,OAAO;AAAA,UACT,CAAC;AAAA,QACH;AAAA,MACF,EAAO;AAAA,QACL,QAAQ,KAAK;AAAA,UACX,IAAI,IAAI;AAAA,UACR,QAAQ,IAAI;AAAA,UACZ,QAAQ,IAAI;AAAA,UACZ,SAAS,IAAI;AAAA,UACb,WAAW,IAAI;AAAA,UACf,OAAO;AAAA,QACT,CAAC;AAAA;AAAA,MAGH,YAAY,IAAI;AAAA,IAClB;AAAA,IAEA,OAAO;AAAA;AAAA,OAIH,OAAM,GAAyB;AAAA,IACnC,MAAM,KAAK,WAAW;AAAA,IACtB,MAAM,WAAW,MAAM,KAAK,aAAa;AAAA,IACzC,OAAO,4BAAgB,KAAK,QAAQ,KAAK,UAAU,UAAU,KAAK,WAAW;AAAA;AAAA,OAIzE,KAAI,CAAC,MAAc,MAAoC;AAAA,IAC3D,MAAM,KAAK,WAAW;AAAA,IACtB,MAAM,IAAI,MAAM,KAAK,QAAQ,aAAa,IAAI;AAAA,IAC9C,MAAM,IAAI,MAAM,KAAK,QAAQ,aAAa,IAAI;AAAA,IAC9C,OAAO,0BAAc,EAAE,MAAM,EAAE,IAAI;AAAA;AAAA,OAI/B,KAAI,GAAgE;AAAA,IACxE,MAAM,KAAK,WAAW;AAAA,IACtB,OAAO,KAAK,YAAY;AAAA;AAE5B;AAMA,SAAS,kBAAkB,CAAC,OAAiB,UAA8B;AAAA,EACzE,MAAM,qBAAqB,SAAS,IAAI,CAAC,MAAO,EAAE,WAAW,GAAG,IAAI,EAAE,MAAM,CAAC,IAAI,CAAE;AAAA,EACnF,OAAO,MAAM,OAAO,CAAC,aACnB,mBAAmB,KAAK,CAAC,YAAY,2BAAc,SAAS,QAAQ,CAAC,CACvE;AAAA;",
+  "debugId": "C0D26E6B9D66359264756E2164756E21",
+  "names": []
+}

package/dist/cjs/src/vcs/walk.cjs

@@ -0,0 +1,83 @@
+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/walk.ts
+var exports_walk = {};
+__export(exports_walk, {
+  walkTree: () => walkTree
+});
+module.exports = __toCommonJS(exports_walk);
+async function walkTree(fs, root, exclude = []) {
+  const results = [];
+  await walkDir(fs, root, root, exclude, results);
+  return results.sort();
+}
+async function walkDir(fs, base, dir, exclude, results) {
+  let entries;
+  try {
+    entries = await fs.readdir(dir);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (exclude.includes(entry))
+      continue;
+    const fullPath = fs.resolve(dir, entry);
+    let stat;
+    try {
+      stat = await fs.stat(fullPath);
+    } catch {
+      continue;
+    }
+    if (stat.isDirectory()) {
+      await walkDir(fs, base, fullPath, exclude, results);
+    } else if (stat.isFile()) {
+      const relative = relativePath(base, fullPath);
+      results.push(relative);
+    }
+  }
+}
+function relativePath(base, full) {
+  const normalizedBase = base.endsWith("/") ? base : base + "/";
+  if (full.startsWith(normalizedBase)) {
+    return full.slice(normalizedBase.length);
+  }
+  return full;
+}
+
+//# debugId=D1B356BE34BA845A64756E2164756E21

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

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/vcs/walk.ts"],
+  "sourcesContent": [
+    "import type { VirtualFS } from \"../types.cjs\";\n\n/**\n * Recursively walk a directory tree and return all file paths\n * relative to the given root. Excludes directories whose names\n * match the exclude list.\n */\nexport async function walkTree(\n  fs: VirtualFS,\n  root: string,\n  exclude: string[] = [],\n): Promise<string[]> {\n  const results: string[] = [];\n  await walkDir(fs, root, root, exclude, results);\n  return results.sort();\n}\n\nasync function walkDir(\n  fs: VirtualFS,\n  base: string,\n  dir: string,\n  exclude: string[],\n  results: string[],\n): Promise<void> {\n  let entries: string[];\n  try {\n    entries = await fs.readdir(dir);\n  } catch {\n    return;\n  }\n\n  for (const entry of entries) {\n    if (exclude.includes(entry)) continue;\n\n    const fullPath = fs.resolve(dir, entry);\n    let stat;\n    try {\n      stat = await fs.stat(fullPath);\n    } catch {\n      continue;\n    }\n\n    if (stat.isDirectory()) {\n      await walkDir(fs, base, fullPath, exclude, results);\n    } else if (stat.isFile()) {\n      // Compute relative path from base\n      const relative = relativePath(base, fullPath);\n      results.push(relative);\n    }\n  }\n}\n\nfunction relativePath(base: string, full: string): string {\n  const normalizedBase = base.endsWith(\"/\") ? base : base + \"/\";\n  if (full.startsWith(normalizedBase)) {\n    return full.slice(normalizedBase.length);\n  }\n  return full;\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOA,eAAsB,QAAQ,CAC5B,IACA,MACA,UAAoB,CAAC,GACF;AAAA,EACnB,MAAM,UAAoB,CAAC;AAAA,EAC3B,MAAM,QAAQ,IAAI,MAAM,MAAM,SAAS,OAAO;AAAA,EAC9C,OAAO,QAAQ,KAAK;AAAA;AAGtB,eAAe,OAAO,CACpB,IACA,MACA,KACA,SACA,SACe;AAAA,EACf,IAAI;AAAA,EACJ,IAAI;AAAA,IACF,UAAU,MAAM,GAAG,QAAQ,GAAG;AAAA,IAC9B,MAAM;AAAA,IACN;AAAA;AAAA,EAGF,WAAW,SAAS,SAAS;AAAA,IAC3B,IAAI,QAAQ,SAAS,KAAK;AAAA,MAAG;AAAA,IAE7B,MAAM,WAAW,GAAG,QAAQ,KAAK,KAAK;AAAA,IACtC,IAAI;AAAA,IACJ,IAAI;AAAA,MACF,OAAO,MAAM,GAAG,KAAK,QAAQ;AAAA,MAC7B,MAAM;AAAA,MACN;AAAA;AAAA,IAGF,IAAI,KAAK,YAAY,GAAG;AAAA,MACtB,MAAM,QAAQ,IAAI,MAAM,UAAU,SAAS,OAAO;AAAA,IACpD,EAAO,SAAI,KAAK,OAAO,GAAG;AAAA,MAExB,MAAM,WAAW,aAAa,MAAM,QAAQ;AAAA,MAC5C,QAAQ,KAAK,QAAQ;AAAA,IACvB;AAAA,EACF;AAAA;AAGF,SAAS,YAAY,CAAC,MAAc,MAAsB;AAAA,EACxD,MAAM,iBAAiB,KAAK,SAAS,GAAG,IAAI,OAAO,OAAO;AAAA,EAC1D,IAAI,KAAK,WAAW,cAAc,GAAG;AAAA,IACnC,OAAO,KAAK,MAAM,eAAe,MAAM;AAAA,EACzC;AAAA,EACA,OAAO;AAAA;",
+  "debugId": "D1B356BE34BA845A64756E2164756E21",
+  "names": []
+}

package/dist/mjs/package.json

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

package/dist/mjs/src/index.mjs

@@ -34,6 +34,7 @@ import {
 import { createStdin, StdinImpl } from "./io/index.mjs";
 import { createStdout, createStderr, createPipe, OutputCollectorImpl, PipeBuffer } from "./io/index.mjs";
 import { escape, escapeForInterpolation, globVirtualFS } from "./utils/index.mjs";
+import { VersionControlSystem } from "./vcs/index.mjs";
 export {
   tokenToString,
   parse,
@@ -66,6 +67,7 @@ export {
   createShellDSL,
   createPipe,
   WebFileSystem,
+  VersionControlSystem,
   StdinImpl,
   ShellPromise,
   ShellError,
@@ -83,4 +85,4 @@ export {
   BreakException
 };
 
-//# debugId=6B9F05D80609142564756E2164756E21
+//# debugId=A64F16175D95758364756E2164756E21