git-drive 0.1.5 → 0.1.6

package/dist/__tests__/commands/init.test.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const init_js_1 = require("../../commands/init.js");
+const errors_js_1 = require("../../errors.js");
+const memfs_1 = require("memfs");
+// Mock fs and path modules
+jest.mock('fs', () => {
+    const { fs } = require('memfs');
+    return fs;
+});
+// Mock prompts
+jest.mock('prompts', () => ({
+    __esModule: true,
+    default: jest.fn(),
+}));
+// Mock config
+jest.mock('../../config.js', () => ({
+    saveConfig: jest.fn(),
+    getDriveStorePath: jest.fn((drivePath) => `${drivePath}/.git-drive`),
+}));
+// Mock git
+jest.mock('../../git.js', () => ({
+    listDrives: jest.fn(),
+}));
+const prompts_1 = __importDefault(require("prompts"));
+const git_js_1 = require("../../git.js");
+const config_js_1 = require("../../config.js");
+const mockPrompts = prompts_1.default;
+const mockListDrives = git_js_1.listDrives;
+const mockSaveConfig = config_js_1.saveConfig;
+const mockGetDriveStorePath = config_js_1.getDriveStorePath;
+describe('init command', () => {
+    let consoleSpy;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        memfs_1.vol.reset();
+        consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+        mockGetDriveStorePath.mockImplementation((drivePath) => `${drivePath}/.git-drive`);
+    });
+    afterEach(() => {
+        consoleSpy.mockRestore();
+    });
+    describe('with path argument', () => {
+        it('should initialize git-drive on specified path', async () => {
+            const drivePath = '/Volumes/TestDrive';
+            memfs_1.vol.fromJSON({
+                [drivePath]: '',
+            });
+            await (0, init_js_1.init)([drivePath]);
+            expect(mockSaveConfig).toHaveBeenCalledWith({ drivePath: expect.stringContaining('TestDrive') });
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Git Drive initialized'));
+        });
+        it('should throw error if path does not exist', async () => {
+            await expect((0, init_js_1.init)(['/Volumes/NonExistent'])).rejects.toThrow(errors_js_1.GitDriveError);
+            await expect((0, init_js_1.init)(['/Volumes/NonExistent'])).rejects.toThrow('Path not found');
+        });
+        it('should throw error if path is not a directory', async () => {
+            memfs_1.vol.fromJSON({
+                '/Volumes/SomeFile': 'file content',
+            });
+            await expect((0, init_js_1.init)(['/Volumes/SomeFile'])).rejects.toThrow('Path is not a directory');
+        });
+        it('should resolve relative paths', async () => {
+            memfs_1.vol.fromJSON({
+                '/current/dir/TestDrive': '',
+            });
+            // Mock cwd to return a specific directory
+            const originalCwd = process.cwd;
+            process.cwd = jest.fn(() => '/current/dir');
+            await (0, init_js_1.init)(['./TestDrive']);
+            expect(mockSaveConfig).toHaveBeenCalled();
+            process.cwd = originalCwd;
+        });
+    });
+    describe('without path argument (interactive)', () => {
+        it('should throw error when no drives found', async () => {
+            mockListDrives.mockResolvedValue([]);
+            await expect((0, init_js_1.init)([])).rejects.toThrow('No external drives found');
+        });
+        it('should prompt user to select a drive', async () => {
+            mockListDrives.mockResolvedValue([
+                { mounted: '/Volumes/Drive1', filesystem: 'Drive1', blocks: 1000000, available: 500000 },
+                { mounted: '/Volumes/Drive2', filesystem: 'Drive2', blocks: 2000000, available: 1000000 },
+            ]);
+            mockPrompts.mockResolvedValue({
+                selectedDrive: '/Volumes/Drive1',
+            });
+            memfs_1.vol.fromJSON({
+                '/Volumes/Drive1': '',
+            });
+            await (0, init_js_1.init)([]);
+            expect(mockPrompts).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'select',
+                name: 'selectedDrive',
+            }));
+        });
+        it('should handle user cancellation', async () => {
+            mockListDrives.mockResolvedValue([
+                { mounted: '/Volumes/Drive1', filesystem: 'Drive1', blocks: 1000000, available: 500000 },
+            ]);
+            mockPrompts.mockResolvedValue({
+                selectedDrive: undefined,
+            });
+            await (0, init_js_1.init)([]);
+            expect(consoleSpy).toHaveBeenCalledWith('Operation cancelled.');
+            expect(mockSaveConfig).not.toHaveBeenCalled();
+        });
+    });
+    describe('store directory creation', () => {
+        it('should create .git-drive directory if it does not exist', async () => {
+            const drivePath = '/Volumes/TestDrive';
+            memfs_1.vol.fromJSON({
+                [drivePath]: '',
+            });
+            await (0, init_js_1.init)([drivePath]);
+            // The store path should have been requested
+            expect(mockGetDriveStorePath).toHaveBeenCalled();
+        });
+    });
+});

