barely-effect 0.1.0

package/dist/platform/filesystem/MemoryFileSystem.d.ts

@@ -0,0 +1,42 @@
+import { Effect } from "effect";
+import { AbsolutePath } from "./AbsolutePath";
+import { FsDirNotEmptyError, FsNotADirError, type FsDirAccessError, type FsDirCreateError, type FsDirRemoveError, type FsFileAccessError, type FsFileWriteError, type FileSystemEntry, type IFileSystem } from "./IFileSystem";
+export type MemoryFileSystemGenesisState = {
+    [path: string]: MemoryFileSystemGenesisState | string;
+};
+export declare class MemoryFileSystem implements IFileSystem {
+    private readonly entries;
+    private readonly root;
+    constructor(genesis?: MemoryFileSystemGenesisState);
+    readFile(path: AbsolutePath): Effect.Effect<string, FsFileAccessError>;
+    writeFile(path: AbsolutePath, contents: string): Effect.Effect<void, FsFileWriteError>;
+    exists(path: AbsolutePath): Effect.Effect<boolean>;
+    createDir(dirPath: AbsolutePath, options?: {
+        recursive: boolean;
+    }): Effect.Effect<void, FsDirCreateError>;
+    removeDir(dirPath: AbsolutePath, options: {
+        recursive: true;
+        force: true;
+    }): Effect.Effect<void, never>;
+    removeDir(dirPath: AbsolutePath, options: {
+        recursive: true;
+        force: false;
+    }): Effect.Effect<void, FsDirAccessError>;
+    removeDir(dirPath: AbsolutePath, options: {
+        recursive: false;
+        force: true;
+    }): Effect.Effect<void, FsDirNotEmptyError | FsNotADirError>;
+    removeDir(dirPath: AbsolutePath, options: {
+        recursive: false;
+        force: false;
+    }): Effect.Effect<void, FsDirRemoveError>;
+    listDir(path: AbsolutePath): Effect.Effect<FileSystemEntry[], FsDirAccessError>;
+    get(path: AbsolutePath): Effect.Effect<FileSystemEntry | undefined>;
+    private seedFromGenesis;
+    private writeFileSync;
+    private createDirectorySync;
+    private getDirectChildren;
+    private removeDirectoryRecursive;
+    private hasEntriesWithin;
+}
+//# sourceMappingURL=MemoryFileSystem.d.ts.map

package/dist/platform/filesystem/MemoryFileSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MemoryFileSystem.d.ts","sourceRoot":"","sources":["../../../src/platform/filesystem/MemoryFileSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAE/B,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC7C,OAAO,EAEL,kBAAkB,EAIlB,cAAc,EAEd,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,WAAW,EACjB,MAAM,eAAe,CAAA;AAGtB,MAAM,MAAM,4BAA4B,GAAG;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,4BAA4B,GAAG,MAAM,CAAA;CAAE,CAAA;AAIpG,qBAAa,gBAAiB,YAAW,WAAW;IAClD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuD;IAC/E,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAoB;gBAE7B,OAAO,GAAE,4BAAiC;IAKtD,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC;IAetE,SAAS,CAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAkBtF,MAAM,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC;IAMlD,SAAS,CACP,OAAO,EAAE,YAAY,EACrB,OAAO,GAAE;QAAE,SAAS,EAAE,OAAO,CAAA;KAAwB,GACpD,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAiCxC,SAAS,CACP,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE;QAAE,SAAS,EAAE,IAAI,CAAC;QAAC,KAAK,EAAE,IAAI,CAAA;KAAE,GACxC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC;IAC7B,SAAS,CACP,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE;QAAE,SAAS,EAAE,IAAI,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAE,GACzC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,gBAAgB,CAAC;IACxC,SAAS,CACP,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE;QAAE,SAAS,EAAE,KAAK,CAAC;QAAC,KAAK,EAAE,IAAI,CAAA;KAAE,GACzC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,kBAAkB,GAAG,cAAc,CAAC;IAC3D,SAAS,CACP,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE;QAAE,SAAS,EAAE,KAAK,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAE,GAC1C,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAuCxC,OAAO,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,eAAe,EAAE,EAAE,gBAAgB,CAAC;IAe/E,GAAG,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,eAAe,GAAG,SAAS,CAAC;IAYnE,OAAO,CAAC,eAAe;IAavB,OAAO,CAAC,aAAa;IAerB,OAAO,CAAC,mBAAmB;IAyB3B,OAAO,CAAC,iBAAiB;IAiBzB,OAAO,CAAC,wBAAwB;IAUhC,OAAO,CAAC,gBAAgB;CASzB"}

