@mod-computer/cli 0.2.4 → 0.2.5

package/dist/commands/rm.js

@@ -1,257 +0,0 @@
-// 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);
-    }
-}

package/dist/commands/spec.js

@@ -1,386 +0,0 @@
-import { SpecificationParserService, RequirementCategory } from '@mod/mod-core';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { log } from '../services/logger.js';
-import { readModConfig } from '../services/mod-config.js';
-import { createModWorkspace } from '@mod/mod-core';
-export async function specCommand(args, repo) {
-    const subcommand = args[0] || 'status';
-    const remainingArgs = args.slice(1);
-    switch (subcommand) {
-        case 'status':
-            await specStatusCommand(remainingArgs, repo);
-            break;
-        case 'list':
-            await specListCommand(remainingArgs);
-            break;
-        default:
-            // If no valid subcommand, assume it's a spec file for status
-            await specStatusCommand([subcommand, ...remainingArgs], repo);
-    }
-}
-async function specStatusCommand(args, repo) {
-    try {
-        let specName = args[0];
-        if (!specName && repo) {
-            const activeBranchSpec = await getActiveBranchSpec(repo);
-            if (activeBranchSpec) {
-                specName = activeBranchSpec;
-                console.log(`Using active branch specification: ${specName}`);
-            }
-        }
-        if (!specName) {
-            console.error('Error: Specification file required');
-            console.error('Usage: mod spec status [spec-file]');
-            console.error('       mod spec status   (uses active branch spec if available)');
-            process.exit(1);
-        }
-        if (!specName.endsWith('.spec.md')) {
-            specName += '.spec.md';
-        }
-        const workspaceRoot = process.cwd();
-        const analysis = await analyzeSpecification(workspaceRoot, specName);
-        printTscStyleOutput(analysis);
-        process.exit(0);
-    }
-    catch (error) {
-        handleError(error, args[0]);
-    }
-}
-async function specListCommand(args) {
-    try {
-        const workspaceRoot = process.cwd();
-        const specsDir = path.join(workspaceRoot, '.mod/specs');
-        const specs = await findAllSpecifications(specsDir);
-        if (specs.length === 0) {
-            console.log('No specification files found in .mod/specs');
-            return;
-        }
-        console.log('Available specifications:\n');
-        // Group by directory
-        const grouped = new Map();
-        for (const spec of specs) {
-            const dir = path.dirname(spec);
-            if (!grouped.has(dir)) {
-                grouped.set(dir, []);
-            }
-            grouped.get(dir).push(path.basename(spec));
-        }
-        // Display grouped specs
-        for (const [dir, files] of grouped) {
-            const relDir = dir === '.' ? '' : `${dir}/`;
-            for (const file of files) {
-                console.log(`  ${relDir}${file}`);
-            }
-        }
-        console.log(`\nTotal: ${specs.length} specification files`);
-    }
-    catch (error) {
-        console.error('Failed to list specifications:', error);
-        process.exit(1);
-    }
-}
-async function getActiveBranchSpec(repo) {
-    try {
-        const cfg = readModConfig();
-        if (!cfg?.workspaceId || !cfg?.activeBranchId) {
-            return undefined;
-        }
-        const modWorkspace = createModWorkspace(repo);
-        const workspaceHandles = await modWorkspace.listWorkspaces();
-        const workspaceHandle = workspaceHandles.find(wh => wh.id === cfg.workspaceId);
-        if (!workspaceHandle)
-            return undefined;
-        const branches = await workspaceHandle.branch.list();
-        const activeBranch = branches.find(b => b.id === cfg.activeBranchId);
-        if (!activeBranch?.metadata?.linkedSpec)
-            return undefined;
-        return activeBranch.metadata.linkedSpec;
-    }
-    catch (error) {
-        log('[Spec] Failed to get active branch spec:', error);
-        return undefined;
-    }
-}
-async function analyzeSpecification(workspaceRoot, specName) {
-    const parser = new SpecificationParserService({
-        workspaceRoot,
-        specsDirectory: '.mod/specs',
-        cacheEnabled: false
-    });
-    log('[Spec] Scanning workspace for @spec traces');
-    const startTime = Date.now();
-    const traceMap = await parser.scanWorkspaceForTraces();
-    const scanTime = Date.now() - startTime;
-    log(`[Spec] Scan completed in ${scanTime}ms, found ${traceMap.size} requirement IDs`);
-    const specFilePath = await findSpecificationFile(workspaceRoot, specName);
-    const content = await fs.readFile(specFilePath, 'utf-8');
-    const parsed = await parser.parseSpecification(content, specFilePath);
-    const frontmatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n/);
-    const frontmatterOffset = frontmatterMatch ? frontmatterMatch[0].split('\n').length - 1 : 0;
-    const allRequirements = extractNestedRequirements(content, parsed.requirements, frontmatterOffset);
-    const filteredTraces = filterTracesBySpec(traceMap, specName);
-    const requirements = allRequirements.map(req => {
-        const traces = filteredTraces.get(req.id) || [];
-        const status = traces.length === 0 ? 'todo' : 'traced';
-        return {
-            requirementId: req.id,
-            category: req.category,
-            title: req.title,
-            status: status,
-            traceCount: traces.length,
-            traces: traces.map(trace => ({
-                file: path.relative(workspaceRoot, trace.filePath),
-                line: trace.lineRange.start,
-                description: trace.description
-            })),
-            hierarchyLevel: calculateHierarchyLevel(req.id),
-            lineRange: req.lineRange
-        };
-    });
-    applyHierarchicalAggregation(requirements);
-    const summary = {
-        traced: requirements.filter(r => r.status === 'traced').length,
-        todo: requirements.filter(r => r.status === 'todo').length,
-        totalTraces: requirements.reduce((sum, r) => sum + r.traceCount, 0)
-    };
-    return {
-        specFile: path.relative(workspaceRoot, specFilePath),
-        title: parsed.metadata.title,
-        requirements,
-        summary
-    };
-}
-async function findSpecificationFile(workspaceRoot, specName) {
-    const specsDir = path.join(workspaceRoot, '.mod/specs');
-    const matches = [];
-    async function searchDir(dir, relativePath = '') {
-        try {
-            const entries = await fs.readdir(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                const fullPath = path.join(dir, entry.name);
-                const relPath = path.join(relativePath, entry.name);
-                if (entry.isDirectory()) {
-                    await searchDir(fullPath, relPath);
-                }
-                else if (entry.name.endsWith('.spec.md')) {
-                    // Check exact match with path or just filename
-                    if (relPath === specName || entry.name === specName) {
-                        matches.push(fullPath);
-                    }
-                }
-            }
-        }
-        catch {
-            // Directory doesn't exist or can't be read
-        }
-    }
-    await searchDir(specsDir);
-    if (matches.length === 0) {
-        throw new Error(`Specification file "${specName}" not found in ${specsDir}`);
-    }
-    if (matches.length > 1) {
-        const errorMsg = [`Multiple specifications found with name "${specName}":`];
-        const sortedPaths = matches.map(m => path.relative(specsDir, m)).sort();
-        for (const specPath of sortedPaths) {
-            errorMsg.push(`  - ${specPath}`);
-        }
-        errorMsg.push('');
-        errorMsg.push('Please specify the full path from .mod/specs/');
-        errorMsg.push(`Example: mod spec status ${sortedPaths[0]}`);
-        throw new Error(errorMsg.join('\n'));
-    }
-    return matches[0];
-}
-// Helper function to find all specifications
-async function findAllSpecifications(specsDir) {
-    const specs = [];
-    async function searchDir(dir, relativePath = '') {
-        try {
-            const entries = await fs.readdir(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                const fullPath = path.join(dir, entry.name);
-                const relPath = path.join(relativePath, entry.name);
-                if (entry.isDirectory()) {
-                    await searchDir(fullPath, relPath);
-                }
-                else if (entry.name.endsWith('.spec.md')) {
-                    specs.push(relPath);
-                }
-            }
-        }
-        catch {
-            // Directory doesn't exist or can't be read
-        }
-    }
-    await searchDir(specsDir);
-    return specs.sort();
-}
-// Extract nested requirements (reused from status.ts)
-function extractNestedRequirements(content, topLevelRequirements, frontmatterOffset) {
-    const adjustedTopLevel = topLevelRequirements.map(req => ({
-        ...req,
-        lineRange: req.lineRange ? {
-            start: req.lineRange.start + frontmatterOffset,
-            end: req.lineRange.end + frontmatterOffset
-        } : undefined
-    }));
-    const allRequirements = [...adjustedTopLevel];
-    const nestedReqRegex = /^\s*-\s*\*\*(?<id>REQ-[A-Z]+-\d+(?:\.\d+)*)\*\*:\s*(?<description>.*)/gm;
-    let match;
-    while ((match = nestedReqRegex.exec(content)) !== null) {
-        const groups = match.groups;
-        if (!groups)
-            continue;
-        const { id, description } = groups;
-        const categoryMatch = id.match(/REQ-([A-Z]+)/);
-        if (!categoryMatch)
-            continue;
-        const categoryStr = categoryMatch[1];
-        const category = Object.values(RequirementCategory).find(cat => cat === categoryStr);
-        if (!category)
-            continue;
-        if (topLevelRequirements.some(req => req.id === id))
-            continue;
-        const lineNumber = content.substring(0, match.index).split('\n').length;
-        allRequirements.push({
-            id,
-            category,
-            title: description.trim(),
-            description: description.trim(),
-            children: [],
-            lineRange: { start: lineNumber, end: lineNumber },
-            parent: determineParentRequirement(id)
-        });
-    }
-    return allRequirements;
-}
-function filterTracesBySpec(traceMap, specName) {
-    const filtered = new Map();
-    const specBaseName = specName.replace('.spec.md', '');
-    for (const [requirementId, traces] of traceMap.entries()) {
-        const relevantTraces = traces.filter(trace => {
-            if (!trace.specPath)
-                return true;
-            return trace.specPath.includes(specBaseName);
-        });
-        if (relevantTraces.length > 0) {
-            filtered.set(requirementId, relevantTraces);
-        }
-    }
-    return filtered;
-}
-// Helper functions
-function determineParentRequirement(requirementId) {
-    const parts = requirementId.split('-');
-    if (parts.length < 3)
-        return undefined;
-    const [, category, numberPart] = parts;
-    const dotIndex = numberPart.indexOf('.');
-    if (dotIndex === -1)
-        return undefined;
-    const parentNumber = numberPart.substring(0, dotIndex);
-    return `REQ-${category}-${parentNumber}`;
-}
-function calculateHierarchyLevel(requirementId) {
-    const parts = requirementId.split('-');
-    if (parts.length < 3)
-        return 1;
-    const numberPart = parts[2];
-    const dotCount = (numberPart.match(/\./g) || []).length;
-    return 2 + dotCount;
-}
-function applyHierarchicalAggregation(requirements) {
-    const sortedByHierarchy = [...requirements].sort((a, b) => b.hierarchyLevel - a.hierarchyLevel);
-    for (const requirement of sortedByHierarchy) {
-        const children = requirements.filter(r => r.requirementId.startsWith(requirement.requirementId + '.') &&
-            r.hierarchyLevel === requirement.hierarchyLevel + 1);
-        if (children.length > 0) {
-            if (requirement.traceCount === 0 && children.every(child => child.status === 'traced')) {
-                requirement.status = 'traced';
-            }
-        }
-    }
-}
-function printTscStyleOutput(analysis) {
-    const colors = {
-        traced: '\x1b[32m', // Green
-        todo: '\x1b[31m', // Red
-        reset: '\x1b[0m',
-        dim: '\x1b[90m', // Dim gray
-        count: '\x1b[36m' // Cyan for trace counts
-    };
-    const totalReqs = analysis.requirements.length;
-    console.log(`${analysis.specFile} - ${totalReqs} requirements\n`);
-    const requirementsByCategory = groupRequirementsByCategory(analysis.requirements);
-    for (const [category, requirements] of requirementsByCategory.entries()) {
-        console.log(`${colors.dim}## ${category} Requirements${colors.reset}\n`);
-        for (const req of requirements) {
-            const statusLabel = req.status;
-            const color = colors[statusLabel];
-            const truncatedTitle = req.title.length > 60 ?
-                req.title.substring(0, 57) + '...' : req.title;
-            const indent = '  '.repeat(Math.max(0, req.hierarchyLevel - 2));
-            if (req.traces.length > 0) {
-                const trace = req.traces[0];
-                const traceCountDisplay = req.traceCount > 1 ? ` ${colors.count}(${req.traceCount})${colors.reset}` : '';
-                console.log(`${indent}${trace.file}:${trace.line}:1 - ${color}${statusLabel}${colors.reset}${traceCountDisplay} ${req.requirementId}: ${truncatedTitle}`);
-            }
-            else {
-                const lineNumber = req.lineRange?.start || 1;
-                console.log(`${indent}${analysis.specFile}:${lineNumber}:1 - ${color}${statusLabel}${colors.reset} ${req.requirementId}: ${truncatedTitle}`);
-            }
-        }
-        console.log();
-    }
-    const tracedText = `${colors.traced}${analysis.summary.traced} traced${colors.reset}`;
-    const todoText = `${colors.todo}${analysis.summary.todo} todo${colors.reset}`;
-    const totalTracesText = `${colors.count}${analysis.summary.totalTraces} traces${colors.reset}`;
-    console.log(`Found ${tracedText}, ${todoText} (${totalTracesText} total).`);
-}
-function groupRequirementsByCategory(requirements) {
-    const categoryOrder = ['UX', 'BUS', 'DATA', 'INT', 'INFRA', 'QUAL'];
-    const grouped = new Map();
-    for (const category of categoryOrder) {
-        grouped.set(category, []);
-    }
-    for (const req of requirements) {
-        const category = req.category;
-        if (!grouped.has(category)) {
-            grouped.set(category, []);
-        }
-        grouped.get(category).push(req);
-    }
-    for (const [, reqs] of grouped.entries()) {
-        reqs.sort((a, b) => a.requirementId.localeCompare(b.requirementId));
-    }
-    const result = new Map();
-    for (const [category, reqs] of grouped.entries()) {
-        if (reqs.length > 0) {
-            result.set(category, reqs);
-        }
-    }
-    return result;
-}
-function handleError(error, specName) {
-    if (error instanceof Error) {
-        if (error.message.includes('not found')) {
-            console.error(`Error: Specification file "${specName}" not found`);
-            process.exit(1);
-        }
-        else if (error.message.includes('parse')) {
-            console.error(`Error: Failed to parse specification: ${error.message}`);
-            process.exit(2);
-        }
-        else if (error.message.includes('scan')) {
-            console.error(`Error: Failed to scan workspace: ${error.message}`);
-            process.exit(3);
-        }
-        else if (error.message.includes('Multiple specifications found')) {
-            console.error(error.message);
-            process.exit(1);
-        }
-    }
-    console.error(`Unexpected error: ${error instanceof Error ? error.message : String(error)}`);
-    process.exit(3);
-}