package/dist/__tests__/commands/list.test.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const memfs_1 = require("memfs");
+// Mock fs
+jest.mock('fs', () => {
+    const { fs } = require('memfs');
+    return fs;
+});
+// Mock node-disk-info
+jest.mock('node-disk-info', () => ({
+    getDiskInfo: jest.fn(),
+}));
+// Mock server
+jest.mock('../../server.js', () => ({
+    ensureServerRunning: jest.fn(),
+}));
+// Mock os
+jest.mock('os', () => ({
+    homedir: () => '/home/testuser',
+}));
+const node_disk_info_1 = require("node-disk-info");
+const list_js_1 = require("../../commands/list.js");
+const mockGetDiskInfo = node_disk_info_1.getDiskInfo;
+describe('list command', () => {
+    let consoleSpy;
+    const originalPlatform = process.platform;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        memfs_1.vol.reset();
+        consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+        Object.defineProperty(process, 'platform', { value: 'darwin', writable: true });
+    });
+    afterEach(() => {
+        consoleSpy.mockRestore();
+        Object.defineProperty(process, 'platform', { value: originalPlatform, writable: true });
+    });
+    it('should display no drives message when no external drives found', async () => {
+        mockGetDiskInfo.mockResolvedValue([]);
+        memfs_1.vol.fromJSON({
+            '/home/testuser/.config/git-drive/links.json': '{}',
+        });
+        await (0, list_js_1.list)([]);
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('No external drives detected'));
+    });
+    it('should list connected drives with git-drive status', async () => {
+        mockGetDiskInfo.mockResolvedValue([
+            { mounted: '/Volumes/MyUSB', filesystem: 'MyUSB', blocks: 32000000, available: 16000000 },
+            { mounted: '/Volumes/External', filesystem: 'External', blocks: 1000000000, available: 500000000 },
+        ]);
+        memfs_1.vol.fromJSON({
+            '/home/testuser/.config/git-drive/links.json': '{}',
+            '/Volumes/MyUSB/.git-drive/my-project.git/HEAD': '',
+            '/Volumes/External': '',
+        });
+        await (0, list_js_1.list)([]);
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('/Volumes/MyUSB'));
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('/Volumes/External'));
+    });
+    it('should count repositories on initialized drives', async () => {
+        mockGetDiskInfo.mockResolvedValue([
+            { mounted: '/Volumes/MyUSB', filesystem: 'MyUSB', blocks: 32000000, available: 16000000 },
+        ]);
+        memfs_1.vol.fromJSON({
+            '/home/testuser/.config/git-drive/links.json': '{}',
+            '/Volumes/MyUSB/.git-drive/project1.git/HEAD': '',
+            '/Volumes/MyUSB/.git-drive/project2.git/HEAD': '',
+            '/Volumes/MyUSB/.git-drive/project3.git/HEAD': '',
+        });
+        await (0, list_js_1.list)([]);
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Repositories: 3'));
+    });
+    it('should display drive size in GB', async () => {
+        mockGetDiskInfo.mockResolvedValue([
+            { mounted: '/Volumes/MyUSB', filesystem: 'MyUSB', blocks: 97656250, available: 50000000 },
+        ]);
+        memfs_1.vol.fromJSON({
+            '/home/testuser/.config/git-drive/links.json': '{}',
+            '/Volumes/MyUSB': '',
+        });
+        await (0, list_js_1.list)([]);
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('GB'));
+    });
+    it('should handle errors when detecting drives', async () => {
+        mockGetDiskInfo.mockRejectedValue(new Error('Failed to detect drives'));
+        memfs_1.vol.fromJSON({
+            '/home/testuser/.config/git-drive/links.json': '{}',
+        });
+        await (0, list_js_1.list)([]);
+        expect(consoleSpy).toHaveBeenCalledWith('Error detecting drives:', expect.any(Error));
+    });
+});

