@mod-computer/cli 0.2.4 → 0.2.5

package/dist/lib/diff.js

@@ -1,284 +0,0 @@
-// glassware[type="implementation", id="impl-cli-fd-diff--22cb6c01", requirements="requirement-cli-fd-diff-text--54d22be4,requirement-cli-fd-diff-binary--4aeb6fda,requirement-cli-fd-diff-automerge--8310553b"]
-// spec: packages/mod-cli/specs/file-directory.md
-/**
- * Extract text content from ModFile content structure
- */
-// glassware[type="implementation", id="impl-cli-fd-diff-automerge--19e08758", requirements="requirement-cli-fd-diff-automerge--8310553b"]
-export function getWorkspaceContent(content) {
-    if (typeof content === 'string') {
-        return content;
-    }
-    if (content?.text) {
-        // TextFileContent or CodeFileContent
-        if (typeof content.text === 'string') {
-            return content.text;
-        }
-        // Automerge Text type - convert to string
-        if (content.text.toString) {
-            return content.text.toString();
-        }
-    }
-    return '';
-}
-/**
- * Check if content appears to be binary
- */
-// glassware[type="implementation", id="impl-cli-fd-diff-binary--80add1e0", requirements="requirement-cli-fd-diff-binary--4aeb6fda"]
-export function isBinaryContent(content) {
-    // Check for null bytes or high proportion of non-printable characters
-    let nonPrintable = 0;
-    const checkLength = Math.min(content.length, 8000);
-    for (let i = 0; i < checkLength; i++) {
-        const code = content.charCodeAt(i);
-        if (code === 0) {
-            return true; // Null byte = definitely binary
-        }
-        // Non-printable excluding common whitespace
-        if (code < 32 && code !== 9 && code !== 10 && code !== 13) {
-            nonPrintable++;
-        }
-    }
-    return nonPrintable / checkLength > 0.3;
-}
-/**
- * Compute unified diff between two strings
- */
-// glassware[type="implementation", id="impl-cli-fd-diff-text--9c318f0e", requirements="requirement-cli-fd-diff-text--54d22be4"]
-export function computeDiff(oldContent, newContent, contextLines = 3) {
-    const oldLines = oldContent.split('\n');
-    const newLines = newContent.split('\n');
-    // Simple LCS-based diff algorithm
-    const lcs = computeLCS(oldLines, newLines);
-    const hunks = [];
-    let oldIndex = 0;
-    let newIndex = 0;
-    let lcsIndex = 0;
-    let currentHunk = null;
-    while (oldIndex < oldLines.length || newIndex < newLines.length) {
-        // Check if current lines match LCS
-        const matchesLCS = lcsIndex < lcs.length &&
-            oldIndex < oldLines.length &&
-            newIndex < newLines.length &&
-            oldLines[oldIndex] === lcs[lcsIndex] &&
-            newLines[newIndex] === lcs[lcsIndex];
-        if (matchesLCS) {
-            // Context line
-            if (currentHunk) {
-                currentHunk.lines.push({
-                    type: 'context',
-                    content: oldLines[oldIndex],
-                    oldLineNumber: oldIndex + 1,
-                    newLineNumber: newIndex + 1,
-                });
-            }
-            oldIndex++;
-            newIndex++;
-            lcsIndex++;
-        }
-        else {
-            // Start a new hunk if needed
-            if (!currentHunk) {
-                const startOld = Math.max(0, oldIndex - contextLines);
-                const startNew = Math.max(0, newIndex - contextLines);
-                currentHunk = {
-                    oldStart: startOld + 1,
-                    oldLines: 0,
-                    newStart: startNew + 1,
-                    newLines: 0,
-                    lines: [],
-                };
-                // Add leading context
-                for (let i = startOld; i < oldIndex; i++) {
-                    currentHunk.lines.push({
-                        type: 'context',
-                        content: oldLines[i],
-                        oldLineNumber: i + 1,
-                        newLineNumber: startNew + (i - startOld) + 1,
-                    });
-                }
-            }
-            // Handle deletions
-            while (oldIndex < oldLines.length &&
-                (lcsIndex >= lcs.length || oldLines[oldIndex] !== lcs[lcsIndex])) {
-                currentHunk.lines.push({
-                    type: 'deletion',
-                    content: oldLines[oldIndex],
-                    oldLineNumber: oldIndex + 1,
-                });
-                oldIndex++;
-            }
-            // Handle additions
-            while (newIndex < newLines.length &&
-                (lcsIndex >= lcs.length || newLines[newIndex] !== lcs[lcsIndex])) {
-                currentHunk.lines.push({
-                    type: 'addition',
-                    content: newLines[newIndex],
-                    newLineNumber: newIndex + 1,
-                });
-                newIndex++;
-            }
-            // Check if we should close the hunk (no more changes for a while)
-            const nextChange = findNextChange(oldLines, newLines, lcs, oldIndex, newIndex, lcsIndex);
-            if (nextChange > contextLines * 2 || (oldIndex >= oldLines.length && newIndex >= newLines.length)) {
-                // Add trailing context
-                const endContext = Math.min(contextLines, oldLines.length - oldIndex);
-                for (let i = 0; i < endContext; i++) {
-                    if (oldIndex + i < oldLines.length && lcsIndex + i < lcs.length) {
-                        currentHunk.lines.push({
-                            type: 'context',
-                            content: oldLines[oldIndex + i],
-                            oldLineNumber: oldIndex + i + 1,
-                            newLineNumber: newIndex + i + 1,
-                        });
-                    }
-                }
-                // Calculate hunk line counts
-                currentHunk.oldLines = currentHunk.lines.filter(l => l.type === 'context' || l.type === 'deletion').length;
-                currentHunk.newLines = currentHunk.lines.filter(l => l.type === 'context' || l.type === 'addition').length;
-                hunks.push(currentHunk);
-                currentHunk = null;
-                // Skip context we just added
-                oldIndex += endContext;
-                newIndex += endContext;
-                lcsIndex += endContext;
-            }
-        }
-    }
-    // Close any remaining hunk
-    if (currentHunk && currentHunk.lines.length > 0) {
-        currentHunk.oldLines = currentHunk.lines.filter(l => l.type === 'context' || l.type === 'deletion').length;
-        currentHunk.newLines = currentHunk.lines.filter(l => l.type === 'context' || l.type === 'addition').length;
-        hunks.push(currentHunk);
-    }
-    return hunks;
-}
-/**
- * Compute LCS (Longest Common Subsequence) of two arrays
- */
-function computeLCS(a, b) {
-    const m = a.length;
-    const n = b.length;
-    // DP table
-    const dp = Array(m + 1)
-        .fill(null)
-        .map(() => Array(n + 1).fill(0));
-    for (let i = 1; i <= m; i++) {
-        for (let j = 1; j <= n; j++) {
-            if (a[i - 1] === b[j - 1]) {
-                dp[i][j] = dp[i - 1][j - 1] + 1;
-            }
-            else {
-                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
-            }
-        }
-    }
-    // Backtrack to find LCS
-    const lcs = [];
-    let i = m;
-    let j = n;
-    while (i > 0 && j > 0) {
-        if (a[i - 1] === b[j - 1]) {
-            lcs.unshift(a[i - 1]);
-            i--;
-            j--;
-        }
-        else if (dp[i - 1][j] > dp[i][j - 1]) {
-            i--;
-        }
-        else {
-            j--;
-        }
-    }
-    return lcs;
-}
-/**
- * Find distance to next change
- */
-function findNextChange(oldLines, newLines, lcs, oldIndex, newIndex, lcsIndex) {
-    let count = 0;
-    while (oldIndex + count < oldLines.length &&
-        newIndex + count < newLines.length &&
-        lcsIndex + count < lcs.length &&
-        oldLines[oldIndex + count] === lcs[lcsIndex + count] &&
-        newLines[newIndex + count] === lcs[lcsIndex + count]) {
-        count++;
-    }
-    return count;
-}
-/**
- * Format diff hunks as unified diff string
- */
-export function formatUnifiedDiff(oldPath, newPath, hunks, color = true) {
-    if (hunks.length === 0) {
-        return '';
-    }
-    const lines = [];
-    // Header
-    const oldHeader = `--- ${oldPath}`;
-    const newHeader = `+++ ${newPath}`;
-    lines.push(color ? `\x1b[1m${oldHeader}\x1b[0m` : oldHeader);
-    lines.push(color ? `\x1b[1m${newHeader}\x1b[0m` : newHeader);
-    for (const hunk of hunks) {
-        // Hunk header
-        const hunkHeader = `@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`;
-        lines.push(color ? `\x1b[36m${hunkHeader}\x1b[0m` : hunkHeader);
-        for (const line of hunk.lines) {
-            switch (line.type) {
-                case 'context':
-                    lines.push(` ${line.content}`);
-                    break;
-                case 'deletion':
-                    const delLine = `-${line.content}`;
-                    lines.push(color ? `\x1b[31m${delLine}\x1b[0m` : delLine);
-                    break;
-                case 'addition':
-                    const addLine = `+${line.content}`;
-                    lines.push(color ? `\x1b[32m${addLine}\x1b[0m` : addLine);
-                    break;
-            }
-        }
-    }
-    return lines.join('\n');
-}
-/**
- * Calculate diff statistics
- */
-export function calculateDiffStats(hunks) {
-    let additions = 0;
-    let deletions = 0;
-    for (const hunk of hunks) {
-        for (const line of hunk.lines) {
-            if (line.type === 'addition')
-                additions++;
-            if (line.type === 'deletion')
-                deletions++;
-        }
-    }
-    return { additions, deletions };
-}
-/**
- * Format diffstat summary
- */
-export function formatDiffStat(files, color = true) {
-    const lines = [];
-    let totalAdditions = 0;
-    let totalDeletions = 0;
-    const maxPathLen = Math.max(...files.map(f => f.path.length), 20);
-    for (const file of files) {
-        const total = file.additions + file.deletions;
-        const plusStr = '+'.repeat(Math.min(file.additions, 20));
-        const minusStr = '-'.repeat(Math.min(file.deletions, 20));
-        let line = ` ${file.path.padEnd(maxPathLen)} | ${String(total).padStart(4)} `;
-        if (color) {
-            line += `\x1b[32m${plusStr}\x1b[0m\x1b[31m${minusStr}\x1b[0m`;
-        }
-        else {
-            line += `${plusStr}${minusStr}`;
-        }
-        lines.push(line);
-        totalAdditions += file.additions;
-        totalDeletions += file.deletions;
-    }
-    lines.push(` ${files.length} file${files.length === 1 ? '' : 's'} changed, ${totalAdditions} insertion${totalAdditions === 1 ? '' : 's'}(+), ${totalDeletions} deletion${totalDeletions === 1 ? '' : 's'}(-)`);
-    return lines.join('\n');
-}

