@sdk-it/core 0.30.0 → 0.31.1

package/dist/lib/file-system.test.js

@@ -1,357 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdir, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { after, before, describe, it } from "node:test";
-import {
-  addLeadingSlash,
-  exist,
-  getExt,
-  getFile,
-  getFolderExports,
-  isNullOrUndefined,
-  readFolder,
-  removeTrialingSlashes,
-  writeFiles
-} from "./file-system.ts";
-describe("File System Utilities - Error-First Testing", () => {
-  let testDir;
-  let nonExistentPath;
-  before(async () => {
-    testDir = join(tmpdir(), `fs-test-${Date.now()}`);
-    await mkdir(testDir, { recursive: true });
-    nonExistentPath = join(testDir, "non-existent-directory", "deep", "path");
-  });
-  after(async () => {
-    const { rm } = await import("node:fs/promises");
-    await rm(testDir, { recursive: true, force: true });
-  });
-  describe("getFile - Attack Phase: Invalid Inputs & File System Errors", () => {
-    it("should return null for non-existent file", async () => {
-      const result = await getFile(join(testDir, "does-not-exist.txt"));
-      assert.strictEqual(result, null);
-    });
-    it("should return null for empty string path", async () => {
-      const result = await getFile("");
-      assert.strictEqual(result, null);
-    });
-    it("should throw error when trying to read a directory path instead of file", async () => {
-      const dirPath = join(testDir, "test-dir-for-getfile");
-      await mkdir(dirPath);
-      await assert.rejects(() => getFile(dirPath), {
-        code: "EISDIR"
-      });
-    });
-    it("should handle permission denied scenarios gracefully", async () => {
-      const result = await getFile("/root/protected-file.txt");
-      assert.strictEqual(result, null);
-    });
-    it("should handle malformed paths", async () => {
-      const malformedPaths = [
-        "\0invalid",
-        "file\nwith\nnewlines",
-        "file	with	tabs"
-      ];
-      for (const path of malformedPaths) {
-        const result = await getFile(path);
-        assert.strictEqual(result, null, `Failed for path: ${path}`);
-      }
-    });
-  });
-  describe("exist - Attack Phase: Edge Cases & Invalid Paths", () => {
-    it("should return false for non-existent paths", async () => {
-      assert.strictEqual(await exist(nonExistentPath), false);
-    });
-    it("should return false for empty string", async () => {
-      assert.strictEqual(await exist(""), false);
-    });
-    it("should handle null bytes in path gracefully", async () => {
-      assert.strictEqual(await exist("path\0with\0nulls"), false);
-    });
-    it("should handle extremely long paths", async () => {
-      const longPath = "a".repeat(1e4);
-      assert.strictEqual(await exist(longPath), false);
-    });
-  });
-  describe("readFolder - Attack Phase: Directory Corruption & Invalid States", () => {
-    it("should return empty array for non-existent directory", async () => {
-      const result = await readFolder(nonExistentPath);
-      assert.deepStrictEqual(result, []);
-    });
-    it("should throw error for file path instead of directory", async () => {
-      const filePath = join(testDir, "test-file-for-readfolder.txt");
-      await writeFile(filePath, "content");
-      await assert.rejects(() => readFolder(filePath), {
-        code: "ENOTDIR"
-      });
-    });
-    it("should handle permission denied on directory", async () => {
-      const result = await readFolder("/root");
-      assert.deepStrictEqual(result, []);
-    });
-    it("should handle recursive reading with circular symlinks gracefully", async () => {
-      const result = await readFolder(testDir, true);
-      assert.ok(Array.isArray(result));
-    });
-  });
-  describe("writeFiles - Attack Phase: Write Failures & State Corruption", () => {
-    it("should handle null content gracefully", async () => {
-      const content = {
-        "test.txt": null,
-        "valid.txt": "content"
-      };
-      await writeFiles(testDir, content);
-      assert.strictEqual(await exist(join(testDir, "test.txt")), false);
-      assert.strictEqual(await exist(join(testDir, "valid.txt")), true);
-    });
-    it("should fail gracefully when writing to read-only directory", async () => {
-      const readOnlyPath = "/read-only-system-path";
-      const content = {
-        "test.txt": "content"
-      };
-      try {
-        await writeFiles(readOnlyPath, content);
-        assert.fail("Should have thrown an error for read-only directory");
-      } catch (error) {
-        assert.ok(error instanceof Error);
-      }
-    });
-    it("should handle ignoreIfExists flag correctly when file exists", async () => {
-      const filePath = join(testDir, "existing.txt");
-      await writeFile(filePath, "original");
-      const content = {
-        "existing.txt": {
-          content: "should not overwrite",
-          ignoreIfExists: true
-        }
-      };
-      await writeFiles(testDir, content);
-      const result = await getFile(filePath);
-      assert.strictEqual(result, "original");
-    });
-    it("should create deeply nested directories", async () => {
-      const content = {
-        "deep/nested/structure/file.txt": "content"
-      };
-      await writeFiles(testDir, content);
-      const result = await getFile(
-        join(testDir, "deep/nested/structure/file.txt")
-      );
-      assert.strictEqual(result, "content");
-    });
-  });
-  describe("getFolderExports - Attack Phase: Invalid Folder States", () => {
-    const mockReadFolder = async (folder) => {
-      if (folder === nonExistentPath) {
-        return [];
-      }
-      return [
-        {
-          filePath: join(folder, "valid.ts"),
-          fileName: "valid.ts",
-          isFolder: false
-        },
-        {
-          filePath: join(folder, "index.ts"),
-          fileName: "index.ts",
-          isFolder: false
-        },
-        {
-          filePath: join(folder, "subfolder"),
-          fileName: "subfolder",
-          isFolder: true
-        }
-      ];
-    };
-    it("should handle non-existent folder gracefully", async () => {
-      const result = await getFolderExports(nonExistentPath, mockReadFolder);
-      assert.strictEqual(result, "");
-    });
-    it("should ignore files with unsupported extensions", async () => {
-      const mockReadFolderWithJs = async () => [
-        { filePath: "test.js", fileName: "test.js", isFolder: false },
-        { filePath: "test.ts", fileName: "test.ts", isFolder: false }
-      ];
-      const result = await getFolderExports(
-        testDir,
-        mockReadFolderWithJs,
-        true,
-        ["ts"]
-      );
-      assert.ok(!result.includes("test.js"));
-      assert.ok(result.includes("test.ts"));
-    });
-  });
-  describe("getExt - Attack Phase: Malformed File Names", () => {
-    it("should handle undefined filename", () => {
-      assert.strictEqual(getExt(void 0), "");
-    });
-    it("should handle empty string filename", () => {
-      assert.strictEqual(getExt(""), "");
-    });
-    it("should handle filename with no extension", () => {
-      assert.strictEqual(getExt("filename"), "");
-    });
-    it("should handle filename with multiple dots", () => {
-      assert.strictEqual(getExt("file.name.with.multiple.dots.ts"), "ts");
-    });
-    it("should handle filename starting with dot", () => {
-      assert.strictEqual(getExt(".hidden"), "hidden");
-    });
-    it("should handle filename with only dots", () => {
-      assert.strictEqual(getExt("..."), "txt");
-    });
-    it("should handle filename with path separators", () => {
-      assert.strictEqual(getExt("path/to/file.txt"), "txt");
-    });
-  });
-  describe("Path Utilities - Attack Phase: Malformed Paths", () => {
-    describe("addLeadingSlash", () => {
-      it("should handle empty string", () => {
-        assert.strictEqual(addLeadingSlash(""), "/");
-      });
-      it("should handle path with multiple leading slashes", () => {
-        assert.strictEqual(addLeadingSlash("///path"), "/path");
-      });
-      it("should handle path with backslashes", () => {
-        const result = addLeadingSlash("path\\to\\file");
-        assert.ok(result.startsWith("/"));
-      });
-    });
-    describe("removeTrialingSlashes", () => {
-      it("should handle empty string", () => {
-        assert.strictEqual(removeTrialingSlashes(""), "");
-      });
-      it("should handle string with only slashes", () => {
-        assert.strictEqual(removeTrialingSlashes("///"), "");
-      });
-      it("should preserve single slash when keepLastOne is true", () => {
-        assert.strictEqual(removeTrialingSlashes("path///", true), "path/");
-      });
-    });
-  });
-  describe("Type Guards - Attack Phase: Type Coercion Vulnerabilities", () => {
-    describe("isNullOrUndefined", () => {
-      it("should correctly identify falsy values that are not null/undefined", () => {
-        assert.strictEqual(isNullOrUndefined(0), false);
-        assert.strictEqual(isNullOrUndefined(""), false);
-        assert.strictEqual(isNullOrUndefined(false), false);
-        assert.strictEqual(isNullOrUndefined(NaN), false);
-      });
-      it("should correctly identify null and undefined", () => {
-        assert.strictEqual(isNullOrUndefined(null), true);
-        assert.strictEqual(isNullOrUndefined(void 0), true);
-      });
-    });
-    describe("type safety verification", () => {
-      it("should handle type coercion edge cases", () => {
-        const value = null;
-        if (isNullOrUndefined(value)) {
-          assert.ok(value === null || value === void 0);
-        }
-      });
-    });
-  });
-  describe("State Transition Testing - File System Operations", () => {
-    it("should maintain file system consistency during complex operations", async () => {
-      const complexContent = {
-        "folder1/file1.txt": "content1",
-        "folder1/file2.txt": null,
-        // Should not be created
-        "folder2/subfolder/file3.txt": {
-          content: "content3",
-          ignoreIfExists: false
-        },
-        "folder2/existing.txt": {
-          content: "new content",
-          ignoreIfExists: true
-        }
-      };
-      await mkdir(join(testDir, "folder2"), { recursive: true });
-      await writeFile(join(testDir, "folder2/existing.txt"), "original");
-      await writeFiles(testDir, complexContent);
-      assert.strictEqual(
-        await getFile(join(testDir, "folder1/file1.txt")),
-        "content1"
-      );
-      assert.strictEqual(
-        await exist(join(testDir, "folder1/file2.txt")),
-        false
-      );
-      assert.strictEqual(
-        await getFile(join(testDir, "folder2/subfolder/file3.txt")),
-        "content3"
-      );
-      assert.strictEqual(
-        await getFile(join(testDir, "folder2/existing.txt")),
-        "original"
-      );
-    });
-    it("should maintain directory structure consistency during recursive operations", async () => {
-      const nestedDir = join(testDir, "nested/deep/structure");
-      await mkdir(nestedDir, { recursive: true });
-      await writeFile(join(nestedDir, "file.txt"), "content");
-      await writeFile(join(testDir, "nested/file2.txt"), "content2");
-      const files = await readFolder(join(testDir, "nested"), true);
-      assert.ok(files.includes("deep/structure/file.txt"));
-      assert.ok(files.includes("file2.txt"));
-      assert.strictEqual(files.filter((f) => f.startsWith("deep/")).length, 1);
-    });
-  });
-  describe("Happy Path - Basic Functionality Confirmation", () => {
-    it("should successfully read existing file", async () => {
-      const filePath = join(testDir, "test-read.txt");
-      const content = "test content";
-      await writeFile(filePath, content);
-      const result = await getFile(filePath);
-      assert.strictEqual(result, content);
-    });
-    it("should correctly identify existing files and directories", async () => {
-      const filePath = join(testDir, "test-exist-unique.txt");
-      const dirPath = join(testDir, "test-dir-unique");
-      await writeFile(filePath, "content");
-      await mkdir(dirPath);
-      assert.strictEqual(await exist(filePath), true);
-      assert.strictEqual(await exist(dirPath), true);
-    });
-    it("should read folder contents correctly", async () => {
-      const folderPath = join(testDir, "read-test");
-      await mkdir(folderPath);
-      await writeFile(join(folderPath, "file1.txt"), "content1");
-      await writeFile(join(folderPath, "file2.txt"), "content2");
-      const files = await readFolder(folderPath);
-      assert.deepStrictEqual(files.sort(), ["file1.txt", "file2.txt"]);
-    });
-    it("should write files correctly", async () => {
-      const content = {
-        "simple.txt": "simple content",
-        "complex.txt": {
-          content: "complex content",
-          ignoreIfExists: false
-        }
-      };
-      await writeFiles(testDir, content);
-      assert.strictEqual(
-        await getFile(join(testDir, "simple.txt")),
-        "simple content"
-      );
-      assert.strictEqual(
-        await getFile(join(testDir, "complex.txt")),
-        "complex content"
-      );
-    });
-    it("should extract file extensions correctly", () => {
-      assert.strictEqual(getExt("file.txt"), "txt");
-      assert.strictEqual(getExt("script.js"), "js");
-      assert.strictEqual(getExt("component.tsx"), "tsx");
-    });
-    it("should format paths correctly", () => {
-      assert.strictEqual(addLeadingSlash("path/to/file"), "/path/to/file");
-      assert.strictEqual(
-        removeTrialingSlashes("path/to/file///"),
-        "path/to/file"
-      );
-    });
-  });
-});
-//# sourceMappingURL=file-system.test.js.map

