alepha 0.15.0 → 0.15.2

package/dist/system/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/system/errors/FileError.ts","../../src/system/providers/FileSystemProvider.ts","../../src/system/providers/MemoryFileSystemProvider.ts","../../src/system/providers/ShellProvider.ts","../../src/system/providers/MemoryShellProvider.ts","../../src/system/services/FileDetector.ts","../../src/system/providers/NodeFileSystemProvider.ts","../../src/system/providers/NodeShellProvider.ts","../../src/system/index.ts"],"mappings":"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"}

package/dist/{file → system}/index.js

@@ -1,18 +1,20 @@
-import { $inject, $module, AlephaError, isFileLike } from "alepha";
+import { $inject, $module, AlephaError, Json, isFileLike } from "alepha";
+import { join } from "node:path";
 import { createReadStream } from "node:fs";
 import { access, copyFile, cp, mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
-import { join } from "node:path";
 import { PassThrough, Readable } from "node:stream";
 import { fileURLToPath } from "node:url";
+import { exec, spawn } from "node:child_process";
+import { $logger } from "alepha/logger";
 
-//#region ../../src/file/providers/FileSystemProvider.ts
+//#region ../../src/system/providers/FileSystemProvider.ts
 /**
 * FileSystem interface providing utilities for working with files.
 */
 var FileSystemProvider = class {};
 
 //#endregion
-//#region ../../src/file/providers/MemoryFileSystemProvider.ts
+//#region ../../src/system/providers/MemoryFileSystemProvider.ts
 /**
 * In-memory implementation of FileSystemProvider for testing.
 *
@@ -37,6 +39,7 @@ var FileSystemProvider = class {};
 * ```
 */
 var MemoryFileSystemProvider = class {
+	json = $inject(Json);
 	/**
 	* In-memory storage for files (path -> content)
 	*/
@@ -54,6 +57,14 @@ var MemoryFileSystemProvider = class {
 	*/
 	writeFileCalls = [];
 	/**
+	* Track readFile calls for test assertions
+	*/
+	readFileCalls = [];
+	/**
+	* Track rm calls for test assertions
+	*/
+	rmCalls = [];
+	/**
 	* Track join calls for test assertions
 	*/
 	joinCalls = [];
@@ -76,15 +87,32 @@ var MemoryFileSystemProvider = class {
 	}
 	/**
 	* Join path segments using forward slashes.
+	* Uses Node's path.join for proper normalization (handles .. and .)
 	*/
 	join(...paths) {
 		this.joinCalls.push(paths);
-		return paths.filter(Boolean).join("/").replace(/\/+/g, "/");
+		return join(...paths);
 	}
 	/**
 	* Create a FileLike object from various sources.
 	*/
 	createFile(options) {
+		if ("path" in options) {
+			const filePath = options.path;
+			const buffer = this.files.get(filePath);
+			if (buffer === void 0) throw new Error(`ENOENT: no such file or directory, open '${filePath}'`);
+			return {
+				name: options.name ?? filePath.split("/").pop() ?? "file",
+				type: options.type ?? "application/octet-stream",
+				size: buffer.byteLength,
+				lastModified: Date.now(),
+				stream: () => {
+					throw new Error("Stream not implemented in MemoryFileSystemProvider");
+				},
+				arrayBuffer: async () => buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength),
+				text: async () => buffer.toString("utf-8")
+			};
+		}
 		if ("buffer" in options) {
 			const buffer = options.buffer;
 			return {
@@ -119,6 +147,10 @@ var MemoryFileSystemProvider = class {
 	* Remove a file or directory from memory.
 	*/
 	async rm(path, options) {
+		this.rmCalls.push({
+			path,
+			options
+		});
 		if (!(this.files.has(path) || this.directories.has(path)) && !options?.force) throw new Error(`ENOENT: no such file or directory, rm '${path}'`);
 		if (this.directories.has(path)) if (options?.recursive) {
 			this.directories.delete(path);
@@ -213,12 +245,26 @@ var MemoryFileSystemProvider = class {
 	* Read a file from memory.
 	*/
 	async readFile(path) {
+		this.readFileCalls.push(path);
 		if (this.readFileError) throw this.readFileError;
 		const content = this.files.get(path);
 		if (!content) throw new Error(`ENOENT: no such file or directory, open '${path}'`);
 		return content;
 	}
 	/**
+	* Read a file from memory as text.
+	*/
+	async readTextFile(path) {
+		return (await this.readFile(path)).toString("utf-8");
+	}
+	/**
+	* Read a file from memory as JSON.
+	*/
+	async readJsonFile(path) {
+		const text = await this.readTextFile(path);
+		return this.json.parse(text);
+	}
+	/**
 	* Write a file to memory.
 	*/
 	async writeFile(path, data) {
@@ -239,12 +285,59 @@ var MemoryFileSystemProvider = class {
 		this.directories.clear();
 		this.mkdirCalls = [];
 		this.writeFileCalls = [];
+		this.readFileCalls = [];
+		this.rmCalls = [];
 		this.joinCalls = [];
 		this.mkdirError = null;
 		this.writeFileError = null;
 		this.readFileError = null;
 	}
 	/**
+	* Check if a file was written during the test.
+	*
+	* @example
+	* ```typescript
+	* expect(fs.wasWritten("/project/tsconfig.json")).toBe(true);
+	* ```
+	*/
+	wasWritten(path) {
+		return this.writeFileCalls.some((call) => call.path === path);
+	}
+	/**
+	* Check if a file was written with content matching a pattern.
+	*
+	* @example
+	* ```typescript
+	* expect(fs.wasWrittenMatching("/project/tsconfig.json", /extends/)).toBe(true);
+	* ```
+	*/
+	wasWrittenMatching(path, pattern) {
+		const call = this.writeFileCalls.find((c) => c.path === path);
+		return call ? pattern.test(call.data) : false;
+	}
+	/**
+	* Check if a file was read during the test.
+	*
+	* @example
+	* ```typescript
+	* expect(fs.wasRead("/project/package.json")).toBe(true);
+	* ```
+	*/
+	wasRead(path) {
+		return this.readFileCalls.includes(path);
+	}
+	/**
+	* Check if a file was deleted during the test.
+	*
+	* @example
+	* ```typescript
+	* expect(fs.wasDeleted("/project/old-file.txt")).toBe(true);
+	* ```
+	*/
+	wasDeleted(path) {
+		return this.rmCalls.some((call) => call.path === path);
+	}
+	/**
 	* Get the content of a file as a string (convenience method for testing).
 	*/
 	getFileContent(path) {
@@ -253,7 +346,116 @@ var MemoryFileSystemProvider = class {
 };
 
 //#endregion
-//#region ../../src/file/services/FileDetector.ts
+//#region ../../src/system/providers/MemoryShellProvider.ts
+/**
+* In-memory implementation of ShellProvider for testing.
+*
+* Records all commands that would be executed without actually running them.
+* Can be configured to return specific outputs or throw errors for testing.
+*
+* @example
+* ```typescript
+* // In tests, substitute the real ShellProvider with MemoryShellProvider
+* const alepha = Alepha.create().with({
+*   provide: ShellProvider,
+*   use: MemoryShellProvider,
+* });
+*
+* // Configure mock behavior
+* const shell = alepha.inject(MemoryShellProvider);
+* shell.configure({
+*   outputs: { "echo hello": "hello\n" },
+*   errors: { "failing-cmd": "Command failed" },
+* });
+*
+* // Or use the fluent API
+* shell.outputs.set("another-cmd", "output");
+* shell.errors.set("another-error", "Error message");
+*
+* // Run code that uses ShellProvider
+* const service = alepha.inject(MyService);
+* await service.doSomething();
+*
+* // Verify commands were called
+* expect(shell.calls).toHaveLength(2);
+* expect(shell.calls[0].command).toBe("yarn install");
+* ```
+*/
+var MemoryShellProvider = class {
+	/**
+	* All recorded shell calls.
+	*/
+	calls = [];
+	/**
+	* Simulated outputs for specific commands.
+	*/
+	outputs = /* @__PURE__ */ new Map();
+	/**
+	* Commands that should throw an error.
+	*/
+	errors = /* @__PURE__ */ new Map();
+	/**
+	* Commands considered installed in the system PATH.
+	*/
+	installedCommands = /* @__PURE__ */ new Set();
+	/**
+	* Configure the mock with predefined outputs, errors, and installed commands.
+	*/
+	configure(options) {
+		if (options.outputs) for (const [cmd, output] of Object.entries(options.outputs)) this.outputs.set(cmd, output);
+		if (options.errors) for (const [cmd, error] of Object.entries(options.errors)) this.errors.set(cmd, error);
+		if (options.installedCommands) for (const cmd of options.installedCommands) this.installedCommands.add(cmd);
+		return this;
+	}
+	/**
+	* Record command and return simulated output.
+	*/
+	async run(command, options = {}) {
+		this.calls.push({
+			command,
+			options
+		});
+		const errorMsg = this.errors.get(command);
+		if (errorMsg) throw new Error(errorMsg);
+		return this.outputs.get(command) ?? "";
+	}
+	/**
+	* Check if a specific command was called.
+	*/
+	wasCalled(command) {
+		return this.calls.some((call) => call.command === command);
+	}
+	/**
+	* Check if a command matching a pattern was called.
+	*/
+	wasCalledMatching(pattern) {
+		return this.calls.some((call) => pattern.test(call.command));
+	}
+	/**
+	* Get all calls matching a pattern.
+	*/
+	getCallsMatching(pattern) {
+		return this.calls.filter((call) => pattern.test(call.command));
+	}
+	/**
+	* Check if a command is installed.
+	*/
+	async isInstalled(command) {
+		return this.installedCommands.has(command);
+	}
+	/**
+	* Reset all recorded state.
+	*/
+	reset() {
+		this.calls = [];
+		this.outputs.clear();
+		this.errors.clear();
+		this.installedCommands.clear();
+	}
+};
+
+//#endregion
+//#region ../../src/system/services/FileDetector.ts
 /**
 * Service for detecting file types and getting content types.
 *
@@ -956,7 +1158,7 @@ var FileDetector = class FileDetector {
 };
 
 //#endregion
-//#region ../../src/file/providers/NodeFileSystemProvider.ts
+//#region ../../src/system/providers/NodeFileSystemProvider.ts
 /**
 * Node.js implementation of FileSystem interface.
 *
@@ -983,6 +1185,7 @@ var FileDetector = class FileDetector {
 */
 var NodeFileSystemProvider = class {
 	detector = $inject(FileDetector);
+	json = $inject(Json);
 	join(...paths) {
 		return join(...paths);
 	}
@@ -1269,6 +1472,37 @@ var NodeFileSystemProvider = class {
 		await writeFile(path, data);
 	}
 	/**
+	* Reads the content of a file as a string.
+	*
+	* @param path - The file path to read
+	* @returns The file content as a string
+	*
+	* @example
+	* ```typescript
+	* const fs = alepha.inject(NodeFileSystemProvider);
+	* const content = await fs.readTextFile("/tmp/file.txt");
+	* ```
+	*/
+	async readTextFile(path) {
+		return (await this.readFile(path)).toString("utf-8");
+	}
+	/**
+	* Reads the content of a file as JSON.
+	*
+	* @param path - The file path to read
+	* @returns The parsed JSON content
+	*
+	* @example
+	* ```typescript
+	* const fs = alepha.inject(NodeFileSystemProvider);
+	* const config = await fs.readJsonFile<{ name: string }>("/tmp/config.json");
+	* ```
+	*/
+	async readJsonFile(path) {
+		const text = await this.readTextFile(path);
+		return this.json.parse(text);
+	}
+	/**
 	* Creates a FileLike object from a Web File.
 	*
 	* @protected
@@ -1421,7 +1655,154 @@ var NodeFileSystemProvider = class {
 };
 
 //#endregion
-//#region ../../src/file/errors/FileError.ts
+//#region ../../src/system/providers/NodeShellProvider.ts
+/**
+* Node.js implementation of ShellProvider.
+*
+* Executes shell commands using Node.js child_process module.
+* Supports binary resolution from node_modules/.bin for local packages.
+*/
+var NodeShellProvider = class {
+	log = $logger();
+	fs = $inject(FileSystemProvider);
+	/**
+	* Run a shell command or binary.
+	*/
+	async run(command, options = {}) {
+		const { resolve = false, capture = false, root, env } = options;
+		const cwd = root ?? process.cwd();
+		this.log.debug(`Shell: ${command}`, {
+			cwd,
+			resolve,
+			capture
+		});
+		let executable;
+		let args;
+		if (resolve) {
+			const [bin, ...rest] = command.split(" ");
+			executable = await this.resolveExecutable(bin, cwd);
+			args = rest;
+		} else [executable, ...args] = command.split(" ");
+		if (capture) return this.execCapture(command, {
+			cwd,
+			env
+		});
+		return this.execInherit(executable, args, {
+			cwd,
+			env
+		});
+	}
+	/**
+	* Execute command with inherited stdio (streams to terminal).
+	*/
+	async execInherit(executable, args, options) {
+		const proc = spawn(executable, args, {
+			stdio: "inherit",
+			cwd: options.cwd,
+			env: {
+				...process.env,
+				...options.env
+			}
+		});
+		return new Promise((resolve, reject) => {
+			proc.on("exit", (code) => {
+				if (code === 0 || code === null) resolve("");
+				else reject(new AlephaError(`Command exited with code ${code}`));
+			});
+			proc.on("error", reject);
+		});
+	}
+	/**
+	* Execute command and capture stdout.
+	*/
+	execCapture(command, options) {
+		return new Promise((resolve, reject) => {
+			exec(command, {
+				cwd: options.cwd,
+				env: {
+					...process.env,
+					LOG_FORMAT: "pretty",
+					...options.env
+				}
+			}, (err, stdout) => {
+				if (err) {
+					err.stdout = stdout;
+					reject(err);
+				} else resolve(stdout);
+			});
+		});
+	}
+	/**
+	* Resolve executable path from node_modules/.bin.
+	*
+	* Search order:
+	* 1. Local: node_modules/.bin/
+	* 2. Pnpm nested: node_modules/alepha/node_modules/.bin/
+	* 3. Monorepo: Walk up to 3 parent directories
+	*/
+	async resolveExecutable(name, root) {
+		const suffix = process.platform === "win32" ? ".cmd" : "";
+		let execPath = await this.findExecutable(root, `node_modules/.bin/${name}${suffix}`);
+		if (!execPath) execPath = await this.findExecutable(root, `node_modules/alepha/node_modules/.bin/${name}${suffix}`);
+		if (!execPath) {
+			let parentDir = this.fs.join(root, "..");
+			for (let i = 0; i < 3; i++) {
+				execPath = await this.findExecutable(parentDir, `node_modules/.bin/${name}${suffix}`);
+				if (execPath) break;
+				parentDir = this.fs.join(parentDir, "..");
+			}
+		}
+		if (!execPath) throw new AlephaError(`Could not find executable for '${name}'. Make sure the package is installed.`);
+		return execPath;
+	}
+	/**
+	* Check if executable exists at path.
+	*/
+	async findExecutable(root, relativePath) {
+		const fullPath = this.fs.join(root, relativePath);
+		if (await this.fs.exists(fullPath)) return fullPath;
+	}
+	/**
+	* Check if a command is installed and available in the system PATH.
+	*/
+	isInstalled(command) {
+		return new Promise((resolve) => {
+			exec(process.platform === "win32" ? `where ${command}` : `command -v ${command}`, (error) => resolve(!error));
+		});
+	}
+};
+
+//#endregion
+//#region ../../src/system/providers/ShellProvider.ts
+/**
+* Abstract provider for executing shell commands and binaries.
+*
+* Implementations:
+* - `NodeShellProvider` - Real shell execution using Node.js child_process
+* - `MemoryShellProvider` - In-memory mock for testing
+*
+* @example
+* ```typescript
+* class MyService {
+*   protected readonly shell = $inject(ShellProvider);
+*
+*   async build() {
+*     // Run shell command directly
+*     await this.shell.run("yarn install");
+*
+*     // Run local binary with resolution
+*     await this.shell.run("vite build", { resolve: true });
+*
+*     // Capture output
+*     const output = await this.shell.run("echo hello", { capture: true });
+*   }
+* }
+* ```
+*/
+var ShellProvider = class {};
+
+//#endregion
+//#region ../../src/system/errors/FileError.ts
 var FileError = class extends Error {
 	constructor(message, cause) {
 		super(message);
@@ -1431,34 +1812,45 @@ var FileError = class extends Error {
 };
 
 //#endregion
-//#region ../../src/file/index.ts
+//#region ../../src/system/index.ts
 /**
-* Provides file system capabilities for Alepha applications with support for multiple file sources and operations.
+* | type | quality | stability |
+* |------|---------|-----------|
+* | tooling | standard | stable |
 *
-* The file module enables working with files from various sources (URLs, buffers, streams) and provides
-* utilities for file type detection, content type determination, and common file system operations.
+* System-level abstractions for portable code across runtimes.
 *
-* @see {@link FileDetector}
-* @see {@link FileSystemProvider}
-* @see {@link NodeFileSystemProvider}
-* @module alepha.file
+* **Features:**
+* - File system operations (read, write, exists, etc.)
+* - Shell command execution
+* - File type detection and MIME utilities
+* - Memory implementations for testing
+*
+* @module alepha.system
 */
-const AlephaFile = $module({
-	name: "alepha.file",
+const AlephaSystem = $module({
+	name: "alepha.system",
 	primitives: [],
 	services: [
 		FileDetector,
 		FileSystemProvider,
 		MemoryFileSystemProvider,
-		NodeFileSystemProvider
+		NodeFileSystemProvider,
+		ShellProvider,
+		MemoryShellProvider,
+		NodeShellProvider
 	],
 	register: (alepha) => alepha.with({
 		optional: true,
 		provide: FileSystemProvider,
 		use: NodeFileSystemProvider
+	}).with({
+		optional: true,
+		provide: ShellProvider,
+		use: alepha.isTest() ? MemoryShellProvider : NodeShellProvider
 	})
 });
 
 //#endregion
-export { AlephaFile, FileDetector, FileError, FileSystemProvider, MemoryFileSystemProvider, NodeFileSystemProvider };
+export { AlephaSystem, FileDetector, FileError, FileSystemProvider, MemoryFileSystemProvider, MemoryShellProvider, NodeFileSystemProvider, NodeShellProvider, ShellProvider };
 //# sourceMappingURL=index.js.map