package/dist/__tests__/commands/push.test.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const push_js_1 = require("../../commands/push.js");
+const errors_js_1 = require("../../errors.js");
+const memfs_1 = require("memfs");
+// Mock fs
+jest.mock('fs', () => {
+    const { fs } = require('memfs');
+    return fs;
+});
+// Mock prompts
+jest.mock('prompts', () => ({
+    __esModule: true,
+    default: jest.fn(),
+}));
+// Mock git
+jest.mock('../../git.js', () => ({
+    git: jest.fn(),
+    getRemoteUrl: jest.fn(),
+    isGitRepo: jest.fn(),
+}));
+// Mock server
+jest.mock('../../server.js', () => ({
+    ensureServerRunning: jest.fn(),
+}));
+const prompts_1 = __importDefault(require("prompts"));
+const git_js_1 = require("../../git.js");
+const mockPrompts = prompts_1.default;
+const mockGit = git_js_1.git;
+const mockGetRemoteUrl = git_js_1.getRemoteUrl;
+const mockIsGitRepo = git_js_1.isGitRepo;
+describe('push command', () => {
+    let consoleSpy;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        memfs_1.vol.reset();
+        consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+        mockIsGitRepo.mockReturnValue(true);
+        mockGetRemoteUrl.mockReturnValue('/Volumes/TestDrive/.git-drive/my-repo.git');
+        mockGit.mockImplementation((cmd) => {
+            if (cmd.includes('branch --show-current'))
+                return 'main';
+            return '';
+        });
+    });
+    afterEach(() => {
+        consoleSpy.mockRestore();
+    });
+    it('should throw error when not in a git repository', async () => {
+        mockIsGitRepo.mockReturnValue(false);
+        await expect((0, push_js_1.push)([])).rejects.toThrow(errors_js_1.GitDriveError);
+        await expect((0, push_js_1.push)([])).rejects.toThrow('Not in a git repository');
+    });
+    it('should throw error when no git-drive linked', async () => {
+        mockIsGitRepo.mockReturnValue(true);
+        mockGetRemoteUrl.mockReturnValue(null);
+        await expect((0, push_js_1.push)([])).rejects.toThrow("No git-drive linked for this project");
+    });
+    describe('push modes', () => {
+        beforeEach(() => {
+            memfs_1.vol.fromJSON({
+                '/Volumes/TestDrive/.git-drive/my-repo.git/HEAD': '',
+            });
+        });
+        it('should push current branch with --current flag', async () => {
+            await (0, push_js_1.push)(['--current']);
+            expect(mockGit).toHaveBeenCalledWith(expect.stringContaining('push gd main'));
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Successfully pushed'));
+        });
+        it('should push all branches and tags with --all flag', async () => {
+            await (0, push_js_1.push)(['--all']);
+            expect(mockGit).toHaveBeenCalledWith('push gd --all');
+            expect(mockGit).toHaveBeenCalledWith('push gd --tags');
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('all branches and tags'));
+        });
+        it('should prompt for push mode when no flags provided', async () => {
+            mockPrompts.mockResolvedValue({ pushMode: 'current' });
+            await (0, push_js_1.push)([]);
+            expect(mockPrompts).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'select',
+                name: 'pushMode',
+            }));
+        });
+        it('should handle user cancellation in interactive mode', async () => {
+            mockPrompts.mockResolvedValue({ pushMode: undefined });
+            await (0, push_js_1.push)([]);
+            // Should not have pushed anything beyond the prompt
+            expect(mockGit).not.toHaveBeenCalledWith(expect.stringContaining('push gd'));
+        });
+    });
+    describe('pushlog', () => {
+        it('should write pushlog on successful push', async () => {
+            memfs_1.vol.fromJSON({
+                '/Volumes/TestDrive/.git-drive/my-repo.git/HEAD': '',
+            });
+            await (0, push_js_1.push)(['--current']);
+            // Check that the pushlog file was created
+            const files = memfs_1.vol.toJSON();
+            const pushlogPath = '/Volumes/TestDrive/.git-drive/my-repo.git/git-drive-pushlog.json';
+            // The pushlog should exist if the remote URL path exists
+            // This is tested indirectly through the code path
+        });
+        it('should handle pushlog write errors silently', async () => {
+            // Create a scenario where writing the pushlog would fail
+            memfs_1.vol.fromJSON({
+                '/Volumes/TestDrive/.git-drive/my-repo.git/HEAD': '',
+            });
+            // This should not throw even if pushlog writing fails
+            await expect((0, push_js_1.push)(['--current'])).resolves.not.toThrow();
+        });
+    });
+    describe('error handling', () => {
+        it('should throw GitDriveError when git push fails', async () => {
+            memfs_1.vol.fromJSON({
+                '/Volumes/TestDrive/.git-drive/my-repo.git/HEAD': '',
+            });
+            mockGit.mockImplementation((cmd) => {
+                if (cmd.includes('branch --show-current'))
+                    return 'main';
+                throw new Error('fatal: failed to push');
+            });
+            await expect((0, push_js_1.push)(['--current'])).rejects.toThrow(errors_js_1.GitDriveError);
+        });
+    });
+});

