@mod-computer/cli 0.1.1 → 0.2.1

package/dist/commands/mv.js

@@ -0,0 +1,282 @@
+// glassware[type="implementation", id="impl-cli-mv-cmd--7526e170", requirements="requirement-cli-mv-cmd--01f3db90,requirement-cli-mv-requires-workspace--e8eff602,requirement-cli-mv-workspace--ed3f7751,requirement-cli-mv-create-folders--62adc040,requirement-cli-mv-local--7bdf0396,requirement-cli-mv-no-overwrite--3c71bcba,requirement-cli-mv-folder--af5ef6eb"]
+// spec: packages/mod-cli/specs/file-directory.md
+import { createModWorkspace } from '@mod/mod-core';
+import { readWorkspaceConnection } from '../lib/storage.js';
+import { moveLocalFile } from '../lib/local-fs.js';
+import path from 'path';
+// glassware[type="implementation", id="impl-cli-mv-requires-workspace--35f86c8f", requirements="requirement-cli-mv-requires-workspace--e8eff602,requirement-cli-fd-error-no-workspace--1919b4fb"]
+function requireWorkspaceConnection() {
+    const currentDir = process.cwd();
+    const connection = readWorkspaceConnection(currentDir);
+    if (!connection) {
+        console.error('Error: Not connected to a workspace.');
+        console.error('Run `mod init` to connect this directory first.');
+        process.exit(1);
+    }
+    return {
+        workspaceId: connection.workspaceId,
+        workspaceName: connection.workspaceName,
+        workspacePath: connection.path,
+    };
+}
+function parseArgs(args) {
+    const options = {
+        force: false,
+        local: false,
+        dryRun: false,
+        quiet: false,
+    };
+    const paths = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--force' || arg === '-f') {
+            options.force = true;
+        }
+        else if (arg === '--local') {
+            options.local = true;
+        }
+        else if (arg === '--dry-run') {
+            options.dryRun = true;
+        }
+        else if (arg === '--quiet' || arg === '-q') {
+            options.quiet = true;
+        }
+        else if (!arg.startsWith('-')) {
+            paths.push(arg);
+        }
+    }
+    // Last path is destination, rest are sources
+    const dest = paths.pop();
+    return { sources: paths, dest, options };
+}
+export async function mvCommand(args, repo) {
+    const { workspaceId, workspacePath } = requireWorkspaceConnection();
+    const { sources, dest, options } = parseArgs(args);
+    if (sources.length === 0 || !dest) {
+        console.error('Usage: mod mv <source...> <dest>');
+        console.error('');
+        console.error('Options:');
+        console.error('  --force, -f        Overwrite existing files');
+        console.error('  --local            Also move local files');
+        console.error('  --dry-run          Show what would be moved');
+        console.error('  --quiet, -q        Only show errors');
+        process.exit(1);
+    }
+    try {
+        const modWorkspace = createModWorkspace(repo);
+        const workspaceHandle = await modWorkspace.openWorkspace(workspaceId);
+        // Get all files and folders
+        const fileRefs = await workspaceHandle.file.list();
+        const folderRefs = await workspaceHandle.folder.list();
+        // Determine if destination is a folder
+        const destIsFolder = dest.endsWith('/') ||
+            folderRefs.some(f => f.path === dest) ||
+            sources.length > 1;
+        const moveOps = [];
+        const foldersToCreate = new Set();
+        for (const source of sources) {
+            const normalizedSource = source.replace(/\/$/, '');
+            // Find matching file
+            const matchingFile = fileRefs.find(f => {
+                const filePath = f.metadata?.path || f.name;
+                return filePath === normalizedSource;
+            });
+            if (matchingFile) {
+                // Single file move/rename
+                const filePath = matchingFile.metadata?.path || matchingFile.name;
+                const fileName = path.basename(filePath);
+                let toPath;
+                let toFolderId = null;
+                let newName;
+                if (destIsFolder) {
+                    // Move to folder, keep name
+                    toPath = path.join(dest.replace(/\/$/, ''), fileName);
+                    // Find or mark folder for creation
+                    const destFolder = folderRefs.find(f => f.path === dest.replace(/\/$/, ''));
+                    if (destFolder) {
+                        toFolderId = destFolder.id;
+                    }
+                    else {
+                        foldersToCreate.add(dest.replace(/\/$/, ''));
+                    }
+                }
+                else {
+                    // Rename
+                    toPath = dest;
+                    newName = path.basename(dest);
+                    // Determine target folder
+                    const targetDir = path.dirname(dest);
+                    if (targetDir && targetDir !== '.') {
+                        const targetFolder = folderRefs.find(f => f.path === targetDir);
+                        if (targetFolder) {
+                            toFolderId = targetFolder.id;
+                        }
+                        else {
+                            foldersToCreate.add(targetDir);
+                        }
+                    }
+                }
+                // Check for existing file at destination (no-overwrite check)
+                const existingFile = fileRefs.find(f => {
+                    const fp = f.metadata?.path || f.name;
+                    return fp === toPath && f.id !== matchingFile.id;
+                });
+                if (existingFile && !options.force) {
+                    console.error(`Error: ${toPath} already exists. Use --force to overwrite.`);
+                    process.exit(1);
+                }
+                moveOps.push({
+                    fileId: matchingFile.id,
+                    fromPath: filePath,
+                    toPath,
+                    toFolderId,
+                    newName,
+                });
+            }
+            else {
+                // Check if it's a folder - move all contents
+                const filesInFolder = fileRefs.filter(f => {
+                    const filePath = f.metadata?.path || f.name;
+                    return filePath.startsWith(normalizedSource + '/') || filePath === normalizedSource;
+                });
+                if (filesInFolder.length > 0) {
+                    for (const file of filesInFolder) {
+                        const filePath = file.metadata?.path || file.name;
+                        const relativePath = filePath.startsWith(normalizedSource + '/')
+                            ? filePath.slice(normalizedSource.length + 1)
+                            : path.basename(filePath);
+                        const toPath = path.join(dest.replace(/\/$/, ''), relativePath);
+                        const targetDir = path.dirname(toPath);
+                        let toFolderId = null;
+                        if (targetDir && targetDir !== '.') {
+                            const targetFolder = folderRefs.find(f => f.path === targetDir);
+                            if (targetFolder) {
+                                toFolderId = targetFolder.id;
+                            }
+                            else {
+                                foldersToCreate.add(targetDir);
+                            }
+                        }
+                        moveOps.push({
+                            fileId: file.id,
+                            fromPath: filePath,
+                            toPath,
+                            toFolderId,
+                        });
+                    }
+                }
+                else {
+                    console.error(`Error: File not found in workspace: ${source}`);
+                    console.error("Run `mod ls` to see workspace files.");
+                    process.exit(1);
+                }
+            }
+        }
+        if (moveOps.length === 0) {
+            console.log('No files to move.');
+            return;
+        }
+        // Dry run
+        if (options.dryRun) {
+            if (foldersToCreate.size > 0) {
+                console.log('Would create folders:');
+                for (const folder of foldersToCreate) {
+                    console.log(`  ${folder}/`);
+                }
+                console.log('');
+            }
+            console.log(`Would move ${moveOps.length} file${moveOps.length === 1 ? '' : 's'}:`);
+            for (const op of moveOps) {
+                console.log(`  ${op.fromPath} -> ${op.toPath}`);
+            }
+            return;
+        }
+        // Create folders if needed
+        const folderIdMap = new Map();
+        for (const folderPath of Array.from(foldersToCreate).sort()) {
+            try {
+                const newFolder = await workspaceHandle.folder.create(folderPath);
+                folderIdMap.set(folderPath, newFolder.id);
+                if (!options.quiet) {
+                    console.log(`Created folder: ${folderPath}/`);
+                }
+            }
+            catch (error) {
+                // Folder might already exist, try to find it
+                const existing = (await workspaceHandle.folder.list()).find(f => f.path === folderPath);
+                if (existing) {
+                    folderIdMap.set(folderPath, existing.id);
+                }
+            }
+        }
+        // Execute moves
+        let moved = 0;
+        let localMoved = 0;
+        const errors = [];
+        for (const op of moveOps) {
+            try {
+                // Update folder ID from created folders
+                let targetFolderId = op.toFolderId;
+                const targetDir = path.dirname(op.toPath);
+                if (targetDir && targetDir !== '.' && folderIdMap.has(targetDir)) {
+                    targetFolderId = folderIdMap.get(targetDir);
+                }
+                // Move in workspace
+                if (op.newName) {
+                    await workspaceHandle.file.rename(op.fileId, op.newName);
+                }
+                if (targetFolderId !== undefined) {
+                    await workspaceHandle.file.move(op.fileId, targetFolderId);
+                }
+                moved++;
+                if (!options.quiet) {
+                    console.log(`Moved in workspace: ${op.fromPath} -> ${op.toPath}`);
+                }
+                // Move local file if --local flag is set
+                if (options.local) {
+                    const localFrom = path.join(workspacePath, op.fromPath);
+                    const localTo = path.join(workspacePath, op.toPath);
+                    const result = await moveLocalFile(localFrom, localTo);
+                    if (result.success) {
+                        localMoved++;
+                        if (!options.quiet) {
+                            console.log(`Moved local file: ${op.fromPath} -> ${op.toPath}`);
+                        }
+                    }
+                    else if (result.error) {
+                        // Permission error handling
+                        console.warn(`Warning: ${result.error}`);
+                        console.warn('Workspace updated, but local file not moved.');
+                    }
+                }
+            }
+            catch (error) {
+                errors.push(`Failed to move ${op.fromPath}: ${error.message}`);
+            }
+        }
+        // Summary
+        if (!options.quiet) {
+            console.log('');
+            if (moveOps.length === 1) {
+                console.log(`Moved: ${moveOps[0].fromPath} -> ${moveOps[0].toPath}`);
+            }
+            else {
+                console.log(`Moved ${moved} file${moved === 1 ? '' : 's'}.`);
+            }
+            if (!options.local && moved > 0) {
+                console.log('Note: Local files unchanged. Use --local to also move locally.');
+            }
+        }
+        if (errors.length > 0) {
+            console.error('');
+            for (const error of errors) {
+                console.error(error);
+            }
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error('Error moving files:', error.message);
+        process.exit(1);
+    }
+}

package/dist/commands/rm.js

@@ -0,0 +1,257 @@
+// glassware[type="implementation", id="impl-cli-rm-cmd--81378802", requirements="requirement-cli-rm-cmd--40931f9e,requirement-cli-rm-requires-workspace--1a926c90,requirement-cli-rm-confirm--027ace3f,requirement-cli-rm-force--5bd56511,requirement-cli-rm-workspace-only--405d41f5,requirement-cli-rm-local--a58b09c9,requirement-cli-rm-recursive--91e50991,requirement-cli-rm-dry-run--c3af989d"]
+// spec: packages/mod-cli/specs/file-directory.md
+import { createModWorkspace } from '@mod/mod-core';
+import { readWorkspaceConnection } from '../lib/storage.js';
+import { select } from '../lib/prompts.js';
+import { matchGlob, deleteLocalFile, deleteLocalDirectory } from '../lib/local-fs.js';
+import path from 'path';
+// glassware[type="implementation", id="impl-cli-rm-requires-workspace--8a7b05f5", requirements="requirement-cli-rm-requires-workspace--1a926c90,requirement-cli-fd-error-no-workspace--1919b4fb"]
+function requireWorkspaceConnection() {
+    const currentDir = process.cwd();
+    const connection = readWorkspaceConnection(currentDir);
+    if (!connection) {
+        console.error('Error: Not connected to a workspace.');
+        console.error('Run `mod init` to connect this directory first.');
+        process.exit(1);
+    }
+    return {
+        workspaceId: connection.workspaceId,
+        workspaceName: connection.workspaceName,
+        workspacePath: connection.path,
+    };
+}
+function parseArgs(args) {
+    const options = {
+        recursive: false,
+        force: false,
+        local: false,
+        dryRun: false,
+        quiet: false,
+    };
+    const paths = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--recursive' || arg === '-r') {
+            options.recursive = true;
+        }
+        else if (arg === '--force' || arg === '-f') {
+            options.force = true;
+        }
+        else if (arg === '--local') {
+            options.local = true;
+        }
+        else if (arg === '--dry-run') {
+            options.dryRun = true;
+        }
+        else if (arg === '--quiet' || arg === '-q') {
+            options.quiet = true;
+        }
+        else if (!arg.startsWith('-')) {
+            paths.push(arg);
+        }
+    }
+    return { paths, options };
+}
+// glassware[type="implementation", id="impl-cli-fd-error-not-found--00ef7ef6", requirements="requirement-cli-fd-error-not-found--9c364146"]
+function showNotFoundError(filePath) {
+    console.error(`Error: File not found in workspace: ${filePath}`);
+    console.error("Run `mod ls` to see workspace files.");
+}
+export async function rmCommand(args, repo) {
+    const { workspaceId, workspacePath } = requireWorkspaceConnection();
+    const { paths, options } = parseArgs(args);
+    if (paths.length === 0) {
+        console.error('Usage: mod rm <path...>');
+        console.error('');
+        console.error('Options:');
+        console.error('  --recursive, -r    Remove directories recursively');
+        console.error('  --force, -f        Skip confirmation prompt');
+        console.error('  --local            Also delete from local filesystem');
+        console.error('  --dry-run          Show what would be removed');
+        console.error('  --quiet, -q        Only show errors');
+        process.exit(1);
+    }
+    try {
+        const modWorkspace = createModWorkspace(repo);
+        const workspaceHandle = await modWorkspace.openWorkspace(workspaceId);
+        // Get all files and folders
+        const fileRefs = await workspaceHandle.file.list();
+        const folderRefs = await workspaceHandle.folder.list();
+        // Build list of files to remove
+        const filesToRemove = [];
+        const foldersToRemove = [];
+        for (const targetPath of paths) {
+            const isGlob = targetPath.includes('*');
+            const isFolder = targetPath.endsWith('/');
+            const normalizedPath = targetPath.replace(/\/$/, '');
+            if (isGlob) {
+                // Glob pattern matching
+                for (const file of fileRefs) {
+                    const filePath = file.metadata?.path || file.name;
+                    if (matchGlob(filePath, targetPath)) {
+                        filesToRemove.push({ id: file.id, path: filePath, isFolder: false });
+                    }
+                }
+            }
+            else {
+                // Exact path or folder
+                const matchingFile = fileRefs.find(f => {
+                    const filePath = f.metadata?.path || f.name;
+                    return filePath === normalizedPath;
+                });
+                if (matchingFile) {
+                    filesToRemove.push({
+                        id: matchingFile.id,
+                        path: matchingFile.metadata?.path || matchingFile.name,
+                        isFolder: false,
+                    });
+                }
+                else {
+                    // Check if it's a folder
+                    const matchingFolder = folderRefs.find(f => f.path === normalizedPath);
+                    if (matchingFolder) {
+                        if (!options.recursive) {
+                            console.error(`Error: ${normalizedPath}/ is a folder. Use --recursive to remove.`);
+                            process.exit(1);
+                        }
+                        foldersToRemove.push({
+                            id: matchingFolder.id,
+                            path: matchingFolder.path,
+                            isFolder: true,
+                        });
+                        // Add all files in folder
+                        for (const file of fileRefs) {
+                            const filePath = file.metadata?.path || file.name;
+                            if (filePath.startsWith(normalizedPath + '/')) {
+                                filesToRemove.push({ id: file.id, path: filePath, isFolder: false });
+                            }
+                        }
+                    }
+                    else {
+                        // Check if path matches folder prefix
+                        const filesInPath = fileRefs.filter(f => {
+                            const filePath = f.metadata?.path || f.name;
+                            return filePath.startsWith(normalizedPath + '/');
+                        });
+                        if (filesInPath.length > 0) {
+                            if (!options.recursive) {
+                                console.error(`Error: ${normalizedPath}/ is a folder. Use --recursive to remove.`);
+                                process.exit(1);
+                            }
+                            for (const file of filesInPath) {
+                                filesToRemove.push({
+                                    id: file.id,
+                                    path: file.metadata?.path || file.name,
+                                    isFolder: false,
+                                });
+                            }
+                        }
+                        else {
+                            showNotFoundError(targetPath);
+                            process.exit(1);
+                        }
+                    }
+                }
+            }
+        }
+        // Deduplicate
+        const uniqueFiles = [...new Map(filesToRemove.map(f => [f.id, f])).values()];
+        if (uniqueFiles.length === 0) {
+            console.log('No files matched the specified pattern(s).');
+            return;
+        }
+        // Dry run - show what would be removed (impl-cli-rm-dry-run)
+        if (options.dryRun) {
+            console.log(`Would remove ${uniqueFiles.length} file${uniqueFiles.length === 1 ? '' : 's'}:`);
+            for (const file of uniqueFiles.slice(0, 20)) {
+                console.log(`  ${file.path}`);
+            }
+            if (uniqueFiles.length > 20) {
+                console.log(`  ... (${uniqueFiles.length - 20} more)`);
+            }
+            return;
+        }
+        // Confirm/force check (impl-cli-rm-confirm-force)
+        if (uniqueFiles.length > 1 && !options.force) {
+            const choice = await select(`This will remove ${uniqueFiles.length} files from the workspace. Continue?`, [
+                { label: 'Yes', value: 'yes' },
+                { label: 'No', value: 'no' },
+            ]);
+            if (choice === 'no') {
+                console.log('Cancelled.');
+                return;
+            }
+        }
+        // Remove files
+        let removed = 0;
+        let localDeleted = 0;
+        const errors = [];
+        for (const file of uniqueFiles) {
+            try {
+                await workspaceHandle.file.delete(file.id);
+                removed++;
+                if (!options.quiet) {
+                    console.log(`Removed from workspace: ${file.path}`);
+                }
+                // Local deletion (impl-cli-rm-local)
+                if (options.local) {
+                    const localPath = path.join(workspacePath, file.path);
+                    const result = await deleteLocalFile(localPath);
+                    if (result.success) {
+                        localDeleted++;
+                        if (!options.quiet) {
+                            console.log(`Deleted local file: ${file.path}`);
+                        }
+                    }
+                    else if (result.error && !options.quiet) {
+                        console.warn(`Warning: ${result.error}`);
+                    }
+                }
+            }
+            catch (error) {
+                errors.push(`Failed to remove ${file.path}: ${error.message}`);
+            }
+        }
+        // Remove empty folders if recursive
+        if (options.recursive && foldersToRemove.length > 0) {
+            for (const folder of foldersToRemove) {
+                try {
+                    await workspaceHandle.folder.delete(folder.id);
+                    if (!options.quiet) {
+                        console.log(`Removed folder: ${folder.path}/`);
+                    }
+                    if (options.local) {
+                        const localPath = path.join(workspacePath, folder.path);
+                        await deleteLocalDirectory(localPath);
+                    }
+                }
+                catch {
+                    // Folder might have other contents, ignore
+                }
+            }
+        }
+        // Summary
+        if (!options.quiet) {
+            console.log('');
+            console.log(`Removed ${removed} file${removed === 1 ? '' : 's'} from workspace.`);
+            // Workspace-only reminder (impl-cli-rm-workspace-only)
+            if (!options.local && removed > 0) {
+                console.log(`Note: Local files unchanged. Use --local to also delete locally.`);
+            }
+            else if (options.local && localDeleted > 0) {
+                console.log(`Deleted ${localDeleted} local file${localDeleted === 1 ? '' : 's'}.`);
+            }
+        }
+        if (errors.length > 0) {
+            console.error('');
+            for (const error of errors) {
+                console.error(error);
+            }
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error('Error removing files:', error.message);
+        process.exit(1);
+    }
+}