package/dist/lib/formatters.js

@@ -1,204 +0,0 @@
-// glassware[type="implementation", id="impl-cli-fd-formatters--faafb955", requirements="requirement-cli-ls-output-default--6e584280,requirement-cli-ls-output-tree--43babfa8,requirement-cli-ls-output-json--d62469fe"]
-// spec: packages/mod-cli/specs/file-directory.md
-/**
- * Format file size in human readable format
- */
-export function formatSize(bytes) {
-    if (bytes === 0)
-        return '0 B';
-    const units = ['B', 'KB', 'MB', 'GB'];
-    const k = 1024;
-    const i = Math.floor(Math.log(bytes) / Math.log(k));
-    if (i === 0)
-        return `${bytes} B`;
-    const size = bytes / Math.pow(k, i);
-    return `${size.toFixed(1)} ${units[i]}`;
-}
-/**
- * Format relative time
- */
-export function formatRelativeTime(isoString) {
-    const date = new Date(isoString);
-    const now = new Date();
-    const diffMs = now.getTime() - date.getTime();
-    const minutes = Math.floor(diffMs / (1000 * 60));
-    const hours = Math.floor(diffMs / (1000 * 60 * 60));
-    const days = Math.floor(diffMs / (1000 * 60 * 60 * 24));
-    if (minutes < 1)
-        return 'just now';
-    if (minutes < 60)
-        return `${minutes} min ago`;
-    if (hours < 24)
-        return `${hours} hour${hours === 1 ? '' : 's'} ago`;
-    if (days < 7)
-        return `${days} day${days === 1 ? '' : 's'} ago`;
-    return date.toLocaleDateString();
-}
-/**
- * Format default table output for file list
- */
-// glassware[type="implementation", id="impl-cli-ls-output-default--8774cf55", requirements="requirement-cli-ls-output-default--6e584280"]
-export function formatFileTable(files) {
-    if (files.length === 0) {
-        return 'No files in workspace.\n\nRun `mod init` to import files from this directory.';
-    }
-    const lines = [];
-    // Calculate column widths
-    const pathWidth = Math.max(4, Math.min(50, Math.max(...files.map(f => f.path.length))));
-    // Header
-    lines.push(`${'PATH'.padEnd(pathWidth)}  ${'SIZE'.padStart(10)}  MODIFIED`);
-    // Rows
-    for (const file of files) {
-        const path = file.path.length > pathWidth
-            ? '...' + file.path.slice(-(pathWidth - 3))
-            : file.path.padEnd(pathWidth);
-        const size = formatSize(file.size).padStart(10);
-        const modified = formatRelativeTime(file.updatedAt);
-        lines.push(`${path}  ${size}  ${modified}`);
-    }
-    // Summary
-    const totalSize = files.reduce((sum, f) => sum + f.size, 0);
-    lines.push('');
-    lines.push(`${files.length} file${files.length === 1 ? '' : 's'} (${formatSize(totalSize)} total)`);
-    return lines.join('\n');
-}
-function buildTree(files) {
-    const root = { name: '.', isFolder: true, children: new Map() };
-    for (const file of files) {
-        const parts = file.path.split('/');
-        let current = root;
-        for (let i = 0; i < parts.length; i++) {
-            const part = parts[i];
-            const isLast = i === parts.length - 1;
-            if (!current.children.has(part)) {
-                current.children.set(part, {
-                    name: part,
-                    isFolder: !isLast,
-                    size: isLast ? file.size : undefined,
-                    children: new Map(),
-                });
-            }
-            current = current.children.get(part);
-        }
-    }
-    return root;
-}
-/**
- * Format tree output
- */
-// glassware[type="implementation", id="impl-cli-ls-output-tree--c098fff8", requirements="requirement-cli-ls-output-tree--43babfa8"]
-export function formatFileTree(files) {
-    if (files.length === 0) {
-        return 'No files in workspace.\n\nRun `mod init` to import files from this directory.';
-    }
-    const tree = buildTree(files);
-    const lines = ['.'];
-    function renderNode(node, prefix, isLast) {
-        const children = Array.from(node.children.values());
-        // Sort: folders first, then alphabetically
-        children.sort((a, b) => {
-            if (a.isFolder !== b.isFolder)
-                return a.isFolder ? -1 : 1;
-            return a.name.localeCompare(b.name);
-        });
-        for (let i = 0; i < children.length; i++) {
-            const child = children[i];
-            const isLastChild = i === children.length - 1;
-            const connector = isLastChild ? '\\u2514\\u2500\\u2500 ' : '\\u251c\\u2500\\u2500 ';
-            const nextPrefix = prefix + (isLastChild ? '    ' : '\\u2502   ');
-            if (child.isFolder) {
-                lines.push(`${prefix}${connector}${child.name}/`);
-                renderNode(child, nextPrefix, isLastChild);
-            }
-            else {
-                const sizeStr = child.size !== undefined ? ` (${formatSize(child.size)})` : '';
-                lines.push(`${prefix}${connector}${child.name}${sizeStr}`);
-            }
-        }
-    }
-    renderNode(tree, '', true);
-    return lines.join('\n')
-        .replace(/\\u2514/g, '\u2514')
-        .replace(/\\u2500/g, '\u2500')
-        .replace(/\\u251c/g, '\u251c')
-        .replace(/\\u2502/g, '\u2502');
-}
-/**
- * Format JSON output
- */
-// glassware[type="implementation", id="impl-cli-ls-output-json--75e73ac5", requirements="requirement-cli-ls-output-json--d62469fe"]
-export function formatFileJson(files) {
-    const totalSize = files.reduce((sum, f) => sum + f.size, 0);
-    const output = {
-        files: files.map(f => ({
-            path: f.path,
-            size: f.size,
-            mimeType: f.mimeType,
-            updatedAt: f.updatedAt,
-        })),
-        totalFiles: files.length,
-        totalSize,
-    };
-    return JSON.stringify(output, null, 2);
-}
-/**
- * Format file paths only (quiet mode)
- */
-export function formatFilePaths(files) {
-    return files.map(f => f.path).join('\n');
-}
-/**
- * Format long/detailed output
- */
-export function formatFileLong(files) {
-    if (files.length === 0) {
-        return 'No files in workspace.';
-    }
-    const lines = [];
-    // Header
-    lines.push('ID                                    PATH                              SIZE       MIME TYPE');
-    for (const file of files) {
-        const id = file.id.slice(0, 36).padEnd(36);
-        const path = file.path.length > 32
-            ? '...' + file.path.slice(-29)
-            : file.path.padEnd(32);
-        const size = formatSize(file.size).padStart(10);
-        const mime = file.mimeType;
-        lines.push(`${id}  ${path}  ${size}  ${mime}`);
-    }
-    return lines.join('\n');
-}
-/**
- * Determine MIME type category
- */
-export function getMimeCategory(mimeType) {
-    if (mimeType.startsWith('text/')) {
-        if (mimeType.includes('typescript') ||
-            mimeType.includes('javascript') ||
-            mimeType.includes('python') ||
-            mimeType.includes('java') ||
-            mimeType.includes('c') ||
-            mimeType.includes('rust') ||
-            mimeType.includes('go')) {
-            return 'code';
-        }
-        return 'text';
-    }
-    if (mimeType.startsWith('application/json') ||
-        mimeType.includes('yaml') ||
-        mimeType.includes('xml') ||
-        mimeType.includes('csv')) {
-        return 'data';
-    }
-    if (mimeType.includes('javascript') ||
-        mimeType.includes('typescript')) {
-        return 'code';
-    }
-    if (mimeType.startsWith('image/') ||
-        mimeType.startsWith('audio/') ||
-        mimeType.startsWith('video/') ||
-        mimeType === 'application/octet-stream') {
-        return 'binary';
-    }
-    return 'unknown';
-}

