@ibgib/vcs-gib 0.0.47 → 0.0.49

package/src/cli/commands/delete-files.respec.mts

@@ -0,0 +1,366 @@
+/**
+ * @module delete-files.respec
+ *
+ * Unit tests for VCS file and folder deletion workflows:
+ * - vcs add <deleted-file>
+ * - vcs add -a (auto-staging missing files as deleted)
+ * - vcs status (rendering staged & unstaged deletions)
+ * - vcs commit (Merkle DAG negative-space pruning)
+ * - vcs commit --keep-empty-folders vs --rm-empty-folders
+ * - vcs restore <deleted-file> (recovering deleted file to worktree)
+ * - vcs reset <deleted-file> (unstaging deletion)
+ */
+
+import path from 'node:path';
+import fs from 'node:fs/promises';
+
+import {
+    respecfully, ifWe, iReckon, ifWeMight,
+} from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
+
+import { executeInitCmd } from './cli-init-cmd.mjs';
+import { executeAddCmd } from './cli-add-cmd.mjs';
+import { executeCommitCmd } from './cli-commit-cmd.mjs';
+import { executeStatusCmd } from './cli-status-cmd.mjs';
+import { executeResetCmd } from './cli-reset-cmd.mjs';
+import { executeRestoreCmd } from './cli-restore-cmd.mjs';
+
+const lc = `[apps/vcs-gib/src/cli/commands/delete-files.respec.mts]`;
+
+await respecfully(lc, `VCS Deletions Lifecycle Command Handlers`, async () => {
+
+    await ifWe(lc, `vcs add <deleted-file> stages deletion, and vcs commit prunes it from Merkle tree`, async () => {
+        const testDir = path.join(process.cwd(), '.test_delete_single');
+        const vcsFolderName = '.vcsgib_test_delete_single';
+        try {
+            await executeInitCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            await fs.writeFile(path.join(testDir, 'file1.txt'), 'Content 1', 'utf8');
+
+            await executeAddCmd({
+                paths: ['file1.txt'],
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            await executeCommitCmd({
+                message: 'Add file1.txt',
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            // Delete file on disk
+            await fs.unlink(path.join(testDir, 'file1.txt'));
+
+            // Status shows unstaged deletion
+            let statusRes = await executeStatusCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+            iReckon(lc, statusRes.deleted.map(x => x.path)).includes('file1.txt');
+
+            // Stage deletion via vcs add <path>
+            const addRes = await executeAddCmd({
+                paths: ['file1.txt'],
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+            iReckon(lc, addRes.stagedPaths).includes('file1.txt');
+
+            // Status shows staged deletion
+            statusRes = await executeStatusCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+            iReckon(lc, statusRes.staged.map(x => x.path)).includes('file1.txt');
+            const stagedItem = statusRes.staged.find(x => x.path === 'file1.txt');
+            iReckon(lc, stagedItem?.stagedType).willEqual('deleted');
+
+            // Commit deletion
+            const commitRes = await executeCommitCmd({
+                message: 'Delete file1.txt',
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+            iReckon(lc, commitRes.committedPaths).includes('file1.txt');
+
+            // Status is clean after commit
+            statusRes = await executeStatusCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+            iReckon(lc, statusRes.staged.length).willEqual(0);
+            iReckon(lc, statusRes.deleted.length).willEqual(0);
+            iReckon(lc, statusRes.modified.length).willEqual(0);
+        } finally {
+            await fs.rm(testDir, { recursive: true, force: true });
+        }
+    });
+
+    await ifWe(lc, `vcs add -a stages multiple deleted files and folder pruning occurs on commit`, async () => {
+        const testDir = path.join(process.cwd(), '.test_delete_all');
+        const vcsFolderName = '.vcsgib_test_delete_all';
+        try {
+            await executeInitCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            await fs.mkdir(path.join(testDir, 'src', 'utils'), { recursive: true });
+            await fs.writeFile(path.join(testDir, 'src', 'utils', 'math.ts'), 'export const pi = 3.14;', 'utf8');
+            await fs.writeFile(path.join(testDir, 'src', 'index.ts'), 'export * from "./utils/math.js";', 'utf8');
+            await fs.writeFile(path.join(testDir, 'readme.md'), '# Test Project', 'utf8');
+
+            await executeAddCmd({
+                all: true,
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            await executeCommitCmd({
+                message: 'Initial project files',
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            // Delete math.ts
+            await fs.unlink(path.join(testDir, 'src', 'utils', 'math.ts'));
+
+            // vcs add -a auto-stages the deleted file
+            const addRes = await executeAddCmd({
+                all: true,
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+            iReckon(lc, addRes.stagedPaths).includes('src/utils/math.ts');
+
+            // Status shows staged deletion
+            let statusRes = await executeStatusCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+            iReckon(lc, statusRes.staged.map(x => x.path)).includes('src/utils/math.ts');
+
+            // Commit with default pruning (--rm-empty-folders)
+            const commitRes = await executeCommitCmd({
+                message: 'Remove math utility',
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+            iReckon(lc, commitRes.committedPaths).includes('src/utils/math.ts');
+
+            statusRes = await executeStatusCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+            iReckon(lc, statusRes.staged.length).willEqual(0);
+            iReckon(lc, statusRes.deleted.length).willEqual(0);
+        } finally {
+            await fs.rm(testDir, { recursive: true, force: true });
+        }
+    });
+
+    await ifWe(lc, `vcs commit with keepEmptyFolders retains empty folder node in tree`, async () => {
+        const testDir = path.join(process.cwd(), '.test_delete_keep_empty');
+        const vcsFolderName = '.vcsgib_test_delete_keep_empty';
+        try {
+            await executeInitCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            await fs.mkdir(path.join(testDir, 'emptyDir'), { recursive: true });
+            await fs.writeFile(path.join(testDir, 'emptyDir', 'temp.txt'), 'temporary', 'utf8');
+
+            await executeAddCmd({
+                all: true,
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            await executeCommitCmd({
+                message: 'Initial with temp.txt',
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            // Delete temp.txt
+            await fs.unlink(path.join(testDir, 'emptyDir', 'temp.txt'));
+
+            await executeAddCmd({
+                paths: ['emptyDir/temp.txt'],
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            // Commit with keepEmptyFolders: true
+            const commitRes = await executeCommitCmd({
+                message: 'Delete temp keeping empty dir',
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+                keepEmptyFolders: true,
+            });
+            iReckon(lc, commitRes.committedPaths).includes('emptyDir/temp.txt');
+
+            const statusRes = await executeStatusCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+            iReckon(lc, statusRes.staged.length).willEqual(0);
+        } finally {
+            await fs.rm(testDir, { recursive: true, force: true });
+        }
+    });
+
+    await ifWe(lc, `vcs restore <file> restores deleted file from committed snapshot to disk`, async () => {
+        const testDir = path.join(process.cwd(), '.test_restore_deleted');
+        const vcsFolderName = '.vcsgib_test_restore_deleted';
+        try {
+            await executeInitCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            await fs.mkdir(path.join(testDir, 'assets', 'css'), { recursive: true });
+            await fs.writeFile(path.join(testDir, 'assets', 'css', 'style.css'), 'body { margin: 0; }', 'utf8');
+
+            await executeAddCmd({
+                all: true,
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            await executeCommitCmd({
+                message: 'Add stylesheet',
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            // Delete style.css from disk
+            await fs.unlink(path.join(testDir, 'assets', 'css', 'style.css'));
+
+            let statusRes = await executeStatusCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+            iReckon(lc, statusRes.deleted.map(x => x.path)).includes('assets/css/style.css');
+
+            // Restore deleted file from committed snapshot
+            const restoreRes = await executeRestoreCmd({
+                paths: ['assets/css/style.css'],
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+            iReckon(lc, restoreRes.restoredPaths).includes('assets/css/style.css');
+
+            // Verify file is back on disk at correct nested path with correct content
+            const restoredContent = await fs.readFile(path.join(testDir, 'assets', 'css', 'style.css'), 'utf8');
+            iReckon(lc, restoredContent).willEqual('body { margin: 0; }');
+
+            statusRes = await executeStatusCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+            iReckon(lc, statusRes.deleted.length).willEqual(0);
+        } finally {
+            await fs.rm(testDir, { recursive: true, force: true });
+        }
+    });
+
+    await ifWe(lc, `vcs reset <file> unstages a staged deletion`, async () => {
+        const testDir = path.join(process.cwd(), '.test_reset_deletion');
+        const vcsFolderName = '.vcsgib_test_reset_deletion';
+        try {
+            await executeInitCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            await fs.writeFile(path.join(testDir, 'important.txt'), 'Important data', 'utf8');
+
+            await executeAddCmd({
+                paths: ['important.txt'],
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            await executeCommitCmd({
+                message: 'Add important file',
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            // Delete from disk
+            await fs.unlink(path.join(testDir, 'important.txt'));
+
+            // Stage deletion
+            await executeAddCmd({
+                paths: ['important.txt'],
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            let statusRes = await executeStatusCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+            iReckon(lc, statusRes.staged.map(x => x.path)).includes('important.txt');
+
+            // Reset (unstage) deletion
+            const resetRes = await executeResetCmd({
+                paths: ['important.txt'],
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+            iReckon(lc, resetRes.unstagedPaths).includes('important.txt');
+
+            statusRes = await executeStatusCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+            // Should no longer be staged, but still unstaged deleted
+            iReckon(lc, statusRes.staged.length).willEqual(0);
+            iReckon(lc, statusRes.deleted.map(x => x.path)).includes('important.txt');
+        } finally {
+            await fs.rm(testDir, { recursive: true, force: true });
+        }
+    });
+
+});

package/src/cli/vcs-cli-main.mts

@@ -120,6 +120,7 @@ export async function main({
             case VCS_SUBCOMMANDS.COMMIT: {
                 await executeCommitCmd({
                     message: parsed.flags.message,
+                    keepEmptyFolders: parsed.flags.keepEmptyFolders,
                 });
                 break;
             }