package/dist/__tests__/commands/restore.test.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const restore_js_1 = require("../../commands/restore.js");
+const errors_js_1 = require("../../errors.js");
+const memfs_1 = require("memfs");
+// Mock fs
+jest.mock('fs', () => {
+    const { fs } = require('memfs');
+    return fs;
+});
+// Mock config
+jest.mock('../../config.js', () => ({
+    requireConfig: jest.fn(),
+    assertDriveMounted: jest.fn(),
+    getDriveStorePath: jest.fn((drivePath) => `${drivePath}/.git-drive`),
+}));
+// Mock git
+jest.mock('../../git.js', () => ({
+    git: jest.fn(),
+}));
+// Mock server
+jest.mock('../../server.js', () => ({
+    ensureServerRunning: jest.fn(),
+}));
+const git_js_1 = require("../../git.js");
+const config_js_1 = require("../../config.js");
+const mockGit = git_js_1.git;
+const mockRequireConfig = config_js_1.requireConfig;
+const mockAssertDriveMounted = config_js_1.assertDriveMounted;
+describe('restore command', () => {
+    let consoleSpy;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        memfs_1.vol.reset();
+        consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+        mockRequireConfig.mockReturnValue({ drivePath: '/Volumes/MyUSB' });
+        mockAssertDriveMounted.mockImplementation(() => { });
+        mockGit.mockImplementation(() => { });
+    });
+    afterEach(() => {
+        consoleSpy.mockRestore();
+    });
+    it('should throw error when no project name provided', () => {
+        expect(() => (0, restore_js_1.restore)([])).toThrow(errors_js_1.GitDriveError);
+        expect(() => (0, restore_js_1.restore)([])).toThrow('Usage: git drive restore <project-name> [target-dir]');
+    });
+    it('should throw error when project not found on drive', () => {
+        memfs_1.vol.fromJSON({
+            '/Volumes/MyUSB/.git-drive': '',
+        });
+        expect(() => (0, restore_js_1.restore)(['nonexistent-project'])).toThrow(errors_js_1.GitDriveError);
+        expect(() => (0, restore_js_1.restore)(['nonexistent-project'])).toThrow("Project 'nonexistent-project' not found on drive.");
+    });
+    it('should throw error when target directory already exists', () => {
+        memfs_1.vol.fromJSON({
+            '/Volumes/MyUSB/.git-drive/my-project.git/HEAD': '',
+            '/home/user/my-project': '',
+        });
+        expect(() => (0, restore_js_1.restore)(['my-project', '/home/user/my-project'])).toThrow(errors_js_1.GitDriveError);
+        expect(() => (0, restore_js_1.restore)(['my-project', '/home/user/my-project'])).toThrow('Directory already exists');
+    });
+    it('should clone the bare repo to target directory', () => {
+        memfs_1.vol.fromJSON({
+            '/Volumes/MyUSB/.git-drive/my-project.git/HEAD': '',
+        });
+        (0, restore_js_1.restore)(['my-project', '/home/user/restored-project']);
+        expect(mockGit).toHaveBeenCalledWith(expect.stringContaining('clone /Volumes/MyUSB/.git-drive/my-project.git'));
+    });
+    it('should rename origin remote to drive', () => {
+        memfs_1.vol.fromJSON({
+            '/Volumes/MyUSB/.git-drive/my-project.git/HEAD': '',
+        });
+        (0, restore_js_1.restore)(['my-project', '/home/user/restored-project']);
+        expect(mockGit).toHaveBeenCalledWith(expect.stringContaining('remote rename origin drive'), expect.any(String));
+    });
+    it('should use project name as target directory if not specified', () => {
+        memfs_1.vol.fromJSON({
+            '/Volumes/MyUSB/.git-drive/my-project.git/HEAD': '',
+        });
+        (0, restore_js_1.restore)(['my-project']);
+        // Should call git clone with the project name
+        expect(mockGit).toHaveBeenCalledWith(expect.stringMatching(/clone.*my-project\.git/), undefined);
+    });
+    it('should log success message', () => {
+        memfs_1.vol.fromJSON({
+            '/Volumes/MyUSB/.git-drive/my-project.git/HEAD': '',
+        });
+        (0, restore_js_1.restore)(['my-project']);
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Restored'));
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('my-project'));
+    });
+    it('should work with custom target directory', () => {
+        memfs_1.vol.fromJSON({
+            '/Volumes/MyUSB/.git-drive/my-project.git/HEAD': '',
+        });
+        (0, restore_js_1.restore)(['my-project', '/custom/target']);
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('/custom/target'));
+    });
+});