package/dist/platform/filesystem/MemoryFileSystem.js

@@ -0,0 +1,200 @@
+import { Effect } from "effect";
+import { AbsolutePath } from "./AbsolutePath.js";
+import { FsAlreadyExistsError, FsDirNotEmptyError, FsDirNotFoundError, FsFileIsADirError, FsFileNotFoundError, FsNotADirError, FsParentNotFoundError, } from "./IFileSystem.js";
+import { KeyedMap } from "./KeyedMap.js";
+export class MemoryFileSystem {
+    entries = new KeyedMap((key) => key.path);
+    root = AbsolutePath("/");
+    constructor(genesis = {}) {
+        this.entries.set(this.root, { type: "dir" });
+        this.seedFromGenesis(AbsolutePath("/"), genesis);
+    }
+    readFile(path) {
+        return Effect.gen({ self: this }, function* () {
+            const entry = this.entries.get(path);
+            if (entry?.type === "dir") {
+                return yield* Effect.fail(new FsFileIsADirError({ path }));
+            }
+            if (!entry) {
+                return yield* Effect.fail(new FsFileNotFoundError({ path }));
+            }
+            return entry.content;
+        });
+    }
+    writeFile(path, contents) {
+        return Effect.gen({ self: this }, function* () {
+            const parentPath = path.getDirPath();
+            const parentEntry = this.entries.get(parentPath);
+            if (!parentEntry) {
+                return yield* Effect.fail(new FsParentNotFoundError({ path }));
+            }
+            const entry = this.entries.get(path);
+            if (entry?.type === "dir") {
+                return yield* Effect.fail(new FsFileIsADirError({ path }));
+            }
+            this.entries.set(path, { type: "file", content: contents });
+        });
+    }
+    exists(path) {
+        return Effect.gen({ self: this }, function* () {
+            return (yield* this.get(path)) !== undefined;
+        });
+    }
+    createDir(dirPath, options = { recursive: true }) {
+        return Effect.gen({ self: this }, function* () {
+            const entry = this.entries.get(dirPath);
+            if (entry?.type === "dir") {
+                if (!options.recursive) {
+                    return yield* Effect.fail(new FsAlreadyExistsError({ path: dirPath }));
+                }
+                return;
+            }
+            const parentPath = dirPath.getDirPath();
+            if (!options.recursive && !this.entries.get(parentPath)) {
+                return yield* Effect.fail(new FsParentNotFoundError({ path: dirPath }));
+            }
+            if (options.recursive) {
+                let current = dirPath;
+                while (!this.entries.has(current)) {
+                    this.entries.set(current, { type: "dir" });
+                    const parent = current.getDirPath();
+                    if (parent.eq(current)) {
+                        break;
+                    }
+                    current = parent;
+                }
+            }
+            else {
+                this.entries.set(dirPath, { type: "dir" });
+            }
+        });
+    }
+    removeDir(dirPath, options) {
+        return Effect.gen({ self: this }, function* () {
+            const entry = this.entries.get(dirPath);
+            if (entry?.type === "file") {
+                if (options.recursive && options.force) {
+                    this.entries.delete(dirPath);
+                    return;
+                }
+                return yield* Effect.fail(new FsNotADirError({ path: dirPath }));
+            }
+            if (!entry) {
+                if (options.force) {
+                    return;
+                }
+                return yield* Effect.fail(new FsDirNotFoundError({ path: dirPath }));
+            }
+            const hasChildren = this.hasEntriesWithin(dirPath);
+            if (hasChildren && !options.recursive) {
+                return yield* Effect.fail(new FsDirNotEmptyError({ path: dirPath }));
+            }
+            if (options.recursive) {
+                this.removeDirectoryRecursive(dirPath);
+            }
+            else {
+                this.entries.delete(dirPath);
+            }
+        });
+    }
+    listDir(path) {
+        return Effect.gen({ self: this }, function* () {
+            const entry = this.entries.get(path);
+            if (entry?.type === "file") {
+                return yield* Effect.fail(new FsNotADirError({ path }));
+            }
+            if (!entry) {
+                return yield* Effect.fail(new FsDirNotFoundError({ path }));
+            }
+            return this.getDirectChildren(path);
+        });
+    }
+    get(path) {
+        return Effect.sync(() => {
+            const entry = this.entries.get(path);
+            if (!entry) {
+                return undefined;
+            }
+            return { type: entry.type, path };
+        });
+    }
+    seedFromGenesis(cwd, genesis) {
+        for (const [key, value] of Object.entries(genesis)) {
+            const path = cwd.join(key);
+            if (typeof value === "string") {
+                this.createDirectorySync(path.getDirPath(), { recursive: true });
+                this.writeFileSync(path, value);
+            }
+            else {
+                this.createDirectorySync(path, { recursive: true });
+                this.seedFromGenesis(path, value);
+            }
+        }
+    }
+    writeFileSync(path, contents) {
+        const parentPath = path.getDirPath();
+        const parentEntry = this.entries.get(parentPath);
+        if (!parentEntry) {
+            throw new Error(`Parent directory not found: ${parentPath.path}`);
+        }
+        const entry = this.entries.get(path);
+        if (entry?.type === "dir") {
+            throw new Error(`Path is a directory: ${path.path}`);
+        }
+        this.entries.set(path, { type: "file", content: contents });
+    }
+    createDirectorySync(dirPath, options) {
+        const entry = this.entries.get(dirPath);
+        if (entry?.type === "dir") {
+            if (!options.recursive) {
+                throw new Error(`Directory already exists: ${dirPath.path}`);
+            }
+            return;
+        }
+        if (options.recursive) {
+            let current = dirPath;
+            while (!this.entries.has(current)) {
+                this.entries.set(current, { type: "dir" });
+                const parent = current.getDirPath();
+                if (parent.eq(current)) {
+                    break;
+                }
+                current = parent;
+            }
+        }
+        else {
+            this.entries.set(dirPath, { type: "dir" });
+        }
+    }
+    getDirectChildren(dir) {
+        const files = [];
+        const dirs = [];
+        for (const [path, entry] of this.entries) {
+            if (path.getDirPath().eq(dir) && !path.eq(dir)) {
+                if (entry.type === "file") {
+                    files.push({ type: "file", path });
+                }
+                else {
+                    dirs.push({ type: "dir", path });
+                }
+            }
+        }
+        return [...files, ...dirs];
+    }
+    removeDirectoryRecursive(dir) {
+        for (const [path] of this.entries) {
+            if (dir.contains(path)) {
+                this.entries.delete(path);
+            }
+        }
+        this.entries.set(this.root, { type: "dir" });
+    }
+    hasEntriesWithin(dir) {
+        for (const [path] of this.entries) {
+            if (dir.contains(path) && !path.eq(dir)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

package/dist/platform/filesystem/glob/cachedFs.d.ts

@@ -0,0 +1,9 @@
+import { Effect } from "effect";
+import type { AbsolutePath } from "../AbsolutePath";
+import type { FsDirAccessError, FileSystemEntry, IFileSystem } from "../IFileSystem";
+export interface GlobFs {
+    get(path: AbsolutePath): Effect.Effect<FileSystemEntry | undefined>;
+    listDir(path: AbsolutePath): Effect.Effect<FileSystemEntry[], FsDirAccessError>;
+}
+export declare function createCachedFs(fs: IFileSystem): GlobFs;
+//# sourceMappingURL=cachedFs.d.ts.map

package/dist/platform/filesystem/glob/cachedFs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cachedFs.d.ts","sourceRoot":"","sources":["../../../../src/platform/filesystem/glob/cachedFs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAE/B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AACnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAEpF,MAAM,WAAW,MAAM;IACrB,GAAG,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,eAAe,GAAG,SAAS,CAAC,CAAA;IACnE,OAAO,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,eAAe,EAAE,EAAE,gBAAgB,CAAC,CAAA;CAChF;AAED,wBAAgB,cAAc,CAAC,EAAE,EAAE,WAAW,GAAG,MAAM,CAgCtD"}

package/dist/platform/filesystem/glob/cachedFs.js

@@ -0,0 +1,25 @@
+import { Effect } from "effect";
+export function createCachedFs(fs) {
+    const getCache = new Map();
+    const listDirCache = new Map();
+    return {
+        get(path) {
+            const key = path.path;
+            if (getCache.has(key)) {
+                return Effect.succeed(getCache.get(key));
+            }
+            return fs.get(path).pipe(Effect.tap((result) => Effect.sync(() => {
+                getCache.set(key, result);
+            })));
+        },
+        listDir(path) {
+            const key = path.path;
+            if (listDirCache.has(key)) {
+                return Effect.succeed(listDirCache.get(key));
+            }
+            return fs.listDir(path).pipe(Effect.tap((result) => Effect.sync(() => {
+                listDirCache.set(key, result);
+            })));
+        },
+    };
+}

package/dist/platform/filesystem/glob/glob.d.ts

@@ -0,0 +1,15 @@
+import { Effect } from "effect";
+import type { FileSystemEntry, FsDirAccessError, IFileSystem } from "../IFileSystem";
+import { AbsolutePath } from "../AbsolutePath";
+export interface GlobOptions {
+    pattern: string;
+    onlyFiles?: boolean;
+    cwd: AbsolutePath;
+}
+export declare function glob(options: GlobOptions & {
+    onlyFiles: true;
+}, fs: IFileSystem): Effect.Effect<AbsolutePath[], FsDirAccessError>;
+export declare function glob(options: GlobOptions & {
+    onlyFiles?: false;
+}, fs: IFileSystem): Effect.Effect<FileSystemEntry[], FsDirAccessError>;
+//# sourceMappingURL=glob.d.ts.map

package/dist/platform/filesystem/glob/glob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glob.d.ts","sourceRoot":"","sources":["../../../../src/platform/filesystem/glob/glob.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAE/B,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAGpF,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAI9C,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,GAAG,EAAE,YAAY,CAAA;CAClB;AAED,wBAAgB,IAAI,CAClB,OAAO,EAAE,WAAW,GAAG;IAAE,SAAS,EAAE,IAAI,CAAA;CAAE,EAC1C,EAAE,EAAE,WAAW,GACd,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,EAAE,gBAAgB,CAAC,CAAA;AAClD,wBAAgB,IAAI,CAClB,OAAO,EAAE,WAAW,GAAG;IAAE,SAAS,CAAC,EAAE,KAAK,CAAA;CAAE,EAC5C,EAAE,EAAE,WAAW,GACd,MAAM,CAAC,MAAM,CAAC,eAAe,EAAE,EAAE,gBAAgB,CAAC,CAAA"}

package/dist/platform/filesystem/glob/glob.js

@@ -0,0 +1,62 @@
+import { Effect } from "effect";
+import { assert } from "../../../assert.js";
+import { AbsolutePath } from "../AbsolutePath.js";
+import { createCachedFs } from "./cachedFs.js";
+import { parseGlob } from "./parseGlob.js";
+export function glob(options, fs) {
+    return Effect.gen(function* () {
+        const cwd = options.cwd;
+        const chunks = parseGlob(options.pattern);
+        const cachedFs = createCachedFs(fs);
+        const entries = yield* matchGlobWalker(chunks, cwd, cachedFs, new Set());
+        if (options.onlyFiles) {
+            return entries.filter((e) => e.type === "file").map((e) => e.path);
+        }
+        return entries;
+    });
+}
+function matchGlobWalker(chunks, cwd, fs, visited) {
+    return Effect.gen(function* () {
+        const cwdEntry = yield* fs.get(cwd);
+        assert(!!cwdEntry, `${cwd.path} does not exist`);
+        const [chunk, ...rest] = chunks;
+        if (!chunk) {
+            const alreadyVisited = visited.has(cwd.path);
+            if (alreadyVisited) {
+                return [];
+            }
+            visited.add(cwd.path);
+            return [cwdEntry];
+        }
+        if (cwdEntry.type === "file") {
+            return [];
+        }
+        switch (chunk.type) {
+            case "literal": {
+                const newCwd = cwd.join(chunk.value);
+                if ((yield* fs.get(newCwd)) !== undefined) {
+                    return yield* matchGlobWalker(rest, newCwd, fs, visited);
+                }
+                return [];
+            }
+            case "pattern": {
+                const entities = yield* fs.listDir(cwd);
+                const newCwds = entities
+                    .filter((entity) => chunk.pattern.test(entity.path.getName()))
+                    .map((m) => m.path);
+                const results = yield* Effect.all(newCwds.map((newCwd) => matchGlobWalker(rest, newCwd, fs, visited)), { concurrency: "unbounded" });
+                return results.flat();
+            }
+            case "globstar": {
+                const entities = yield* fs.listDir(cwd);
+                const newCwds = entities.map((m) => m.path);
+                const results = yield* Effect.all([
+                    matchGlobWalker(rest, cwd, fs, visited),
+                    ...newCwds.map((newCwd) => matchGlobWalker(rest, newCwd, fs, visited)),
+                    ...newCwds.map((newCwd) => matchGlobWalker(chunks, newCwd, fs, visited)),
+                ], { concurrency: "unbounded" });
+                return results.flat();
+            }
+        }
+    });
+}

package/dist/platform/filesystem/glob/parseGlob.d.ts

@@ -0,0 +1,11 @@
+export type GlobChunk = {
+    type: "literal";
+    value: string;
+} | {
+    type: "pattern";
+    pattern: RegExp;
+} | {
+    type: "globstar";
+};
+export declare function parseGlob(pattern: string): GlobChunk[];
+//# sourceMappingURL=parseGlob.d.ts.map

package/dist/platform/filesystem/glob/parseGlob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseGlob.d.ts","sourceRoot":"","sources":["../../../../src/platform/filesystem/glob/parseGlob.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,SAAS,GACjB;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAClC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACpC;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAAA;AAExB,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,CAItD"}

package/dist/platform/filesystem/glob/parseGlob.js

@@ -0,0 +1,61 @@
+import { assert } from "../../../assert.js";
+export function parseGlob(pattern) {
+    const chunks = pattern.split("/").map(parseChunk);
+    return combineLiteralChunks(chunks);
+}
+function parseChunk(chunk) {
+    if (chunk === "**") {
+        return { type: "globstar" };
+    }
+    if (specialCharacters.some((c) => chunk.includes(c))) {
+        return { type: "pattern", pattern: globPatternToRegex(chunk) };
+    }
+    return { type: "literal", value: chunk };
+}
+const specialCharacters = ["*", "?", "{", "["];
+function globPatternToRegex(globPattern) {
+    let regexString = "";
+    for (let i = 0; i < globPattern.length; i++) {
+        const c = globPattern[i];
+        if (c === "*") {
+            regexString += ".*";
+        }
+        else if (c === ".") {
+            regexString += "\\.";
+        }
+        else if (c === "?") {
+            regexString += ".";
+        }
+        else if (c === "{") {
+            const closingBracketIndex = globPattern.indexOf("}", i + 1);
+            assert(closingBracketIndex !== -1, `Glob pattern ${globPattern} incorrect: unbalanced {}`);
+            const optionsString = globPattern.slice(i + 1, closingBracketIndex);
+            const options = optionsString.split(",").map((s) => escapeRegex(s.trim()));
+            regexString += `(${options.join("|")})`;
+            i = closingBracketIndex;
+        }
+        else if (c === "[") {
+            assert(false, "[] not supported yet");
+        }
+        else {
+            regexString += c;
+        }
+    }
+    return new RegExp(`^${regexString}$`);
+}
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function combineLiteralChunks(chunks) {
+    return chunks.reduce((acc, chunk) => {
+        if (chunk.type === "literal" && acc.length > 0) {
+            const lastChunk = acc[acc.length - 1];
+            if (lastChunk.type === "literal") {
+                lastChunk.value += "/" + chunk.value;
+                return acc;
+            }
+        }
+        acc.push(chunk);
+        return acc;
+    }, []);
+}

package/dist/platform/filesystem/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./IFileSystem";
+export { FileSystem } from "./FileSystem";
+export { MemoryFileSystem, type MemoryFileSystemGenesisState } from "./MemoryFileSystem";
+export { AbsolutePath } from "./AbsolutePath";
+export { glob, type GlobOptions } from "./glob/glob";
+//# sourceMappingURL=index.d.ts.map

package/dist/platform/filesystem/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/platform/filesystem/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA;AAC7B,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,EAAE,gBAAgB,EAAE,KAAK,4BAA4B,EAAE,MAAM,oBAAoB,CAAA;AACxF,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC7C,OAAO,EAAE,IAAI,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAA"}

package/dist/platform/filesystem/index.js

@@ -0,0 +1,5 @@
+export * from "./IFileSystem.js";
+export { FileSystem } from "./FileSystem.js";
+export { MemoryFileSystem } from "./MemoryFileSystem.js";
+export { AbsolutePath } from "./AbsolutePath.js";
+export { glob } from "./glob/glob.js";

package/dist/platform/process/EnvReader.d.ts

@@ -0,0 +1,13 @@
+import { Effect } from "effect";
+export declare class EnvReader {
+    private readonly env;
+    constructor(env: Record<string, string | undefined>);
+    optionalString(name: string): Effect.Effect<string | undefined>;
+    string(name: string, defaultValue?: string): Effect.Effect<string>;
+    stringOf<T extends string[]>(key: string, allowedValues: readonly [...T], fallback?: T[number]): Effect.Effect<T[number]>;
+    optionalNumber(name: string): Effect.Effect<number | undefined>;
+    number(name: string, defaultValue?: number): Effect.Effect<number>;
+    optionalBoolean(name: string): Effect.Effect<boolean | undefined>;
+    boolean(name: string, defaultValue?: boolean): Effect.Effect<boolean>;
+}
+//# sourceMappingURL=EnvReader.d.ts.map

package/dist/platform/process/EnvReader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnvReader.d.ts","sourceRoot":"","sources":["../../../src/platform/process/EnvReader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAE/B,qBAAa,SAAS;IACR,OAAO,CAAC,QAAQ,CAAC,GAAG;gBAAH,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAEpE,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,SAAS,CAAC;IAI/D,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC;IAelE,QAAQ,CAAC,CAAC,SAAS,MAAM,EAAE,EACzB,GAAG,EAAE,MAAM,EACX,aAAa,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC,EAC9B,QAAQ,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,GACnB,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;IA0B3B,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,SAAS,CAAC;IAmB/D,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC;IAelE,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,GAAG,SAAS,CAAC;IAoBjE,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC;CActE"}

package/dist/platform/process/EnvReader.js

@@ -0,0 +1,92 @@
+import { Effect } from "effect";
+export class EnvReader {
+    env;
+    constructor(env) {
+        this.env = env;
+    }
+    optionalString(name) {
+        return Effect.sync(() => this.env[name]);
+    }
+    string(name, defaultValue) {
+        return Effect.gen({ self: this }, function* () {
+            const value = yield* this.optionalString(name);
+            if (value !== undefined) {
+                return value;
+            }
+            if (defaultValue !== undefined) {
+                return defaultValue;
+            }
+            return yield* Effect.die(new Error(`Environment variable ${name} not found`));
+        });
+    }
+    stringOf(key, allowedValues, fallback) {
+        return Effect.gen({ self: this }, function* () {
+            const value = yield* this.optionalString(key);
+            if (value === undefined) {
+                if (fallback !== undefined) {
+                    return fallback;
+                }
+                return yield* Effect.die(new Error(`Environment variable ${key} not found`));
+            }
+            if (allowedValues.includes(value)) {
+                return value;
+            }
+            if (fallback !== undefined) {
+                return fallback;
+            }
+            return yield* Effect.die(new Error(`Environment variable ${key} has invalid value "${value}". Allowed values: ${allowedValues.join(", ")}`));
+        });
+    }
+    optionalNumber(name) {
+        return Effect.gen({ self: this }, function* () {
+            const value = yield* this.optionalString(name);
+            if (value === undefined) {
+                return undefined;
+            }
+            const parsed = Number(value);
+            if (Number.isNaN(parsed) || value.trim() === "") {
+                return yield* Effect.die(new Error(`Environment variable ${name} has invalid number value "${value}"`));
+            }
+            return parsed;
+        });
+    }
+    number(name, defaultValue) {
+        return Effect.gen({ self: this }, function* () {
+            const value = yield* this.optionalNumber(name);
+            if (value !== undefined) {
+                return value;
+            }
+            if (defaultValue !== undefined) {
+                return defaultValue;
+            }
+            return yield* Effect.die(new Error(`Environment variable ${name} not found`));
+        });
+    }
+    optionalBoolean(name) {
+        return Effect.gen({ self: this }, function* () {
+            const value = yield* this.optionalString(name);
+            if (value === undefined) {
+                return undefined;
+            }
+            if (value === "true" || value === "1" || value === "yes") {
+                return true;
+            }
+            if (value === "false" || value === "0" || value === "no") {
+                return false;
+            }
+            return yield* Effect.die(new Error(`Environment variable ${name} has invalid boolean value "${value}"`));
+        });
+    }
+    boolean(name, defaultValue) {
+        return Effect.gen({ self: this }, function* () {
+            const value = yield* this.optionalBoolean(name);
+            if (value !== undefined) {
+                return value;
+            }
+            if (defaultValue !== undefined) {
+                return defaultValue;
+            }
+            return yield* Effect.die(new Error(`Environment variable ${name} not found`));
+        });
+    }
+}

package/dist/platform/process/ProcessContext.d.ts

@@ -0,0 +1,34 @@
+import { AbsolutePath } from "../filesystem/AbsolutePath";
+import { EnvReader } from "./EnvReader";
+export interface IProcessContext {
+    readonly cwd: AbsolutePath;
+    readonly env: EnvReader;
+    readonly home: AbsolutePath;
+    pathFromCwd(inputPath: string): AbsolutePath;
+    resolvePath(inputPath: string): AbsolutePath;
+}
+export declare abstract class AbstractProcessContext implements IProcessContext {
+    abstract readonly cwd: AbsolutePath;
+    abstract readonly env: EnvReader;
+    abstract readonly home: AbsolutePath;
+    pathFromCwd(inputPath: string): AbsolutePath;
+    resolvePath(inputPath: string): AbsolutePath;
+}
+export declare class ProcessContext extends AbstractProcessContext {
+    readonly home: AbsolutePath;
+    readonly cwd: AbsolutePath;
+    readonly env: EnvReader;
+    constructor();
+}
+export interface InMemoryProcessContextOptions {
+    cwd?: AbsolutePath;
+    home?: AbsolutePath;
+    env?: Record<string, string | undefined>;
+}
+export declare class InMemoryProcessContext extends AbstractProcessContext {
+    readonly home: AbsolutePath;
+    readonly cwd: AbsolutePath;
+    readonly env: EnvReader;
+    constructor(options?: InMemoryProcessContextOptions);
+}
+//# sourceMappingURL=ProcessContext.d.ts.map

package/dist/platform/process/ProcessContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProcessContext.d.ts","sourceRoot":"","sources":["../../../src/platform/process/ProcessContext.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AACzD,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAEvC,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,GAAG,EAAE,YAAY,CAAA;IAC1B,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAA;IACvB,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;IAE3B,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY,CAAA;IAC5C,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY,CAAA;CAC7C;AAED,8BAAsB,sBAAuB,YAAW,eAAe;IACrE,QAAQ,CAAC,QAAQ,CAAC,GAAG,EAAE,YAAY,CAAA;IACnC,QAAQ,CAAC,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAA;IAChC,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;IAEpC,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY;IAI5C,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY;CAsB7C;AAED,qBAAa,cAAe,SAAQ,sBAAsB;IACxD,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAiC;IAC5D,QAAQ,CAAC,GAAG,EAAE,YAAY,CAAkC;IAC5D,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAA;;CAMxB;AAED,MAAM,WAAW,6BAA6B;IAC5C,GAAG,CAAC,EAAE,YAAY,CAAA;IAClB,IAAI,CAAC,EAAE,YAAY,CAAA;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAA;CACzC;AAED,qBAAa,sBAAuB,SAAQ,sBAAsB;IAChE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;IAC3B,QAAQ,CAAC,GAAG,EAAE,YAAY,CAAA;IAC1B,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAA;gBAEX,OAAO,CAAC,EAAE,6BAA6B;CAMpD"}

package/dist/platform/process/ProcessContext.js

@@ -0,0 +1,47 @@
+import * as os from "node:os";
+import * as path from "node:path";
+import { AbsolutePath } from "../filesystem/AbsolutePath.js";
+import { EnvReader } from "./EnvReader.js";
+export class AbstractProcessContext {
+    pathFromCwd(inputPath) {
+        return this.cwd.join(inputPath);
+    }
+    resolvePath(inputPath) {
+        if (inputPath === "") {
+            throw new Error("Path cannot be empty");
+        }
+        if (path.isAbsolute(inputPath)) {
+            return AbsolutePath(inputPath);
+        }
+        if (inputPath.startsWith("~")) {
+            const pathAfterTilde = inputPath.slice(1);
+            if (pathAfterTilde === "" || pathAfterTilde === "/") {
+                return this.home;
+            }
+            if (pathAfterTilde.startsWith("/")) {
+                return this.home.join(pathAfterTilde);
+            }
+        }
+        return this.cwd.join(inputPath);
+    }
+}
+export class ProcessContext extends AbstractProcessContext {
+    home = new AbsolutePath(os.homedir());
+    cwd = new AbsolutePath(process.cwd());
+    env;
+    constructor() {
+        super();
+        this.env = new EnvReader(process.env);
+    }
+}
+export class InMemoryProcessContext extends AbstractProcessContext {
+    home;
+    cwd;
+    env;
+    constructor(options) {
+        super();
+        this.home = options?.home ?? AbsolutePath("/home");
+        this.cwd = options?.cwd ?? AbsolutePath("/home/workspace");
+        this.env = new EnvReader(options?.env ?? {});
+    }
+}