@mod-computer/cli 0.1.0 → 0.2.1

package/dist/lib/git.js

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

package/dist/lib/local-fs.js

@@ -0,0 +1,201 @@
+// glassware[type="implementation", id="impl-cli-fd-local-fs--3a1efb54", requirements="requirement-cli-fd-local-read--bbd1aae6,requirement-cli-fd-local-delete--df1be435,requirement-cli-fd-local-move--022534b1"]
+// spec: packages/mod-cli/specs/file-directory.md
+import fs from 'fs/promises';
+import path from 'path';
+/**
+ * Read local file content as string
+ */
+// glassware[type="implementation", id="impl-cli-fd-local-read--99aa05fa", requirements="requirement-cli-fd-local-read--bbd1aae6"]
+export async function readLocalFile(filePath) {
+    try {
+        const absolutePath = path.resolve(filePath);
+        const content = await fs.readFile(absolutePath, 'utf-8');
+        return content;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return null;
+        }
+        throw error;
+    }
+}
+/**
+ * Check if local file exists
+ */
+export async function localFileExists(filePath) {
+    try {
+        const absolutePath = path.resolve(filePath);
+        await fs.access(absolutePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get local file stats
+ */
+export async function getLocalFileStats(filePath) {
+    try {
+        const absolutePath = path.resolve(filePath);
+        const stats = await fs.stat(absolutePath);
+        return {
+            size: stats.size,
+            mtime: stats.mtime,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Delete local file with proper error handling
+ */
+// glassware[type="implementation", id="impl-cli-fd-local-delete--74bf0b5b", requirements="requirement-cli-fd-local-delete--df1be435"]
+export async function deleteLocalFile(filePath) {
+    try {
+        const absolutePath = path.resolve(filePath);
+        await fs.unlink(absolutePath);
+        return { success: true };
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return { success: true }; // Already deleted
+        }
+        if (error.code === 'EACCES' || error.code === 'EPERM') {
+            return { success: false, error: `Permission denied: ${filePath}` };
+        }
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Delete local directory recursively
+ */
+export async function deleteLocalDirectory(dirPath) {
+    try {
+        const absolutePath = path.resolve(dirPath);
+        await fs.rm(absolutePath, { recursive: true, force: true });
+        return { success: true };
+    }
+    catch (error) {
+        if (error.code === 'EACCES' || error.code === 'EPERM') {
+            return { success: false, error: `Permission denied: ${dirPath}` };
+        }
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Move local file with cross-device fallback
+ */
+// glassware[type="implementation", id="impl-cli-fd-local-move--692fd328", requirements="requirement-cli-fd-local-move--022534b1"]
+export async function moveLocalFile(src, dest) {
+    try {
+        const absoluteSrc = path.resolve(src);
+        const absoluteDest = path.resolve(dest);
+        // Ensure destination directory exists
+        const destDir = path.dirname(absoluteDest);
+        await fs.mkdir(destDir, { recursive: true });
+        try {
+            await fs.rename(absoluteSrc, absoluteDest);
+        }
+        catch (err) {
+            if (err.code === 'EXDEV') {
+                // Cross-device: copy then delete
+                await fs.copyFile(absoluteSrc, absoluteDest);
+                await fs.unlink(absoluteSrc);
+            }
+            else {
+                throw err;
+            }
+        }
+        return { success: true };
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return { success: false, error: `File not found: ${src}` };
+        }
+        if (error.code === 'EACCES' || error.code === 'EPERM') {
+            return { success: false, error: `Permission denied: ${src}` };
+        }
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * List files in a local directory recursively
+ */
+export async function listLocalFiles(dirPath, pattern) {
+    const files = [];
+    const absolutePath = path.resolve(dirPath);
+    async function walk(dir) {
+        try {
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                const relativePath = path.relative(absolutePath, fullPath);
+                if (entry.isDirectory()) {
+                    await walk(fullPath);
+                }
+                else if (entry.isFile()) {
+                    if (!pattern || matchGlob(relativePath, pattern)) {
+                        files.push(relativePath);
+                    }
+                }
+            }
+        }
+        catch {
+            // Skip directories we can't read
+        }
+    }
+    await walk(absolutePath);
+    return files;
+}
+/**
+ * Simple glob matching (supports * and **)
+ */
+export function matchGlob(filePath, pattern) {
+    // Normalize path separators
+    const normalizedPath = filePath.replace(/\\/g, '/');
+    const normalizedPattern = pattern.replace(/\\/g, '/');
+    // Handle patterns starting with **/ (should match any path depth including root)
+    if (normalizedPattern.startsWith('**/')) {
+        // **/ means "anywhere in path", so we match either:
+        // 1. The file directly at root (just matches the part after **/)
+        // 2. The file nested in directories (matches .* followed by / then the part after **/)
+        const rest = normalizedPattern.slice(3); // Remove **/
+        const restRegex = rest
+            .replace(/\./g, '\\.')
+            .replace(/\*\*/g, '.*')
+            .replace(/\*/g, '[^/]*');
+        const regex = new RegExp(`^(.*\\/)?${restRegex}$`);
+        return regex.test(normalizedPath);
+    }
+    // Convert glob to regex for other patterns
+    const regexPattern = normalizedPattern
+        .replace(/\./g, '\\.') // Escape dots
+        .replace(/\*\*/g, '.*') // ** matches anything
+        .replace(/\*/g, '[^/]*'); // * matches anything except /
+    const regex = new RegExp(`^${regexPattern}$`);
+    return regex.test(normalizedPath);
+}
+/**
+ * Check if a file appears to be binary
+ */
+export async function isBinaryFile(filePath) {
+    try {
+        const absolutePath = path.resolve(filePath);
+        const buffer = Buffer.alloc(512);
+        const fd = await fs.open(absolutePath, 'r');
+        const { bytesRead } = await fd.read(buffer, 0, 512, 0);
+        await fd.close();
+        // Check for null bytes (common in binary files)
+        for (let i = 0; i < bytesRead; i++) {
+            if (buffer[i] === 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/lib/prompts.js

@@ -0,0 +1,56 @@
+// glassware[type="implementation", id="cli-prompts--bbf3cbc1", requirements="requirement-cli-init-ux-2--b69b045f,requirement-cli-init-ux-3--3dde4846,requirement-cli-init-ux-4--140d9249"]
+import { select as inquirerSelect, input as inquirerInput, confirm as inquirerConfirm } from '@inquirer/prompts';
+/**
+ * Display a selection prompt with arrow key navigation.
+ */
+export async function select(question, options) {
+    const result = await inquirerSelect({
+        message: question,
+        choices: options.map(opt => ({
+            name: opt.label,
+            value: opt.value,
+            description: opt.description,
+        })),
+    });
+    return result;
+}
+/**
+ * Display a text input prompt and return the value.
+ */
+export async function input(question, options) {
+    const result = await inquirerInput({
+        message: question,
+        default: options?.default,
+        validate: options?.validate
+            ? (value) => options.validate(value) ?? true
+            : undefined,
+    });
+    return result;
+}
+/**
+ * Display a yes/no confirmation prompt.
+ */
+export async function confirm(question, options) {
+    const result = await inquirerConfirm({
+        message: question,
+        default: options?.default ?? true,
+    });
+    return result;
+}
+// glassware[type="implementation", id="impl-validate-workspace-name--6732de6e", requirements="requirement-cli-init-qual-2--4ba7ca9c"]
+/**
+ * Validate a workspace name.
+ * Returns error message if invalid, null if valid.
+ */
+export function validateWorkspaceName(name) {
+    if (!name || name.trim().length === 0) {
+        return 'Workspace name cannot be empty';
+    }
+    if (name.length > 100) {
+        return 'Workspace name must be 100 characters or less';
+    }
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9-_ ]*[a-zA-Z0-9]$|^[a-zA-Z0-9]$/.test(name.trim())) {
+        return 'Workspace name must start and end with alphanumeric characters';
+    }
+    return null;
+}

package/dist/lib/storage.js

@@ -1,4 +1,7 @@
-// glassware[type=implementation, id=cli-storage-utils, requirements=req-cli-storage-struct-1,req-cli-storage-app-1,req-cli-storage-app-2,req-cli-storage-app-3,req-cli-storage-conn-2,req-cli-storage-qual-1,req-cli-storage-qual-5]
+// glassware[type="implementation", id="impl-cli-storage--44a11f2b", specifications="specification-spec-token-storage--26199fe8,specification-spec-config-permissions--18b20291,specification-spec-token-reuse--bfc74a74"]
+// glassware[type="implementation", id="impl-cli-storage-distributed--54f8febe", specifications="specification-spec-storage-dir--54adedf5,specification-spec-create-storage-dir--29d5746d,specification-spec-nodefs-adapter--55a00910,specification-spec-storage-path-config--26888df2"]
+// glassware[type="implementation", id="impl-cli-ws-storage--bb831726", requirements="requirement-cli-ws-storage-location--5691bb5c,requirement-cli-ws-storage-hash--940b982f,requirement-cli-ws-storage-save--e11dd16d,requirement-cli-ws-storage-get--fbbcc532,requirement-cli-ws-storage-remove--05267ecd,requirement-cli-ws-storage-list--f900c191,requirement-cli-ws-storage-atomic--732eb2e0,requirement-cli-ws-storage-permissions--68c455f2"]
+// spec: packages/mod-cli/specs/workspaces.md
 import fs from 'fs';
 import path from 'path';
 import crypto from 'crypto';
@@ -71,6 +74,7 @@ export function writeConfig(config) {
     const configPath = getConfigPath();
     atomicWrite(configPath, JSON.stringify(config, null, 2), 0o600);
 }
+// glassware[type="implementation", id="impl-cli-ws-storage-hash--7647b959", requirements="requirement-cli-ws-storage-hash--940b982f,requirement-cli-init-app-6--aa3c1ace"]
 /**
  * Get the path to a workspace connection file for a directory.
  * Uses SHA-256 hash of the absolute path (first 16 chars).
@@ -84,6 +88,7 @@ export function getWorkspaceConnectionPath(directoryPath) {
         .slice(0, 16);
     return path.join(getModDir(), 'workspaces', hash);
 }
+// glassware[type="implementation", id="impl-cli-ws-storage-get--bce2619c", requirements="requirement-cli-ws-storage-get--fbbcc532"]
 /**
  * Read the workspace connection for a directory.
  * Returns null if no connection exists.
@@ -102,6 +107,7 @@ export function readWorkspaceConnection(directoryPath) {
         return null;
     }
 }
+// glassware[type="implementation", id="impl-cli-ws-storage-save--352ee3cc", requirements="requirement-cli-ws-storage-save--e11dd16d,requirement-cli-ws-storage-atomic--732eb2e0,requirement-cli-ws-storage-permissions--68c455f2,requirement-cli-init-qual-3--fc1e8a03"]
 /**
  * Write a workspace connection for a directory atomically.
  */
@@ -110,6 +116,7 @@ export function writeWorkspaceConnection(directoryPath, connection) {
     const connectionPath = getWorkspaceConnectionPath(directoryPath);
     atomicWrite(connectionPath, JSON.stringify(connection, null, 2), 0o600);
 }
+// glassware[type="implementation", id="impl-cli-ws-storage-remove--7923bc01", requirements="requirement-cli-ws-storage-remove--05267ecd"]
 /**
  * Delete the workspace connection for a directory.
  */
@@ -127,9 +134,12 @@ export function deleteWorkspaceConnection(directoryPath) {
         return false;
     }
 }
+// glassware[type="implementation", id="impl-cli-ws-storage-list--00734c67", requirements="requirement-cli-ws-storage-list--f900c191,requirement-cli-init-data-0--d659ea61,requirement-cli-init-int-3--ada97918"]
 /**
  * List all workspace connections.
  * Returns array of connections, filtering out corrupted files.
+ * Workspace connections map local directories to workspaces (data-0).
+ * Connection visible to sync daemon for directory lookup (int-3).
  */
 export function listWorkspaceConnections() {
     const workspacesDir = path.join(getModDir(), 'workspaces');