package/dist/__tests__/commands/status.test.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const memfs_1 = require("memfs");
+// Mock fs
+jest.mock('fs', () => {
+    const { fs } = require('memfs');
+    return fs;
+});
+// Mock node-disk-info
+jest.mock('node-disk-info', () => ({
+    getDiskInfo: jest.fn(),
+}));
+// Mock git
+jest.mock('../../git.js', () => ({
+    isGitRepo: jest.fn(),
+    getProjectName: jest.fn(),
+    getRemoteUrl: jest.fn(),
+}));
+// Mock server
+jest.mock('../../server.js', () => ({
+    ensureServerRunning: jest.fn(),
+}));
+// Mock os
+jest.mock('os', () => ({
+    homedir: () => '/home/testuser',
+}));
+const node_disk_info_1 = require("node-disk-info");
+const git_js_1 = require("../../git.js");
+const status_js_1 = require("../../commands/status.js");
+const mockGetDiskInfo = node_disk_info_1.getDiskInfo;
+const mockIsGitRepo = git_js_1.isGitRepo;
+const mockGetProjectName = git_js_1.getProjectName;
+const mockGetRemoteUrl = git_js_1.getRemoteUrl;
+describe('status command', () => {
+    let consoleSpy;
+    const originalPlatform = process.platform;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        memfs_1.vol.reset();
+        consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+        mockIsGitRepo.mockReturnValue(false);
+        Object.defineProperty(process, 'platform', { value: 'darwin', writable: true });
+    });
+    afterEach(() => {
+        consoleSpy.mockRestore();
+        Object.defineProperty(process, 'platform', { value: originalPlatform, writable: true });
+    });
+    it('should display connected drives section', async () => {
+        mockGetDiskInfo.mockResolvedValue([
+            { mounted: '/Volumes/MyUSB', filesystem: 'MyUSB', blocks: 32000000, available: 16000000 },
+        ]);
+        memfs_1.vol.fromJSON({
+            '/home/testuser/.config/git-drive/links.json': '{}',
+            '/Volumes/MyUSB/.git-drive/my-project.git/HEAD': '',
+        });
+        await (0, status_js_1.status)([]);
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Connected Drives'));
+    });
+    it('should display no external drives message when none found', async () => {
+        mockGetDiskInfo.mockResolvedValue([]);
+        memfs_1.vol.fromJSON({
+            '/home/testuser/.config/git-drive/links.json': '{}',
+        });
+        await (0, status_js_1.status)([]);
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('No external drives connected'));
+    });
+    it('should display registered repositories section', async () => {
+        mockGetDiskInfo.mockResolvedValue([]);
+        memfs_1.vol.fromJSON({
+            '/home/testuser/.config/git-drive/links.json': JSON.stringify({
+                '/home/user/project1': {
+                    mountpoint: '/Volumes/MyUSB',
+                    repoName: 'project1.git',
+                    linkedAt: '2024-01-01T00:00:00.000Z',
+                },
+            }),
+            '/home/user/project1': '',
+            '/Volumes/MyUSB': '',
+        });
+        await (0, status_js_1.status)([]);
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Registered Repositories'));
+    });
+    it('should show NOT CONNECTED status when drive is not mounted', async () => {
+        mockGetDiskInfo.mockResolvedValue([]);
+        memfs_1.vol.fromJSON({
+            '/home/testuser/.config/git-drive/links.json': JSON.stringify({
+                '/home/user/project1': {
+                    mountpoint: '/Volumes/MyUSB',
+                    repoName: 'project1.git',
+                    linkedAt: '2024-01-01T00:00:00.000Z',
+                },
+            }),
+            '/home/user/project1': '',
+        });
+        await (0, status_js_1.status)([]);
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('NOT CONNECTED'));
+    });
+    it('should show NOT FOUND status when local directory does not exist', async () => {
+        mockGetDiskInfo.mockResolvedValue([]);
+        memfs_1.vol.fromJSON({
+            '/home/testuser/.config/git-drive/links.json': JSON.stringify({
+                '/home/user/nonexistent': {
+                    mountpoint: '/Volumes/MyUSB',
+                    repoName: 'project.git',
+                    linkedAt: '2024-01-01T00:00:00.000Z',
+                },
+            }),
+            '/Volumes/MyUSB': '',
+        });
+        await (0, status_js_1.status)([]);
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('NOT FOUND'));
+    });
+    it('should display current repository section when in a git repo', async () => {
+        mockGetDiskInfo.mockResolvedValue([]);
+        mockIsGitRepo.mockReturnValue(true);
+        mockGetProjectName.mockReturnValue('my-project');
+        mockGetRemoteUrl.mockReturnValue('/Volumes/MyUSB/.git-drive/my-project.git');
+        memfs_1.vol.fromJSON({
+            '/home/testuser/.config/git-drive/links.json': '{}',
+        });
+        await (0, status_js_1.status)([]);
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Current Repository'));
+    });
+    it('should show no gd remote message when not linked', async () => {
+        mockGetDiskInfo.mockResolvedValue([]);
+        mockIsGitRepo.mockReturnValue(true);
+        mockGetProjectName.mockReturnValue('my-project');
+        mockGetRemoteUrl.mockReturnValue(null);
+        memfs_1.vol.fromJSON({
+            '/home/testuser/.config/git-drive/links.json': '{}',
+        });
+        await (0, status_js_1.status)([]);
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("No 'gd' remote configured"));
+    });
+    it('should display server status section', async () => {
+        mockGetDiskInfo.mockResolvedValue([]);
+        memfs_1.vol.fromJSON({
+            '/home/testuser/.config/git-drive/links.json': '{}',
+        });
+        await (0, status_js_1.status)([]);
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Server'));
+    });
+    it('should handle errors gracefully', async () => {
+        mockGetDiskInfo.mockRejectedValue(new Error('Failed to get disk info'));
+        memfs_1.vol.fromJSON({
+            '/home/testuser/.config/git-drive/links.json': '{}',
+        });
+        await (0, status_js_1.status)([]);
+        expect(consoleSpy).toHaveBeenCalledWith('Error detecting drives:', expect.any(Error));
+    });
+});