package/dist/lib/file-system.test.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/lib/file-system.test.ts"],
-  "sourcesContent": ["import assert from 'node:assert/strict';\nimport { mkdir, writeFile } from 'node:fs/promises';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\nimport { after, before, describe, it } from 'node:test';\n\nimport {\n  type WriteContent,\n  addLeadingSlash,\n  exist,\n  getExt,\n  getFile,\n  getFolderExports,\n  isNullOrUndefined,\n  readFolder,\n  removeTrialingSlashes,\n  writeFiles,\n} from './file-system.ts';\n\ndescribe('File System Utilities - Error-First Testing', () => {\n  let testDir: string;\n  let nonExistentPath: string;\n\n  before(async () => {\n    testDir = join(tmpdir(), `fs-test-${Date.now()}`);\n    await mkdir(testDir, { recursive: true });\n    nonExistentPath = join(testDir, 'non-existent-directory', 'deep', 'path');\n  });\n\n  after(async () => {\n    const { rm } = await import('node:fs/promises');\n    await rm(testDir, { recursive: true, force: true });\n  });\n\n  describe('getFile - Attack Phase: Invalid Inputs & File System Errors', () => {\n    it('should return null for non-existent file', async () => {\n      const result = await getFile(join(testDir, 'does-not-exist.txt'));\n      assert.strictEqual(result, null);\n    });\n\n    it('should return null for empty string path', async () => {\n      const result = await getFile('');\n      assert.strictEqual(result, null);\n    });\n\n    it('should throw error when trying to read a directory path instead of file', async () => {\n      const dirPath = join(testDir, 'test-dir-for-getfile');\n      await mkdir(dirPath);\n\n      await assert.rejects(() => getFile(dirPath), {\n        code: 'EISDIR',\n      });\n    });\n\n    it('should handle permission denied scenarios gracefully', async () => {\n      // Test with invalid path that would cause permission errors\n      const result = await getFile('/root/protected-file.txt');\n      assert.strictEqual(result, null);\n    });\n\n    it('should handle malformed paths', async () => {\n      const malformedPaths = [\n        '\\0invalid',\n        'file\\nwith\\nnewlines',\n        'file\\twith\\ttabs',\n      ];\n\n      for (const path of malformedPaths) {\n        const result = await getFile(path);\n        assert.strictEqual(result, null, `Failed for path: ${path}`);\n      }\n    });\n  });\n\n  describe('exist - Attack Phase: Edge Cases & Invalid Paths', () => {\n    it('should return false for non-existent paths', async () => {\n      assert.strictEqual(await exist(nonExistentPath), false);\n    });\n\n    it('should return false for empty string', async () => {\n      assert.strictEqual(await exist(''), false);\n    });\n\n    it('should handle null bytes in path gracefully', async () => {\n      assert.strictEqual(await exist('path\\0with\\0nulls'), false);\n    });\n\n    it('should handle extremely long paths', async () => {\n      const longPath = 'a'.repeat(10000);\n      assert.strictEqual(await exist(longPath), false);\n    });\n  });\n\n  describe('readFolder - Attack Phase: Directory Corruption & Invalid States', () => {\n    it('should return empty array for non-existent directory', async () => {\n      const result = await readFolder(nonExistentPath);\n      assert.deepStrictEqual(result, []);\n    });\n\n    it('should throw error for file path instead of directory', async () => {\n      const filePath = join(testDir, 'test-file-for-readfolder.txt');\n      await writeFile(filePath, 'content');\n\n      // readFolder should throw an error when given a file path\n      await assert.rejects(() => readFolder(filePath), {\n        code: 'ENOTDIR',\n      });\n    });\n\n    it('should handle permission denied on directory', async () => {\n      const result = await readFolder('/root');\n      assert.deepStrictEqual(result, []);\n    });\n\n    it('should handle recursive reading with circular symlinks gracefully', async () => {\n      // This tests the function's resilience to infinite loops\n      const result = await readFolder(testDir, true);\n      assert.ok(Array.isArray(result));\n    });\n  });\n\n  describe('writeFiles - Attack Phase: Write Failures & State Corruption', () => {\n    it('should handle null content gracefully', async () => {\n      const content: WriteContent = {\n        'test.txt': null,\n        'valid.txt': 'content',\n      };\n\n      await writeFiles(testDir, content);\n\n      // Verify null content file was not created\n      assert.strictEqual(await exist(join(testDir, 'test.txt')), false);\n      // Verify valid file was created\n      assert.strictEqual(await exist(join(testDir, 'valid.txt')), true);\n    });\n\n    it('should fail gracefully when writing to read-only directory', async () => {\n      const readOnlyPath = '/read-only-system-path';\n      const content: WriteContent = {\n        'test.txt': 'content',\n      };\n\n      try {\n        await writeFiles(readOnlyPath, content);\n        assert.fail('Should have thrown an error for read-only directory');\n      } catch (error) {\n        assert.ok(error instanceof Error);\n      }\n    });\n\n    it('should handle ignoreIfExists flag correctly when file exists', async () => {\n      const filePath = join(testDir, 'existing.txt');\n      await writeFile(filePath, 'original');\n\n      const content: WriteContent = {\n        'existing.txt': {\n          content: 'should not overwrite',\n          ignoreIfExists: true,\n        },\n      };\n\n      await writeFiles(testDir, content);\n      const result = await getFile(filePath);\n      assert.strictEqual(result, 'original');\n    });\n\n    it('should create deeply nested directories', async () => {\n      const content: WriteContent = {\n        'deep/nested/structure/file.txt': 'content',\n      };\n\n      await writeFiles(testDir, content);\n      const result = await getFile(\n        join(testDir, 'deep/nested/structure/file.txt'),\n      );\n      assert.strictEqual(result, 'content');\n    });\n  });\n\n  describe('getFolderExports - Attack Phase: Invalid Folder States', () => {\n    const mockReadFolder = async (folder: string) => {\n      if (folder === nonExistentPath) {\n        return [];\n      }\n      return [\n        {\n          filePath: join(folder, 'valid.ts'),\n          fileName: 'valid.ts',\n          isFolder: false,\n        },\n        {\n          filePath: join(folder, 'index.ts'),\n          fileName: 'index.ts',\n          isFolder: false,\n        },\n        {\n          filePath: join(folder, 'subfolder'),\n          fileName: 'subfolder',\n          isFolder: true,\n        },\n      ];\n    };\n\n    it('should handle non-existent folder gracefully', async () => {\n      const result = await getFolderExports(nonExistentPath, mockReadFolder);\n      assert.strictEqual(result, '');\n    });\n\n    it('should ignore files with unsupported extensions', async () => {\n      const mockReadFolderWithJs = async () => [\n        { filePath: 'test.js', fileName: 'test.js', isFolder: false },\n        { filePath: 'test.ts', fileName: 'test.ts', isFolder: false },\n      ];\n\n      const result = await getFolderExports(\n        testDir,\n        mockReadFolderWithJs,\n        true,\n        ['ts'],\n      );\n      assert.ok(!result.includes('test.js'));\n      assert.ok(result.includes('test.ts'));\n    });\n  });\n\n  describe('getExt - Attack Phase: Malformed File Names', () => {\n    it('should handle undefined filename', () => {\n      assert.strictEqual(getExt(undefined), '');\n    });\n\n    it('should handle empty string filename', () => {\n      assert.strictEqual(getExt(''), '');\n    });\n\n    it('should handle filename with no extension', () => {\n      assert.strictEqual(getExt('filename'), '');\n    });\n\n    it('should handle filename with multiple dots', () => {\n      assert.strictEqual(getExt('file.name.with.multiple.dots.ts'), 'ts');\n    });\n\n    it('should handle filename starting with dot', () => {\n      // Based on the actual implementation, '.hidden' should return 'hidden'\n      assert.strictEqual(getExt('.hidden'), 'hidden');\n    });\n\n    it('should handle filename with only dots', () => {\n      // Based on the actual implementation, '...' returns 'txt' as fallback\n      assert.strictEqual(getExt('...'), 'txt');\n    });\n\n    it('should handle filename with path separators', () => {\n      assert.strictEqual(getExt('path/to/file.txt'), 'txt');\n    });\n  });\n\n  describe('Path Utilities - Attack Phase: Malformed Paths', () => {\n    describe('addLeadingSlash', () => {\n      it('should handle empty string', () => {\n        assert.strictEqual(addLeadingSlash(''), '/');\n      });\n\n      it('should handle path with multiple leading slashes', () => {\n        assert.strictEqual(addLeadingSlash('///path'), '/path');\n      });\n\n      it('should handle path with backslashes', () => {\n        const result = addLeadingSlash('path\\\\to\\\\file');\n        assert.ok(result.startsWith('/'));\n      });\n    });\n\n    describe('removeTrialingSlashes', () => {\n      it('should handle empty string', () => {\n        assert.strictEqual(removeTrialingSlashes(''), '');\n      });\n\n      it('should handle string with only slashes', () => {\n        assert.strictEqual(removeTrialingSlashes('///'), '');\n      });\n\n      it('should preserve single slash when keepLastOne is true', () => {\n        assert.strictEqual(removeTrialingSlashes('path///', true), 'path/');\n      });\n    });\n  });\n\n  describe('Type Guards - Attack Phase: Type Coercion Vulnerabilities', () => {\n    describe('isNullOrUndefined', () => {\n      it('should correctly identify falsy values that are not null/undefined', () => {\n        assert.strictEqual(isNullOrUndefined(0), false);\n        assert.strictEqual(isNullOrUndefined(''), false);\n        assert.strictEqual(isNullOrUndefined(false), false);\n        assert.strictEqual(isNullOrUndefined(NaN), false);\n      });\n\n      it('should correctly identify null and undefined', () => {\n        assert.strictEqual(isNullOrUndefined(null), true);\n        assert.strictEqual(isNullOrUndefined(undefined), true);\n      });\n    });\n\n    // Remove notNullOrUndefined tests since it doesn't exist in the source\n    describe('type safety verification', () => {\n      it('should handle type coercion edge cases', () => {\n        // Test that isNullOrUndefined works as a proper type guard\n        const value: unknown = null;\n        if (isNullOrUndefined(value)) {\n          // TypeScript should narrow the type here\n          assert.ok(value === null || value === undefined);\n        }\n      });\n    });\n  });\n\n  describe('State Transition Testing - File System Operations', () => {\n    it('should maintain file system consistency during complex operations', async () => {\n      const complexContent: WriteContent = {\n        'folder1/file1.txt': 'content1',\n        'folder1/file2.txt': null, // Should not be created\n        'folder2/subfolder/file3.txt': {\n          content: 'content3',\n          ignoreIfExists: false,\n        },\n        'folder2/existing.txt': {\n          content: 'new content',\n          ignoreIfExists: true,\n        },\n      };\n\n      // Pre-create existing file\n      await mkdir(join(testDir, 'folder2'), { recursive: true });\n      await writeFile(join(testDir, 'folder2/existing.txt'), 'original');\n\n      await writeFiles(testDir, complexContent);\n\n      // Verify final state\n      assert.strictEqual(\n        await getFile(join(testDir, 'folder1/file1.txt')),\n        'content1',\n      );\n      assert.strictEqual(\n        await exist(join(testDir, 'folder1/file2.txt')),\n        false,\n      );\n      assert.strictEqual(\n        await getFile(join(testDir, 'folder2/subfolder/file3.txt')),\n        'content3',\n      );\n      assert.strictEqual(\n        await getFile(join(testDir, 'folder2/existing.txt')),\n        'original',\n      );\n    });\n\n    it('should maintain directory structure consistency during recursive operations', async () => {\n      // Create nested structure\n      const nestedDir = join(testDir, 'nested/deep/structure');\n      await mkdir(nestedDir, { recursive: true });\n      await writeFile(join(nestedDir, 'file.txt'), 'content');\n      await writeFile(join(testDir, 'nested/file2.txt'), 'content2');\n\n      const files = await readFolder(join(testDir, 'nested'), true);\n\n      // Verify structure is maintained\n      assert.ok(files.includes('deep/structure/file.txt'));\n      assert.ok(files.includes('file2.txt'));\n      assert.strictEqual(files.filter((f) => f.startsWith('deep/')).length, 1);\n    });\n  });\n\n  describe('Happy Path - Basic Functionality Confirmation', () => {\n    it('should successfully read existing file', async () => {\n      const filePath = join(testDir, 'test-read.txt');\n      const content = 'test content';\n      await writeFile(filePath, content);\n\n      const result = await getFile(filePath);\n      assert.strictEqual(result, content);\n    });\n\n    it('should correctly identify existing files and directories', async () => {\n      const filePath = join(testDir, 'test-exist-unique.txt');\n      const dirPath = join(testDir, 'test-dir-unique');\n\n      await writeFile(filePath, 'content');\n      await mkdir(dirPath);\n\n      assert.strictEqual(await exist(filePath), true);\n      assert.strictEqual(await exist(dirPath), true);\n    });\n\n    it('should read folder contents correctly', async () => {\n      const folderPath = join(testDir, 'read-test');\n      await mkdir(folderPath);\n      await writeFile(join(folderPath, 'file1.txt'), 'content1');\n      await writeFile(join(folderPath, 'file2.txt'), 'content2');\n\n      const files = await readFolder(folderPath);\n      assert.deepStrictEqual(files.sort(), ['file1.txt', 'file2.txt']);\n    });\n\n    it('should write files correctly', async () => {\n      const content: WriteContent = {\n        'simple.txt': 'simple content',\n        'complex.txt': {\n          content: 'complex content',\n          ignoreIfExists: false,\n        },\n      };\n\n      await writeFiles(testDir, content);\n\n      assert.strictEqual(\n        await getFile(join(testDir, 'simple.txt')),\n        'simple content',\n      );\n      assert.strictEqual(\n        await getFile(join(testDir, 'complex.txt')),\n        'complex content',\n      );\n    });\n\n    it('should extract file extensions correctly', () => {\n      assert.strictEqual(getExt('file.txt'), 'txt');\n      assert.strictEqual(getExt('script.js'), 'js');\n      assert.strictEqual(getExt('component.tsx'), 'tsx');\n    });\n\n    it('should format paths correctly', () => {\n      assert.strictEqual(addLeadingSlash('path/to/file'), '/path/to/file');\n      assert.strictEqual(\n        removeTrialingSlashes('path/to/file///'),\n        'path/to/file',\n      );\n    });\n  });\n});\n"],
-  "mappings": "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",
-  "names": []
-}

package/dist/lib/program.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=program.test.d.ts.map

package/dist/lib/program.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"program.test.d.ts","sourceRoot":"","sources":["../../src/lib/program.test.ts"],"names":[],"mappings":""}