@joshski/dust 0.1.71 → 0.1.73

package/dist/dust.js

@@ -275,7 +275,7 @@ async function loadSettings(cwd, fileSystem) {
 }
 
 // lib/version.ts
-var DUST_VERSION = "0.1.71";
+var DUST_VERSION = "0.1.73";
 
 // lib/session.ts
 var DUST_UNATTENDED = "DUST_UNATTENDED";

package/dist/filesystem/emulator.d.ts

@@ -0,0 +1,49 @@
+/**
+ * In-memory FileSystem emulator for testing and cache-backed use cases.
+ *
+ * Provides a complete FileSystem + GlobScanner implementation backed by
+ * an in-memory file tree, with write tracking for test assertions.
+ */
+import type { FileSystem, GlobScanner } from './types';
+export type FileSystemTree = {
+    [name: string]: string | FileSystemTree;
+};
+/**
+ * Extended file system with write tracking for assertions.
+ * Also implements GlobScanner by scanning over known files.
+ */
+export interface FileSystemEmulator extends FileSystem, GlobScanner {
+    createdDirs: string[];
+    writtenFiles: Map<string, string>;
+    /** Internal files map - exposed for tests that need to modify file system state */
+    files: Map<string, string>;
+    /** File permissions set via chmod - maps path to mode */
+    permissions: Map<string, number>;
+}
+/**
+ * Creates a file system emulator with optional file contents and write tracking.
+ * Implements both FileSystem and GlobScanner interfaces - the scan() method
+ * iterates over the files the emulator knows about.
+ *
+ * @param tree - Nested object representing file system hierarchy (paths get '/' prefix)
+ * @param flatFiles - Optional record of path→content entries added as-is (no prefix)
+ * @returns FileSystemEmulator with tracking for created directories and written files
+ *
+ * @example
+ * // Nested tree (paths become /project/.dust/...)
+ * createFileSystemEmulator({
+ *   project: {
+ *     '.dust': {
+ *       principles: { 'my-principle.md': '# My Principle' },
+ *       ideas: {}  // empty directory
+ *     }
+ *   }
+ * })
+ *
+ * // Flat files (paths used as-is)
+ * createFileSystemEmulator({}, {
+ *   '.dust/config/audits/security.md': '# Security Audit\n...',
+ *   '.dust/tasks/audit-security.md': '# Run security audit\n...',
+ * })
+ */
+export declare function createFileSystemEmulator(tree?: FileSystemTree, flatFiles?: Record<string, string>): FileSystemEmulator;

package/dist/filesystem-emulator.js

