@mod-computer/cli 0.2.3 → 0.2.5

package/dist/services/feature-flags.js

@@ -1,187 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-const FEATURE_DIR = '.mod';
-const FEATURE_FILE = 'feature-flags.json';
-const FLAG_LIST_ENV = 'MOD_FLAGS';
-const FEATURE_FILE_ENV = 'MOD_FEATURE_FLAGS_PATH';
-const FEATURE_DEFINITIONS = {
-    'tasks-panel': {
-        description: 'Enable the Tasks view in the interactive TUI (/tasks).',
-        defaultValue: true,
-    },
-    'directory-view': {
-        description: 'Enable the project file browser (/files).',
-        defaultValue: true,
-    },
-    'background-watch': {
-        description: 'Allow automatic workspace file watching & background sync.',
-        defaultValue: true,
-    },
-    'agents-run-command': {
-        description: 'Expose the experimental agents-run command.',
-        defaultValue: true,
-    },
-    'full-ui': {
-        description: 'Enable full CLI functionality beyond alpha-safe commands.',
-        defaultValue: false,
-    },
-};
-const FLAG_KEYS = Object.keys(FEATURE_DEFINITIONS);
-let cachedFlags = null;
-const TRUE_VALUES = new Set(['1', 'true', 'yes', 'on', 'enable', 'enabled']);
-const FALSE_VALUES = new Set(['0', 'false', 'no', 'off', 'disable', 'disabled']);
-function canonicalizeFlagName(name) {
-    if (!name)
-        return null;
-    const normalized = name
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/^-+/, '')
-        .replace(/-+$/, '');
-    return (FLAG_KEYS.find(flag => flag === normalized) ?? null);
-}
-function parseBoolean(value) {
-    if (typeof value === 'boolean')
-        return value;
-    if (typeof value === 'number')
-        return value !== 0;
-    if (typeof value === 'string') {
-        const normalized = value.trim().toLowerCase();
-        if (TRUE_VALUES.has(normalized))
-            return true;
-        if (FALSE_VALUES.has(normalized))
-            return false;
-    }
-    return undefined;
-}
-function getFeatureFlagsFilePath() {
-    const overridePath = process.env[FEATURE_FILE_ENV];
-    if (overridePath && overridePath.trim().length > 0) {
-        return path.resolve(overridePath.trim());
-    }
-    return path.join(process.cwd(), FEATURE_DIR, FEATURE_FILE);
-}
-function getPackageLocalConfigPath() {
-    try {
-        const __filename = new URL(import.meta.url).pathname;
-        const __dirname = path.dirname(__filename);
-        // From dist/services -> ../config/feature-flags.json
-        return path.join(__dirname, '../../config/feature-flags.json');
-    }
-    catch {
-        return '';
-    }
-}
-function parseConfigFile(filePath) {
-    if (!fs.existsSync(filePath))
-        return {};
-    try {
-        const raw = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-        const overrides = {};
-        for (const [name, value] of Object.entries(raw)) {
-            const key = canonicalizeFlagName(name);
-            if (!key)
-                continue;
-            if (typeof value === 'boolean') {
-                overrides[key] = value;
-            }
-            else if (typeof value === 'string') {
-                const parsed = parseBoolean(value);
-                if (typeof parsed === 'boolean')
-                    overrides[key] = parsed;
-            }
-        }
-        return overrides;
-    }
-    catch {
-        return {};
-    }
-}
-function readJsonOverrides() {
-    const globalOverrides = parseConfigFile(getFeatureFlagsFilePath());
-    const packageOverrides = parseConfigFile(getPackageLocalConfigPath());
-    // Package-local overrides take precedence over global ones
-    return { ...globalOverrides, ...packageOverrides };
-}
-function parseListEnvOverrides() {
-    const value = process.env[FLAG_LIST_ENV];
-    if (!value)
-        return {};
-    const overrides = {};
-    const tokens = value.split(/[, ]+/g).map(token => token.trim()).filter(Boolean);
-    for (const token of tokens) {
-        let enabled = true;
-        let name = token;
-        if (name.startsWith('!') || name.startsWith('-')) {
-            enabled = false;
-            name = name.slice(1);
-        }
-        else if (name.startsWith('+')) {
-            name = name.slice(1);
-        }
-        const key = canonicalizeFlagName(name);
-        if (key)
-            overrides[key] = enabled;
-    }
-    return overrides;
-}
-function parsePerFlagEnvOverrides() {
-    const overrides = {};
-    for (const key of FLAG_KEYS) {
-        const envName = `MOD_FLAG_${key.replace(/[^A-Z0-9]/gi, '_').toUpperCase()}`;
-        const raw = process.env[envName];
-        const parsed = parseBoolean(raw);
-        if (typeof parsed === 'boolean') {
-            overrides[key] = parsed;
-        }
-    }
-    const fullUiEnv = process.env['MOD_CLI_FULL_UI'];
-    const fullUiParsed = parseBoolean(fullUiEnv);
-    if (typeof fullUiParsed === 'boolean') {
-        overrides['full-ui'] = fullUiParsed;
-    }
-    return overrides;
-}
-function buildFlags() {
-    const overrides = {
-        ...readJsonOverrides(),
-        ...parseListEnvOverrides(),
-        ...parsePerFlagEnvOverrides(),
-    };
-    const resolved = {};
-    for (const key of FLAG_KEYS) {
-        resolved[key] = overrides[key] ?? FEATURE_DEFINITIONS[key].defaultValue;
-    }
-    return resolved;
-}
-export function getFeatureFlags(options) {
-    if (!cachedFlags || options?.refresh) {
-        cachedFlags = buildFlags();
-    }
-    return cachedFlags;
-}
-export function isFeatureEnabled(flag) {
-    return getFeatureFlags()[flag];
-}
-export function describeFeatureFlags() {
-    const flags = getFeatureFlags();
-    return FLAG_KEYS.map(key => ({
-        key,
-        description: FEATURE_DEFINITIONS[key].description,
-        defaultValue: FEATURE_DEFINITIONS[key].defaultValue,
-        enabled: flags[key],
-    }));
-}
-export function shouldEnableBackgroundWatch() {
-    const env = process.env.MOD_CLI_AUTO_WATCH;
-    if (env === '1')
-        return true;
-    if (env === '0')
-        return false;
-    return isFeatureEnabled('background-watch');
-}
-export function shouldExposeFullUi() {
-    return isFeatureEnabled('full-ui');
-}
-export const FEATURE_FLAGS_FILE_NAME = FEATURE_FILE;