package/dist/lib/git.js

@@ -1,137 +0,0 @@
-// glassware[type="implementation", id="impl-cli-git-utils--7e4f29ca", requirements="requirement-cli-git-app-1--f5a33b8c,requirement-cli-git-app-2--4f3b552c,requirement-cli-git-qual-1--98d1bacb,requirement-cli-git-qual-2--503addb9,requirement-cli-git-qual-3--5af20852,requirement-cli-git-qual-4--7c40baf1"]
-import fs from 'fs';
-import path from 'path';
-/**
- * Detect if a directory is inside a git repository.
- * Walks up the directory tree looking for a .git directory.
- */
-// glassware[type="implementation", id="impl-cli-detect-git-repo--86f0b85f", specifications="specification-spec-is-git-repo--8d217687"]
-export function detectGitRepo(directory) {
-    let currentDir = path.resolve(directory);
-    const root = path.parse(currentDir).root;
-    while (currentDir !== root) {
-        const gitDir = path.join(currentDir, '.git');
-        if (fs.existsSync(gitDir)) {
-            const headFile = path.join(gitDir, 'HEAD');
-            const branchResult = readCurrentBranchWithDetached(headFile);
-            return {
-                isGitRepo: true,
-                branch: branchResult.branch,
-                gitDir,
-                headFile,
-                isDetached: branchResult.isDetached,
-            };
-        }
-        currentDir = path.dirname(currentDir);
-    }
-    return {
-        isGitRepo: false,
-        branch: null,
-        gitDir: null,
-        headFile: null,
-        isDetached: false,
-    };
-}
-/**
- * Read the current branch name from .git/HEAD with detached state info.
- * Returns branch name and whether in detached HEAD state.
- */
-// glassware[type="implementation", id="impl-cli-read-branch-detached--42ec893d", specifications="specification-spec-detect-branch--76e466f2,specification-spec-detached-head--0fce4d44"]
-export function readCurrentBranchWithDetached(headFile) {
-    try {
-        if (!fs.existsSync(headFile)) {
-            return { branch: null, isDetached: false };
-        }
-        const content = fs.readFileSync(headFile, 'utf8').trim();
-        // Check if it's a symbolic ref (normal branch)
-        // Format: "ref: refs/heads/branch-name"
-        if (content.startsWith('ref: refs/heads/')) {
-            return {
-                branch: content.replace('ref: refs/heads/', ''),
-                isDetached: false,
-            };
-        }
-        // Detached HEAD (commit hash) - return detached-{hash} format per spec
-        if (/^[0-9a-f]{40}$/i.test(content)) {
-            return {
-                branch: `detached-${content.substring(0, 7)}`,
-                isDetached: true,
-            };
-        }
-        return { branch: null, isDetached: false };
-    }
-    catch (error) {
-        return { branch: null, isDetached: false };
-    }
-}
-/**
- * Read the current branch name from .git/HEAD.
- * Returns null if detached HEAD or unable to read.
- */
-export function readCurrentBranch(headFile) {
-    return readCurrentBranchWithDetached(headFile).branch;
-}
-/**
- * Get git branch for a directory.
- * Convenience function that returns just the branch name or null.
- */
-export function getGitBranch(directory) {
-    const gitInfo = detectGitRepo(directory);
-    return gitInfo.branch;
-}
-/**
- * Check if a path should be ignored based on git patterns.
- * This is a simplified check for common patterns.
- */
-export function isGitIgnoredPath(relativePath) {
-    // Always ignore .git directory contents
-    if (relativePath.startsWith('.git/') || relativePath === '.git') {
-        return true;
-    }
-    // Ignore common patterns
-    const ignoredPatterns = [
-        /^node_modules\//,
-        /^\.git\//,
-        /^dist\//,
-        /^build\//,
-        /^\.next\//,
-        /^\.nuxt\//,
-        /^coverage\//,
-        /^\.cache\//,
-        /^\.automerge-data\//,
-        /\.log$/,
-        /\.lock$/,
-        /^\.DS_Store$/,
-        /^Thumbs\.db$/,
-    ];
-    return ignoredPatterns.some(pattern => pattern.test(relativePath));
-}
-/**
- * Check if a git operation is in progress (rebase, merge, etc).
- * When active git operations are in progress, syncing should be paused.
- */
-// glassware[type="implementation", id="impl-cli-git-operation-check--c31739c8", specifications="specification-spec-git-operations--addf801f"]
-export function isGitOperationInProgress(directory) {
-    const gitInfo = detectGitRepo(directory);
-    if (!gitInfo.isGitRepo || !gitInfo.gitDir) {
-        return false;
-    }
-    const gitDir = gitInfo.gitDir;
-    // Check for various git operations in progress
-    const operationIndicators = [
-        path.join(gitDir, 'rebase-merge'), // git rebase in progress
-        path.join(gitDir, 'rebase-apply'), // git am or rebase --apply in progress
-        path.join(gitDir, 'MERGE_HEAD'), // git merge in progress
-        path.join(gitDir, 'CHERRY_PICK_HEAD'), // git cherry-pick in progress
-        path.join(gitDir, 'REVERT_HEAD'), // git revert in progress
-        path.join(gitDir, 'BISECT_LOG'), // git bisect in progress
-    ];
-    return operationIndicators.some(indicator => fs.existsSync(indicator));
-}
-/**
- * Check if the .git directory exists and is valid.
- */
-export function isGitRepo(directory) {
-    const gitInfo = detectGitRepo(directory);
-    return gitInfo.isGitRepo;
-}