@@ -0,0 +1,146 @@
+// lib/filesystem/emulator.ts
+function flattenFileSystemTree(tree, basePath = "") {
+  const files = new Map;
+  const paths = new Set;
+  for (const [name, value] of Object.entries(tree)) {
+    const fullPath = basePath ? `${basePath}/${name}` : `/${name}`;
+    if (typeof value === "string") {
+      files.set(fullPath, value);
+      paths.add(fullPath);
+    } else {
+      paths.add(fullPath);
+      const nested = flattenFileSystemTree(value, fullPath);
+      for (const [path, content] of nested.files) {
+        files.set(path, content);
+      }
+      for (const path of nested.paths) {
+        paths.add(path);
+      }
+    }
+  }
+  for (const path of [...files.keys(), ...paths]) {
+    let dir = path;
+    while (dir.includes("/")) {
+      dir = dir.substring(0, dir.lastIndexOf("/"));
+      if (dir)
+        paths.add(dir);
+    }
+  }
+  return { files, paths };
+}
+function createFileSystemEmulator(tree = {}, flatFiles) {
+  const { files, paths } = flattenFileSystemTree(tree);
+  if (flatFiles) {
+    for (const [filePath, content] of Object.entries(flatFiles)) {
+      files.set(filePath, content);
+      paths.add(filePath);
+      for (let dir = filePath.substring(0, filePath.lastIndexOf("/"));dir; dir = dir.substring(0, dir.lastIndexOf("/"))) {
+        paths.add(dir);
+      }
+    }
+  }
+  const createdDirs = [];
+  const writtenFiles = new Map;
+  const permissions = new Map;
+  const creationTimes = new Map;
+  let nextCreationTime = 1000;
+  for (const path of files.keys()) {
+    creationTimes.set(path, nextCreationTime++);
+  }
+  return {
+    exists: (path) => paths.has(path),
+    isDirectory: (path) => paths.has(path) && !files.has(path),
+    readFile: async (path) => {
+      if (!files.has(path)) {
+        const error = new Error(`ENOENT: no such file or directory, open '${path}'`);
+        error.code = "ENOENT";
+        throw error;
+      }
+      return files.get(path);
+    },
+    writeFile: async (path, content, options) => {
+      if (options?.flag === "wx" && paths.has(path)) {
+        const error = new Error(`EEXIST: file already exists, open '${path}'`);
+        error.code = "EEXIST";
+        throw error;
+      }
+      writtenFiles.set(path, content);
+      paths.add(path);
+      files.set(path, content);
+      if (!creationTimes.has(path)) {
+        creationTimes.set(path, nextCreationTime++);
+      }
+    },
+    mkdir: async (path) => {
+      createdDirs.push(path);
+    },
+    readdir: async (path) => {
+      const prefix = `${path}/`;
+      const entries = new Set;
+      for (const f of files.keys()) {
+        if (f.startsWith(prefix)) {
+          const relativePath = f.slice(prefix.length);
+          if (!relativePath.includes("/")) {
+            entries.add(relativePath);
+          } else {
+            entries.add(relativePath.split("/")[0]);
+          }
+        }
+      }
+      return Array.from(entries);
+    },
+    chmod: async (path, mode) => {
+      permissions.set(path, mode);
+    },
+    getFileCreationTime: (path) => {
+      return creationTimes.get(path) ?? 0;
+    },
+    scan: async function* (dir) {
+      if (!paths.has(dir)) {
+        const error = new Error(`ENOENT: no such file or directory, scandir '${dir}'`);
+        error.code = "ENOENT";
+        throw error;
+      }
+      const prefix = `${dir}/`;
+      for (const file of files.keys()) {
+        if (file.startsWith(prefix)) {
+          yield file.slice(prefix.length);
+        }
+      }
+    },
+    rename: async (oldPath, newPath) => {
+      const entriesToMove = [];
+      const pathsToUpdate = [];
+      for (const [path, content] of files.entries()) {
+        if (path === oldPath || path.startsWith(`${oldPath}/`)) {
+          const relativePath = path.slice(oldPath.length);
+          const newFilePath = `${newPath}${relativePath}`;
+          entriesToMove.push([path, newFilePath]);
+          files.set(newFilePath, content);
+          paths.add(newFilePath);
+        }
+      }
+      for (const path of paths) {
+        if (path === oldPath || path.startsWith(`${oldPath}/`)) {
+          pathsToUpdate.push(path);
+          const relativePath = path.slice(oldPath.length);
+          paths.add(`${newPath}${relativePath}`);
+        }
+      }
+      for (const [oldFilePath] of entriesToMove) {
+        files.delete(oldFilePath);
+        paths.delete(oldFilePath);
+      }
+      for (const oldPathEntry of pathsToUpdate) {
+        paths.delete(oldPathEntry);
+      }
+    },
+    createdDirs,
+    writtenFiles,
+    files,
+    permissions
+  };
+}
+export {
+  createFileSystemEmulator
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@joshski/dust",
-  "version": "0.1.71",
+  "version": "0.1.73",
   "description": "Flow state for AI coding agents",
   "type": "module",
   "bin": {
@@ -29,6 +29,10 @@
     "./filesystem": {
       "types": "./dist/filesystem/types.d.ts"
     },
+    "./filesystem/emulator": {
+      "import": "./dist/filesystem-emulator.js",
+      "types": "./dist/filesystem/emulator.d.ts"
+    },
     "./istanbul/minimal-reporter": "./lib/istanbul/minimal-reporter.cjs",
     "./biome": {
       "import": "./dist/biome.js",