package/dist/services/file-import-service.js

@@ -1,283 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import crypto from 'crypto';
-import { createModWorkspace } from '@mod/mod-core/mod-workspace';
-import { detectMimeType, mimeTypeToCanvasType } from '@mod/mod-core';
-import { ModIgnoreService } from './modignore-service.js';
-import { readModConfig } from './mod-config.js';
-export class FileImportService {
-    constructor(repo) {
-        this.folderCache = new Map(); // path -> folderId
-        this.repo = repo;
-    }
-    async previewImport(options = {}) {
-        console.log('🔍 Scanning for importable files...');
-        const workingDir = options.workingDirectory || process.cwd();
-        const preview = await this.scanFiles(workingDir, options);
-        console.log('\n📋 Import Preview:');
-        console.log(`   Total files scanned: ${preview.totalFilesScanned}`);
-        console.log(`   Files to import: ${preview.filteredFiles.length}`);
-        console.log(`   Files excluded: ${preview.excludedFiles.length}`);
-        console.log(`   Estimated size: ${this.formatBytes(preview.estimatedSize)}`);
-        console.log(`   Estimated time: ${preview.estimatedDuration}ms`);
-        if (options.verbose) {
-            console.log('\n📁 Files to import:');
-            preview.filteredFiles.slice(0, 20).forEach(file => {
-                console.log(`     ${file}`);
-            });
-            if (preview.filteredFiles.length > 20) {
-                console.log(`     ... and ${preview.filteredFiles.length - 20} more files`);
-            }
-        }
-        return preview;
-    }
-    async promptImport(options = {}) {
-        const preview = await this.previewImport(options);
-        if (preview.filteredFiles.length === 0) {
-            console.log('❌ No files found to import');
-            return false;
-        }
-        // Simple confirmation for now - could enhance with readline interface
-        console.log('\n❓ Proceed with import? (This will create documents in your workspace)');
-        console.log('   Type "y" to continue or any other key to cancel...');
-        // For CLI implementation, we'll return true for now
-        // In a full implementation, this would use readline to get user input
-        return true;
-    }
-    async executeImport(options = {}) {
-        const startTime = Date.now();
-        const workingDir = options.workingDirectory || process.cwd();
-        const batchSize = options.batchSize || 50;
-        console.log('🚀 Starting file import...');
-        // Clear folder cache for fresh import
-        this.folderCache.clear();
-        const config = readModConfig();
-        if (!config || !config.workspaceId) {
-            throw new Error('No active workspace configured. Run `mod workspace create <name>` first.');
-        }
-        const modWorkspace = createModWorkspace(this.repo);
-        const workspaceHandle = await modWorkspace.openWorkspace(config.workspaceId);
-        const preview = await this.scanFiles(workingDir, options);
-        const result = {
-            importedFiles: [],
-            skippedFiles: [],
-            errors: [],
-            totalDuration: 0
-        };
-        const batches = this.chunkArray(preview.filteredFiles, batchSize);
-        for (let i = 0; i < batches.length; i++) {
-            const batch = batches[i];
-            console.log(`📦 Processing batch ${i + 1}/${batches.length} (${batch.length} files)...`);
-            await Promise.all(batch.map(async (filePath) => {
-                try {
-                    await this.importFile(filePath, workspaceHandle, workingDir);
-                    result.importedFiles.push(filePath);
-                    if (options.verbose) {
-                        console.log(`   ✓ ${filePath}`);
-                    }
-                }
-                catch (error) {
-                    result.errors.push({
-                        file: filePath,
-                        error: error instanceof Error ? error.message : String(error)
-                    });
-                    if (options.verbose) {
-                        console.log(`   ❌ ${filePath}: ${error}`);
-                    }
-                }
-            }));
-            // Small delay between batches to prevent overwhelming the system
-            if (i < batches.length - 1) {
-                await new Promise(resolve => setTimeout(resolve, 100));
-            }
-        }
-        result.totalDuration = Date.now() - startTime;
-        console.log('\n✅ Import complete!');
-        console.log(`   Imported: ${result.importedFiles.length} files`);
-        console.log(`   Skipped: ${result.skippedFiles.length} files`);
-        console.log(`   Errors: ${result.errors.length} files`);
-        console.log(`   Duration: ${result.totalDuration}ms`);
-        if (result.errors.length > 0) {
-            console.log('\n❌ Errors occurred:');
-            result.errors.slice(0, 5).forEach(error => {
-                console.log(`     ${error.file}: ${error.error}`);
-            });
-            if (result.errors.length > 5) {
-                console.log(`     ... and ${result.errors.length - 5} more errors`);
-            }
-        }
-        return result;
-    }
-    async scanFiles(workingDir, options) {
-        this.modIgnoreService = new ModIgnoreService(workingDir);
-        const scannedFiles = [];
-        const filteredFiles = [];
-        const excludedFiles = [];
-        let totalSize = 0;
-        await this.scanDirectory(workingDir, workingDir, scannedFiles, filteredFiles, excludedFiles, options);
-        // Calculate size estimates
-        for (const file of filteredFiles) {
-            try {
-                const stats = await fs.promises.stat(file);
-                totalSize += stats.size;
-            }
-            catch (error) {
-                // File might have been deleted during scan, skip
-            }
-        }
-        return {
-            totalFilesScanned: scannedFiles.length,
-            filteredFiles,
-            excludedFiles,
-            estimatedSize: totalSize,
-            estimatedDuration: filteredFiles.length * 10 // Rough estimate: 10ms per file
-        };
-    }
-    async scanDirectory(rootDir, currentDir, scannedFiles, filteredFiles, excludedFiles, options) {
-        try {
-            const entries = await fs.promises.readdir(currentDir, { withFileTypes: true });
-            for (const entry of entries) {
-                const fullPath = path.join(currentDir, entry.name);
-                const relativePath = path.relative(rootDir, fullPath);
-                if (entry.isDirectory()) {
-                    // Check if directory should be excluded
-                    if (this.modIgnoreService?.shouldIgnore(fullPath, rootDir)) {
-                        excludedFiles.push(relativePath);
-                        continue;
-                    }
-                    // Recurse into directory
-                    await this.scanDirectory(rootDir, fullPath, scannedFiles, filteredFiles, excludedFiles, options);
-                }
-                else if (entry.isFile()) {
-                    scannedFiles.push(relativePath);
-                    // Check if file should be excluded
-                    if (this.modIgnoreService?.shouldIgnore(fullPath, rootDir)) {
-                        excludedFiles.push(relativePath);
-                        continue;
-                    }
-                    // Check file extension filter
-                    if (this.isTrackableFile(fullPath)) {
-                        // Apply pattern filters if specified
-                        if (options.patterns && options.patterns.length > 0) {
-                            const matches = options.patterns.some(pattern => relativePath.includes(pattern) || fullPath.includes(pattern));
-                            if (!matches) {
-                                excludedFiles.push(relativePath);
-                                continue;
-                            }
-                        }
-                        filteredFiles.push(fullPath);
-                    }
-                    else {
-                        excludedFiles.push(relativePath);
-                    }
-                }
-            }
-        }
-        catch (error) {
-            // Directory might not be accessible, skip
-        }
-    }
-    isTrackableFile(filePath) {
-        const ext = path.extname(filePath).toLowerCase();
-        const trackableExtensions = [
-            '.md', '.txt', '.js', '.ts', '.jsx', '.tsx', '.json', '.yaml', '.yml',
-            '.py', '.java', '.cpp', '.c', '.h', '.css', '.scss', '.html', '.xml',
-            '.sql', '.go', '.rs', '.php', '.rb', '.swift', '.kt', '.scala', '.sh',
-            '.ps1', '.dockerfile', '.tf', '.hcl', '.vue', '.svelte', '.astro'
-        ];
-        return trackableExtensions.includes(ext);
-    }
-    async importFile(filePath, workspaceHandle, workingDir) {
-        try {
-            const content = await fs.promises.readFile(filePath, 'utf-8');
-            const relativePath = path.relative(workingDir, filePath);
-            const contentHash = crypto.createHash('sha256').update(content).digest('hex');
-            // Parse directory structure to create hierarchical folders
-            const pathParts = relativePath.split(path.sep);
-            const fileName = pathParts.pop();
-            const dirPath = pathParts.join('/');
-            let folderId = null;
-            // Create folder hierarchy if the file is in a subdirectory
-            if (dirPath) {
-                folderId = await this.ensureFolderHierarchy(dirPath, workspaceHandle);
-            }
-            // Create document via workspace handle with proper folder association
-            const ext = path.extname(fileName).toLowerCase();
-            const mimeType = this.getMimeTypeForExtension(ext);
-            const canvasType = mimeTypeToCanvasType(mimeType);
-            const documentData = {
-                text: content,
-                metadata: {
-                    type: canvasType, // Required for workspace container routing
-                    originalFilename: fileName,
-                    tags: [`imported:${new Date().toISOString()}`, `hash:${contentHash}`],
-                    typeData: {
-                        originalPath: filePath,
-                        relativePath,
-                        contentHash
-                    }
-                }
-            };
-            const fileDoc = await workspaceHandle.file.create(documentData, {
-                name: fileName, // Use just the filename, not the full path
-                mimeType,
-                folderId: folderId, // Associate with the appropriate folder (cast to handle DocumentId type)
-            });
-            // This should be handled automatically by the workspace handle
-        }
-        catch (error) {
-            throw new Error(`Failed to import ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    async ensureFolderHierarchy(dirPath, workspaceHandle) {
-        // Check cache first to avoid creating duplicate folders
-        if (this.folderCache.has(dirPath)) {
-            return this.folderCache.get(dirPath);
-        }
-        const pathParts = dirPath.split('/').filter(Boolean);
-        let currentPath = '';
-        let parentFolderId = null;
-        // Create folders hierarchically from root to deepest level
-        for (const folderName of pathParts) {
-            currentPath = currentPath ? `${currentPath}/${folderName}` : folderName;
-            if (this.folderCache.has(currentPath)) {
-                parentFolderId = this.folderCache.get(currentPath);
-                continue;
-            }
-            // Create folder using workspace handle - we'll use the folder path approach
-            // since the workspace handle doesn't expose the direct service createFolder method
-            const folderRef = await workspaceHandle.folder.create(currentPath, {
-                name: folderName,
-                metadata: {
-                    type: 'folder',
-                    path: currentPath,
-                    createdAt: new Date().toISOString()
-                }
-            });
-            // Cache the folder ID for reuse
-            this.folderCache.set(currentPath, folderRef.id);
-            parentFolderId = folderRef.id;
-        }
-        return parentFolderId;
-    }
-    chunkArray(array, chunkSize) {
-        const chunks = [];
-        for (let i = 0; i < array.length; i += chunkSize) {
-            chunks.push(array.slice(i, i + chunkSize));
-        }
-        return chunks;
-    }
-    getMimeTypeForExtension(ext) {
-        // Use centralized MIME type detection from mod-core
-        const fileName = `file${ext}`;
-        return detectMimeType(fileName);
-    }
-    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];
-    }
-}

package/dist/services/file-transformation-service.js

@@ -1,218 +0,0 @@
-import path from 'path';
-export class FileTransformationService {
-    constructor() {
-        this.languageExtensionMap = {
-            // JavaScript/TypeScript
-            javascript: '.js',
-            typescript: '.ts',
-            tsx: '.tsx',
-            jsx: '.jsx',
-            // Python
-            python: '.py',
-            // Java/Kotlin/Scala
-            java: '.java',
-            kotlin: '.kt',
-            scala: '.scala',
-            // C/C++
-            c: '.c',
-            cpp: '.cpp',
-            'c++': '.cpp',
-            cc: '.cc',
-            cxx: '.cxx',
-            // C#
-            csharp: '.cs',
-            'c#': '.cs',
-            // Go
-            go: '.go',
-            golang: '.go',
-            // Rust
-            rust: '.rs',
-            // PHP
-            php: '.php',
-            // Ruby
-            ruby: '.rb',
-            // Swift
-            swift: '.swift',
-            // Dart
-            dart: '.dart',
-            // Shell/Bash
-            shell: '.sh',
-            bash: '.sh',
-            zsh: '.zsh',
-            fish: '.fish',
-            // Web technologies
-            html: '.html',
-            css: '.css',
-            scss: '.scss',
-            sass: '.sass',
-            less: '.less',
-            // Config/Data
-            json: '.json',
-            yaml: '.yml',
-            yml: '.yml',
-            toml: '.toml',
-            xml: '.xml',
-            // SQL
-            sql: '.sql',
-            mysql: '.sql',
-            postgresql: '.sql',
-            sqlite: '.sql',
-            // Other
-            dockerfile: 'Dockerfile',
-            makefile: 'Makefile',
-            r: '.r',
-            matlab: '.m',
-            lua: '.lua',
-            perl: '.pl',
-            // Assembly
-            assembly: '.asm',
-            asm: '.asm',
-            // Functional languages
-            haskell: '.hs',
-            clojure: '.clj',
-            erlang: '.erl',
-            elixir: '.ex',
-            ocaml: '.ml',
-            fsharp: '.fs',
-            // Other popular languages
-            groovy: '.groovy',
-            powershell: '.ps1',
-            vim: '.vim',
-            // Markup
-            markdown: '.md',
-            tex: '.tex',
-            latex: '.tex',
-        };
-    }
-    /**
-     * Transform a file based on its metadata
-     */
-    transformFile(originalFileName, content, metadata) {
-        const result = {
-            fileName: originalFileName,
-            content,
-            transformed: false,
-            originalType: metadata.type,
-        };
-        if (metadata.type === 'text') {
-            // Transform text files to markdown
-            result.fileName = this.ensureExtension(originalFileName, '.md');
-            result.transformed = result.fileName !== originalFileName;
-            result.targetType = 'markdown';
-        }
-        else if (metadata.type === 'code') {
-            // Transform code files based on language
-            const language = this.detectLanguage(metadata, originalFileName);
-            if (language) {
-                const extension = this.languageExtensionMap[language.toLowerCase()];
-                if (extension) {
-                    result.fileName = this.replaceExtension(originalFileName, extension);
-                    result.transformed = result.fileName !== originalFileName;
-                    result.targetType = `code (${language})`;
-                }
-            }
-            // If no language detected or mapped, default to .txt
-            if (!result.transformed) {
-                result.fileName = this.ensureExtension(originalFileName, '.txt');
-                result.transformed = result.fileName !== originalFileName;
-                result.targetType = 'text (unknown language)';
-            }
-        }
-        return result;
-    }
-    /**
-     * Detect the programming language from metadata or filename
-     */
-    detectLanguage(metadata, fileName) {
-        // First, check metadata for explicit language
-        if (metadata.language) {
-            return metadata.language;
-        }
-        // Try to infer from filename extension
-        const ext = path.extname(fileName).toLowerCase();
-        const extToLanguage = {
-            '.js': 'javascript',
-            '.ts': 'typescript',
-            '.tsx': 'tsx',
-            '.jsx': 'jsx',
-            '.py': 'python',
-            '.java': 'java',
-            '.kt': 'kotlin',
-            '.scala': 'scala',
-            '.c': 'c',
-            '.cpp': 'cpp',
-            '.cc': 'cpp',
-            '.cxx': 'cpp',
-            '.cs': 'csharp',
-            '.go': 'go',
-            '.rs': 'rust',
-            '.php': 'php',
-            '.rb': 'ruby',
-            '.swift': 'swift',
-            '.dart': 'dart',
-            '.sh': 'shell',
-            '.bash': 'bash',
-            '.zsh': 'zsh',
-            '.fish': 'fish',
-            '.html': 'html',
-            '.css': 'css',
-            '.scss': 'scss',
-            '.sass': 'sass',
-            '.less': 'less',
-            '.json': 'json',
-            '.yml': 'yaml',
-            '.yaml': 'yaml',
-            '.toml': 'toml',
-            '.xml': 'xml',
-            '.sql': 'sql',
-            '.r': 'r',
-            '.m': 'matlab',
-            '.lua': 'lua',
-            '.pl': 'perl',
-            '.asm': 'assembly',
-            '.hs': 'haskell',
-            '.clj': 'clojure',
-            '.erl': 'erlang',
-            '.ex': 'elixir',
-            '.ml': 'ocaml',
-            '.fs': 'fsharp',
-            '.groovy': 'groovy',
-            '.ps1': 'powershell',
-            '.vim': 'vim',
-            '.md': 'markdown',
-            '.tex': 'latex',
-        };
-        return extToLanguage[ext] || null;
-    }
-    /**
-     * Ensure a filename has a specific extension
-     */
-    ensureExtension(fileName, extension) {
-        const currentExt = path.extname(fileName);
-        if (currentExt === extension) {
-            return fileName;
-        }
-        const baseName = currentExt ? fileName.slice(0, -currentExt.length) : fileName;
-        return baseName + extension;
-    }
-    /**
-     * Replace the extension of a filename
-     */
-    replaceExtension(fileName, newExtension) {
-        const currentExt = path.extname(fileName);
-        const baseName = currentExt ? fileName.slice(0, -currentExt.length) : fileName;
-        return baseName + newExtension;
-    }
-    /**
-     * Get the mapping of languages to extensions (for documentation/debugging)
-     */
-    getLanguageExtensionMap() {
-        return { ...this.languageExtensionMap };
-    }
-    /**
-     * Add or update a language extension mapping
-     */
-    setLanguageExtension(language, extension) {
-        this.languageExtensionMap[language.toLowerCase()] = extension;
-    }
-}