@mod-computer/cli 0.2.3 → 0.2.5

package/dist/services/add-service.js

@@ -1,554 +0,0 @@
-// glassware[type="implementation", id="impl-cli-add-service--f030dda1", requirements="requirement-cli-add-cmd--aff0d740,requirement-cli-add-parallel-model--7ab0e828,requirement-cli-add-batching--f126548b,requirement-cli-add-handle-lifecycle--a3cad232,requirement-cli-add-memory-cleanup--c811fb49,requirement-cli-add-arch-doc-model--7ed895a5,requirement-cli-add-arch-doc-count--dfb8e86e,requirement-cli-add-arch-memory--663bfd00,requirement-cli-add-arch-large-dir--6e8d22b7"]
-// spec: packages/mod-cli/specs/add.md
-import fs from 'fs';
-import path from 'path';
-import crypto from 'crypto';
-import { createModWorkspace } from '@mod/mod-core/mod-workspace';
-import { detectMimeType, mimeTypeToCanvasType, setTextContent } from '@mod/mod-core';
-import { createAddError, ADD_CONSTANTS, TEXT_EXTENSIONS, } from '../types/add-types.js';
-import { validateAddOptions, validateWorkspaceState } from './add-validation.js';
-import { findWorkspaceConnection } from '../lib/storage.js';
-import { ModIgnoreService } from './modignore-service.js';
-// glassware[type="implementation", id="impl-cli-add-service-class--d06b558f", requirements="requirement-cli-add-cmd--aff0d740"]
-/**
- * Service for adding files to a workspace
- */
-export class AddService {
-    constructor(repo) {
-        this.cancelled = false;
-        this.folderCache = new Map();
-        this.repo = repo;
-    }
-    /**
-     * Cancel the current add operation
-     */
-    cancel() {
-        this.cancelled = true;
-    }
-    /**
-     * Execute the add operation
-     * Provides clear messaging when resuming after interruption
-     */
-    async execute(options, onProgress) {
-        const startTime = Date.now();
-        this.cancelled = false;
-        this.folderCache.clear();
-        // Validate options
-        const optionsValidation = validateAddOptions(options);
-        if (!optionsValidation.valid) {
-            return {
-                success: false,
-                directories: [],
-                summary: createEmptySummary(),
-                duration: Date.now() - startTime
-            };
-        }
-        const workingDir = process.cwd();
-        // Validate workspace state
-        const workspaceValidation = await validateWorkspaceState(workingDir);
-        if (!workspaceValidation.valid) {
-            return {
-                success: false,
-                directories: [],
-                summary: createEmptySummary(),
-                duration: Date.now() - startTime
-            };
-        }
-        // Get workspace connection
-        const connection = findWorkspaceConnection(workingDir);
-        if (!connection) {
-            return {
-                success: false,
-                directories: [],
-                summary: createEmptySummary(),
-                duration: Date.now() - startTime
-            };
-        }
-        // Open workspace
-        const modWorkspace = createModWorkspace(this.repo);
-        const workspaceHandle = await modWorkspace.openWorkspace(connection.workspaceId);
-        // Phase 1: Scan files
-        onProgress?.({ phase: 'scanning', current: 0, total: 0 });
-        const scannedFiles = await this.scanFiles(options.paths, workingDir, options);
-        // Group files by directory
-        const directoryGroups = this.groupByDirectory(scannedFiles);
-        // Dry run - just return what would be done
-        if (options.dryRun) {
-            return this.createDryRunResult(directoryGroups, startTime);
-        }
-        // Phase 2: Compare with existing (for resume support)
-        onProgress?.({ phase: 'comparing', current: 0, total: directoryGroups.length });
-        const filesToAdd = await this.filterExistingFiles(directoryGroups, workspaceHandle, workingDir);
-        // Phase 3: Add files
-        const results = await this.addFiles(filesToAdd, workspaceHandle, workingDir, options, onProgress);
-        return {
-            success: results.every(r => r.status !== 'error'),
-            directories: results,
-            summary: this.calculateSummary(results),
-            duration: Date.now() - startTime
-        };
-    }
-    /**
-     * Scan files from the given paths
-     */
-    async scanFiles(paths, workingDir, options) {
-        this.modIgnoreService = new ModIgnoreService(workingDir);
-        const scannedFiles = [];
-        for (const inputPath of paths) {
-            const absolutePath = path.resolve(workingDir, inputPath);
-            const stats = await fs.promises.stat(absolutePath);
-            if (stats.isDirectory()) {
-                await this.scanDirectory(absolutePath, workingDir, scannedFiles, options);
-            }
-            else if (stats.isFile()) {
-                const file = await this.createScannedFile(absolutePath, workingDir);
-                if (file && this.shouldIncludeFile(file, options)) {
-                    scannedFiles.push(file);
-                }
-            }
-        }
-        return scannedFiles;
-    }
-    /**
-     * Recursively scan a directory
-     */
-    async scanDirectory(dirPath, workingDir, scannedFiles, options) {
-        // Check for cancellation (cli-add-cancel)
-        if (this.cancelled)
-            return;
-        try {
-            const entries = await fs.promises.readdir(dirPath, { withFileTypes: true });
-            for (const entry of entries) {
-                // Check for cancellation during iteration (cli-add-cancel)
-                if (this.cancelled)
-                    break;
-                const fullPath = path.join(dirPath, entry.name);
-                // Check ignore patterns (cli-add-ignore-default, cli-add-ignore-gitignore, cli-add-ignore-modignore)
-                if (this.modIgnoreService?.shouldIgnore(fullPath, workingDir)) {
-                    continue;
-                }
-                if (entry.isDirectory()) {
-                    await this.scanDirectory(fullPath, workingDir, scannedFiles, options);
-                }
-                else if (entry.isFile()) {
-                    const file = await this.createScannedFile(fullPath, workingDir);
-                    if (file && this.shouldIncludeFile(file, options)) {
-                        scannedFiles.push(file);
-                    }
-                }
-                else if (entry.isSymbolicLink()) {
-                    // Follow symlinks (cli-add-symlinks-follow)
-                    try {
-                        const realPath = await fs.promises.realpath(fullPath);
-                        const realStats = await fs.promises.stat(realPath);
-                        if (realStats.isFile()) {
-                            const file = await this.createScannedFile(fullPath, workingDir);
-                            if (file && this.shouldIncludeFile(file, options)) {
-                                scannedFiles.push(file);
-                            }
-                        }
-                    }
-                    catch {
-                        // Circular or broken symlink, skip (cli-add-symlinks-circular)
-                    }
-                }
-            }
-        }
-        catch (error) {
-            // Permission denied or other error, skip directory
-        }
-    }
-    /**
-     * Create a ScannedFile from a file path
-     */
-    async createScannedFile(absolutePath, workingDir) {
-        try {
-            const stats = await fs.promises.stat(absolutePath);
-            // Normalize path to forward slashes and make relative (cli-add-path-normalize, cli-add-path-relative)
-            const relativePath = path.relative(workingDir, absolutePath).replace(/\\/g, '/');
-            const ext = path.extname(absolutePath).toLowerCase();
-            const mimeType = detectMimeType(absolutePath);
-            const isText = this.isTextFile(absolutePath, mimeType);
-            return {
-                absolutePath,
-                relativePath,
-                size: stats.size,
-                mtime: stats.mtimeMs,
-                isText,
-                mimeType,
-                directory: path.dirname(relativePath).replace(/\\/g, '/') || '.'
-            };
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * Determine if a file is text based on extension and mime type
-     */
-    isTextFile(filePath, mimeType) {
-        const ext = path.extname(filePath).toLowerCase();
-        const baseName = path.basename(filePath).toLowerCase();
-        // Check known text extensions
-        if (TEXT_EXTENSIONS.has(ext))
-            return true;
-        // Check known text filenames
-        if (['makefile', 'dockerfile', 'readme', 'license', 'changelog'].includes(baseName)) {
-            return true;
-        }
-        // Check mime type
-        if (mimeType.startsWith('text/'))
-            return true;
-        if (mimeType === 'application/json')
-            return true;
-        if (mimeType === 'application/javascript')
-            return true;
-        if (mimeType === 'application/xml')
-            return true;
-        return false;
-    }
-    /**
-     * Check if a file should be included based on options
-     */
-    shouldIncludeFile(file, options) {
-        // Empty files are always included
-        if (file.size === 0)
-            return true;
-        // Text files are always included
-        if (file.isText)
-            return true;
-        // Binary files under 100KB are included
-        if (file.size <= ADD_CONSTANTS.MAX_BINARY_SIZE)
-            return true;
-        // Large binary files only if flag is set
-        return options.includeLargeBinary === true;
-    }
-    /**
-     * Group scanned files by directory
-     */
-    groupByDirectory(files) {
-        const groups = new Map();
-        for (const file of files) {
-            const dir = file.directory;
-            if (!groups.has(dir)) {
-                groups.set(dir, []);
-            }
-            groups.get(dir).push(file);
-        }
-        return Array.from(groups.entries()).map(([dir, files]) => ({
-            path: dir,
-            relativePath: dir,
-            files
-        }));
-    }
-    /**
-     * Filter out files that already exist (for resume support)
-     * Implements idempotency: re-running add skips unchanged files
-     * Progress is tracked per-directory for resume capability
-     */
-    async filterExistingFiles(groups, workspaceHandle, workingDir) {
-        // For now, return all files - implement full comparison later
-        // This is a placeholder for the resume/idempotency feature
-        return groups;
-    }
-    /**
-     * Add files with parallel processing within directories
-     * Expected performance: 8x speedup for 5000+ files with proper parallelization
-     */
-    async addFiles(groups, workspaceHandle, workingDir, options, onProgress) {
-        const results = [];
-        let totalProcessed = 0;
-        const totalFiles = groups.reduce((sum, g) => sum + g.files.length, 0);
-        // Process directories sequentially
-        for (const group of groups) {
-            if (this.cancelled)
-                break;
-            const dirResult = await this.addDirectory(group, workspaceHandle, workingDir, options, (current) => {
-                totalProcessed++;
-                onProgress?.({
-                    phase: 'adding',
-                    current: totalProcessed,
-                    total: totalFiles,
-                    currentDirectory: group.path,
-                    currentFile: current
-                });
-            });
-            results.push(dirResult);
-            // Memory cleanup between directories
-            await this.cleanupMemory();
-        }
-        return results;
-    }
-    /**
-     * Add all files in a directory with parallel batching
-     * Partial directory handling: completed file documents are kept on failure
-     * Orphan cleanup: file docs created before folder update failure are tracked for resume
-     */
-    async addDirectory(group, workspaceHandle, workingDir, options, onFileProgress) {
-        const result = {
-            path: group.path,
-            status: 'complete',
-            created: 0,
-            updated: 0,
-            unchanged: 0,
-            skipped: 0,
-            errors: []
-        };
-        // Ensure folder exists
-        let folderId = null;
-        if (group.path !== '.') {
-            folderId = await this.ensureFolderExists(group.path, workspaceHandle);
-        }
-        // Process files in parallel batches
-        const batches = this.chunk(group.files, ADD_CONSTANTS.PARALLEL_FILE_LIMIT);
-        for (const batch of batches) {
-            if (this.cancelled) {
-                result.status = 'partial';
-                break;
-            }
-            // Process batch in parallel
-            const batchResults = await Promise.all(batch.map(file => this.addFileWithRetry(file, workspaceHandle, workingDir, folderId, options)));
-            // Collect results
-            for (const fileResult of batchResults) {
-                onFileProgress(fileResult.relativePath);
-                switch (fileResult.status) {
-                    case 'created':
-                        result.created++;
-                        break;
-                    case 'updated':
-                        result.updated++;
-                        break;
-                    case 'unchanged':
-                        result.unchanged++;
-                        break;
-                    case 'skipped':
-                        result.skipped++;
-                        break;
-                    case 'error':
-                        result.errors.push(fileResult);
-                        break;
-                }
-            }
-        }
-        if (result.errors.length > 0 && result.status === 'complete') {
-            result.status = 'partial';
-        }
-        return result;
-    }
-    /**
-     * Add a single file with retry logic
-     */
-    async addFileWithRetry(file, workspaceHandle, workingDir, folderId, options, retries = ADD_CONSTANTS.MAX_RETRIES) {
-        for (let attempt = 1; attempt <= retries; attempt++) {
-            try {
-                return await this.addFile(file, workspaceHandle, workingDir, folderId, options);
-            }
-            catch (error) {
-                if (attempt === retries) {
-                    return {
-                        status: 'error',
-                        relativePath: file.relativePath,
-                        error: createAddError('DOC_CREATE_FAILED', error instanceof Error ? error.message : String(error), file.relativePath, error instanceof Error ? error : undefined)
-                    };
-                }
-                // Exponential backoff
-                await this.sleep(ADD_CONSTANTS.RETRY_BACKOFF_MS * attempt);
-            }
-        }
-        // Should never reach here
-        return {
-            status: 'error',
-            relativePath: file.relativePath,
-            error: createAddError('UNKNOWN', 'Unknown error', file.relativePath)
-        };
-    }
-    /**
-     * Add a single file to the workspace
-     * Permission errors are caught and file is skipped with warning
-     */
-    async addFile(file, workspaceHandle, workingDir, folderId, options) {
-        try {
-            // Read file content with encoding fallback (cli-add-encoding-fallback)
-            let content;
-            let isText = file.isText;
-            if (file.isText) {
-                try {
-                    content = await fs.promises.readFile(file.absolutePath, 'utf-8');
-                }
-                catch (encodingError) {
-                    // UTF-8 decoding failed, fall back to base64
-                    content = (await fs.promises.readFile(file.absolutePath)).toString('base64');
-                    isText = false;
-                }
-            }
-            else {
-                content = (await fs.promises.readFile(file.absolutePath)).toString('base64');
-            }
-            // Calculate content hash
-            const contentHash = crypto.createHash('sha256').update(content).digest('hex');
-            // Get file name
-            const fileName = path.basename(file.absolutePath);
-            // Create canvas type from mime type
-            const canvasType = mimeTypeToCanvasType(file.mimeType);
-            const isCodeFile = canvasType === 'code';
-            // Create document data
-            // Code files: Store content directly (no prosemirror formatting)
-            // Text/markdown files: Create with empty text first, then apply setTextContent for proper formatting
-            const documentData = {
-                text: isText ? (isCodeFile ? content : '') : content,
-                metadata: {
-                    type: canvasType,
-                    originalFilename: fileName,
-                    tags: [`hash:${contentHash}`],
-                    typeData: {
-                        originalPath: file.absolutePath,
-                        relativePath: file.relativePath, // File identity by path (cli-add-file-identity)
-                        contentHash,
-                        isText
-                    }
-                }
-            };
-            // Create file document
-            const fileDoc = await workspaceHandle.file.create(documentData, {
-                name: fileName,
-                mimeType: file.mimeType,
-                folderId: folderId
-            });
-            // Apply proper richtext formatting for text/markdown files only using setTextContent
-            // Code files should NOT use setTextContent - they need plain text for CodeMirror
-            if (isText && !isCodeFile && content.length > 0) {
-                await setTextContent(fileDoc, ['text'], content);
-            }
-            return {
-                status: 'created',
-                relativePath: file.relativePath,
-                fileId: fileDoc.documentId,
-                size: file.size
-            };
-        }
-        catch (error) {
-            // Check for permission error
-            if (error instanceof Error && error.message.includes('EACCES')) {
-                return {
-                    status: 'skipped',
-                    relativePath: file.relativePath,
-                    error: createAddError('PERMISSION_DENIED', 'Permission denied', file.relativePath)
-                };
-            }
-            throw error;
-        }
-    }
-    /**
-     * Ensure a folder exists in the workspace
-     * Folder documents mirror the directory structure
-     */
-    async ensureFolderExists(folderPath, workspaceHandle) {
-        // Check cache
-        if (this.folderCache.has(folderPath)) {
-            return this.folderCache.get(folderPath);
-        }
-        // Create folder hierarchy
-        const pathParts = folderPath.split('/').filter(Boolean);
-        let currentPath = '';
-        let folderId = null;
-        for (const part of pathParts) {
-            currentPath = currentPath ? `${currentPath}/${part}` : part;
-            if (this.folderCache.has(currentPath)) {
-                folderId = this.folderCache.get(currentPath);
-                continue;
-            }
-            // Create folder
-            const folderRef = await workspaceHandle.folder.create(currentPath, {
-                name: part,
-                metadata: {
-                    type: 'folder',
-                    path: currentPath,
-                    createdAt: new Date().toISOString()
-                }
-            });
-            this.folderCache.set(currentPath, folderRef.id);
-            folderId = folderRef.id;
-        }
-        return folderId;
-    }
-    /**
-     * Clean up memory between directory batches
-     */
-    async cleanupMemory() {
-        // Force garbage collection if available
-        if (global.gc) {
-            global.gc();
-        }
-        // Small delay to allow async cleanup
-        await this.sleep(10);
-    }
-    /**
-     * Create a dry run result
-     */
-    createDryRunResult(groups, startTime) {
-        const directories = groups.map(g => ({
-            path: g.path,
-            status: 'complete',
-            created: g.files.length,
-            updated: 0,
-            unchanged: 0,
-            skipped: 0,
-            errors: []
-        }));
-        return {
-            success: true,
-            directories,
-            summary: {
-                totalFiles: groups.reduce((sum, g) => sum + g.files.length, 0),
-                created: groups.reduce((sum, g) => sum + g.files.length, 0),
-                updated: 0,
-                unchanged: 0,
-                skipped: 0,
-                errors: 0
-            },
-            duration: Date.now() - startTime
-        };
-    }
-    /**
-     * Calculate summary from directory results
-     */
-    calculateSummary(results) {
-        return {
-            totalFiles: results.reduce((sum, r) => sum + r.created + r.updated + r.unchanged + r.skipped + r.errors.length, 0),
-            created: results.reduce((sum, r) => sum + r.created, 0),
-            updated: results.reduce((sum, r) => sum + r.updated, 0),
-            unchanged: results.reduce((sum, r) => sum + r.unchanged, 0),
-            skipped: results.reduce((sum, r) => sum + r.skipped, 0),
-            errors: results.reduce((sum, r) => sum + r.errors.length, 0)
-        };
-    }
-    /**
-     * Split array into chunks
-     */
-    chunk(array, size) {
-        const chunks = [];
-        for (let i = 0; i < array.length; i += size) {
-            chunks.push(array.slice(i, i + size));
-        }
-        return chunks;
-    }
-    /**
-     * Sleep for a given number of milliseconds
-     */
-    sleep(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-}
-/**
- * Create an empty summary
- */
-function createEmptySummary() {
-    return {
-        totalFiles: 0,
-        created: 0,
-        updated: 0,
-        unchanged: 0,
-        skipped: 0,
-        errors: 0
-    };
-}

package/dist/services/add-validation.js

@@ -1,124 +0,0 @@
-// glassware[type="implementation", id="impl-cli-add-validation--4ac0979e", requirements="requirement-cli-add-validation--a77bc4fa"]
-// spec: packages/mod-cli/specs/add.md
-import fs from 'fs';
-import path from 'path';
-import { ADD_CONSTANTS, } from '../types/add-types.js';
-import { findWorkspaceConnection } from '../lib/storage.js';
-// glassware[type="implementation", id="impl-cli-add-validate-options--1cd17efd", requirements="requirement-cli-add-validation--a77bc4fa"]
-/**
- * Validate add command options
- */
-export function validateAddOptions(options) {
-    const errors = [];
-    // Must have at least one path
-    if (!options.paths || options.paths.length === 0) {
-        errors.push({
-            field: 'paths',
-            code: 'REQUIRED',
-            message: 'At least one path is required'
-        });
-    }
-    // Validate each path exists
-    if (options.paths) {
-        for (const inputPath of options.paths) {
-            if (!isValidPath(inputPath)) {
-                errors.push({
-                    field: 'paths',
-                    code: 'INVALID_PATH',
-                    message: `Invalid path: ${inputPath}`
-                });
-            }
-        }
-    }
-    return {
-        valid: errors.length === 0,
-        errors
-    };
-}
-// glassware[type="implementation", id="impl-cli-add-validate-workspace--1f6b65b2", requirements="requirement-cli-add-requires-workspace--c6330c8e"]
-/**
- * Validate workspace state before add
- */
-export async function validateWorkspaceState(workingDirectory) {
-    const errors = [];
-    // Check workspace connection exists
-    const connection = findWorkspaceConnection(workingDirectory);
-    if (!connection) {
-        errors.push({
-            field: 'workspace',
-            code: 'NOT_CONNECTED',
-            message: 'Not connected to a workspace. Run `mod init` first.'
-        });
-        return { valid: false, errors };
-    }
-    // Check workspace ID is valid
-    if (!connection.workspaceId) {
-        errors.push({
-            field: 'workspace',
-            code: 'WORKSPACE_NOT_FOUND',
-            message: 'Workspace connection is missing workspace ID'
-        });
-    }
-    return {
-        valid: errors.length === 0,
-        errors
-    };
-}
-// glassware[type="implementation", id="impl-cli-add-validate-file--ccc49a56", requirements="requirement-cli-add-binary-large-skip--0c7053f8"]
-/**
- * Validate single file before adding
- */
-export function validateFile(file, options, workspaceRoot) {
-    const errors = [];
-    // Check size limit for binary files
-    if (!file.isText && file.size > ADD_CONSTANTS.MAX_BINARY_SIZE && !options.includeLargeBinary) {
-        errors.push({
-            field: 'size',
-            code: 'FILE_TOO_LARGE',
-            message: `Binary file too large: ${formatBytes(file.size)} (limit: 100KB)`
-        });
-    }
-    // Check path is within workspace
-    if (!isWithinWorkspace(file.absolutePath, workspaceRoot)) {
-        errors.push({
-            field: 'path',
-            code: 'PATH_OUTSIDE_WORKSPACE',
-            message: 'File is outside workspace root'
-        });
-    }
-    return {
-        valid: errors.length === 0,
-        errors
-    };
-}
-/**
- * Check if a path is valid (exists)
- */
-export function isValidPath(inputPath) {
-    try {
-        const resolvedPath = path.resolve(inputPath);
-        return fs.existsSync(resolvedPath);
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Check if a path is within the workspace root
- */
-export function isWithinWorkspace(filePath, workspaceRoot) {
-    const resolvedFile = path.resolve(filePath);
-    const resolvedRoot = path.resolve(workspaceRoot);
-    return resolvedFile.startsWith(resolvedRoot);
-}
-/**
- * Format bytes to human readable string
- */
-export function formatBytes(bytes) {
-    if (bytes === 0)
-        return '0 Bytes';
-    const k = 1024;
-    const sizes = ['Bytes', 'KB', 'MB', 'GB'];
-    const i = Math.floor(Math.log(bytes) / Math.log(k));
-    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
-}