isomorphic-jj 1.0.0

package/src/core/working-copy.js

@@ -0,0 +1,314 @@
+/**
+ * WorkingCopy - Manages working copy state and file tracking
+ * 
+ * Tracks file states (mtime, size, mode) for efficient modification detection.
+ */
+
+import { JJError } from '../utils/errors.js';
+import { validateChangeId, validatePath } from '../utils/validation.js';
+
+export class WorkingCopy {
+  /**
+   * @param {Storage} storage - Storage manager instance
+   * @param {Object} fs - Filesystem implementation
+   * @param {string} dir - Repository directory
+   * @param {string} [workspaceId='default'] - Workspace identifier
+   */
+  constructor(storage, fs, dir, workspaceId = 'default') {
+    this.storage = storage;
+    this.fs = fs;
+    this.dir = dir;
+    this.workspaceId = workspaceId;
+    this.state = null;
+  }
+
+  /**
+   * Initialize working copy state
+   *
+   * @param {string} changeId - Initial change ID
+   * @param {string} [operationId] - Operation ID that created this state
+   */
+  async init(changeId, operationId = '') {
+    validateChangeId(changeId);
+
+    this.state = {
+      version: 1,
+      workspaceId: this.workspaceId,
+      changeId,
+      operation: operationId,
+      fileStates: {},
+      sparsePatterns: [], // Empty array = full checkout
+    };
+
+    await this.save();
+  }
+
+  /**
+   * Load working copy state from storage
+   *
+   * Workspace-specific path: working_copy/workspace_id/state.json
+   */
+  async load() {
+    const workspacePath = `working_copy/${this.workspaceId}/state.json`;
+    const data = await this.storage.read(workspacePath);
+
+    if (!data) {
+      throw new JJError('STORAGE_CORRUPT', `${workspacePath} not found`, {
+        suggestion: 'Initialize repository with init()',
+        workspaceId: this.workspaceId,
+      });
+    }
+
+    if (data.version !== 1) {
+      throw new JJError(
+        'STORAGE_VERSION_MISMATCH',
+        `Unsupported working copy version: ${data.version}`,
+        {
+          version: data.version,
+          suggestion: 'Upgrade isomorphic-jj or run migration tool',
+        }
+      );
+    }
+
+    this.state = data;
+  }
+
+  /**
+   * Save working copy state to storage
+   *
+   * Workspace-specific path: working_copy/workspace_id/state.json
+   */
+  async save() {
+    const workspacePath = `working_copy/${this.workspaceId}/state.json`;
+    await this.storage.write(workspacePath, this.state);
+  }
+
+  /**
+   * Get current working copy state
+   * 
+   * @returns {Object} Working copy state
+   */
+  async getState() {
+    if (!this.state) {
+      await this.load();
+    }
+    return this.state;
+  }
+
+  /**
+   * Get current change ID
+   * 
+   * @returns {string} Current change ID
+   */
+  getCurrentChangeId() {
+    if (!this.state) {
+      throw new JJError('WORKING_COPY_NOT_LOADED', 'Working copy state not loaded', {
+        suggestion: 'Call load() or init() first',
+      });
+    }
+    return this.state.changeId;
+  }
+
+  /**
+   * Set current change ID
+   * 
+   * @param {string} changeId - New change ID
+   */
+  async setCurrentChange(changeId) {
+    validateChangeId(changeId);
+
+    if (!this.state) {
+      await this.load();
+    }
+
+    this.state.changeId = changeId;
+    await this.save();
+  }
+
+  /**
+   * Track a file in the working copy
+   * 
+   * @param {string} path - File path relative to repo root
+   * @param {Object} fileState - File state (mtime, size, mode, hash)
+   */
+  async trackFile(path, fileState) {
+    validatePath(path);
+
+    if (!this.state) {
+      await this.load();
+    }
+
+    this.state.fileStates[path] = fileState;
+    await this.save();
+  }
+
+  /**
+   * Untrack a file from the working copy
+   * 
+   * @param {string} path - File path to untrack
+   */
+  async untrackFile(path) {
+    validatePath(path);
+
+    if (!this.state) {
+      await this.load();
+    }
+
+    delete this.state.fileStates[path];
+    await this.save();
+  }
+
+  /**
+   * Get list of modified files
+   * 
+   * Uses mtime + size comparison for fast detection.
+   * 
+   * @returns {Promise<Array<string>>} Array of modified file paths
+   */
+  async getModifiedFiles() {
+    if (!this.state) {
+      await this.load();
+    }
+
+    const modified = [];
+
+    for (const [path, tracked] of Object.entries(this.state.fileStates)) {
+      const fullPath = `${this.dir}/${path}`;
+
+      try {
+        const stats = await this.fs.promises.stat(fullPath);
+
+        // Fast path: check mtime and size
+        if (stats.mtime !== tracked.mtime || stats.size !== tracked.size) {
+          modified.push(path);
+        }
+      } catch (error) {
+        if (error.code === 'ENOENT') {
+          // File was deleted
+          modified.push(path);
+        } else {
+          throw new JJError('STORAGE_READ_FAILED', `Failed to stat ${path}: ${error.message}`, {
+            path: fullPath,
+            originalError: error,
+          });
+        }
+      }
+    }
+
+    return modified;
+  }
+
+  /**
+   * List all tracked files in working copy
+   *
+   * @returns {Promise<Array<string>>} Array of tracked file paths
+   */
+  async listFiles() {
+    if (!this.state) {
+      await this.load();
+    }
+
+    return Object.keys(this.state.fileStates);
+  }
+
+  /**
+   * Clear all file states
+   */
+  async clearFileStates() {
+    if (!this.state) {
+      await this.load();
+    }
+
+    this.state.fileStates = {};
+    await this.save();
+  }
+
+  /**
+   * Get sparse patterns
+   *
+   * @returns {string[]} Array of sparse patterns
+   */
+  getSparsePatterns() {
+    if (!this.state) {
+      throw new JJError('WORKING_COPY_NOT_LOADED', 'Working copy state not loaded', {
+        suggestion: 'Call load() or init() first',
+      });
+    }
+
+    // Return empty array if not set (full checkout)
+    return this.state.sparsePatterns || [];
+  }
+
+  /**
+   * Set sparse patterns
+   *
+   * @param {string[]} patterns - Array of sparse patterns
+   */
+  async setSparsePatterns(patterns) {
+    if (!this.state) {
+      await this.load();
+    }
+
+    this.state.sparsePatterns = patterns;
+    // Note: save() is called by the caller (repository API)
+  }
+
+  /**
+   * Check if a file path matches sparse patterns
+   *
+   * @param {string} filePath - File path to check
+   * @returns {boolean} True if file should be materialized
+   */
+  matchesSparsePatterns(filePath) {
+    const patterns = this.getSparsePatterns();
+
+    // Empty patterns = full checkout (all files match)
+    if (patterns.length === 0) {
+      return true;
+    }
+
+    // Check if file matches any pattern
+    for (const pattern of patterns) {
+      if (this._matchesPattern(filePath, pattern)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Simple glob pattern matching
+   *
+   * @private
+   * @param {string} path - File path
+   * @param {string} pattern - Glob pattern
+   * @returns {boolean} True if path matches pattern
+   */
+  _matchesPattern(path, pattern) {
+    // Exact match
+    if (path === pattern) {
+      return true;
+    }
+
+    // Directory match (pattern ending with /)
+    if (pattern.endsWith('/') && path.startsWith(pattern)) {
+      return true;
+    }
+
+    // Glob patterns
+    if (pattern.includes('*')) {
+      // Convert glob to regex
+      const regexPattern = pattern
+        .replace(/\./g, '\\.')
+        .replace(/\*\*/g, '___DOUBLESTAR___')
+        .replace(/\*/g, '[^/]*')
+        .replace(/___DOUBLESTAR___/g, '.*');
+
+      const regex = new RegExp(`^${regexPattern}$`);
+      return regex.test(path);
+    }
+
+    return false;
+  }
+}

package/src/core/workspace-manager.js

@@ -0,0 +1,283 @@
+/**
+ * WorkspaceManager - Manages multiple working copies (JJ workspaces)
+ *
+ * Allows multiple independent working directories to coexist,
+ * each pointing to different changes in the repository.
+ *
+ * Note: JJ calls these "workspaces" not "worktrees" (Git terminology).
+ */
+
+import { JJError } from '../utils/errors.js';
+import { validateChangeId, validatePath } from '../utils/validation.js';
+import { generateId } from '../utils/id-generation.js';
+import path from 'path';
+
+export class WorkspaceManager {
+  /**
+   * @param {Storage} storage - Storage manager instance
+   * @param {Object} fs - Filesystem implementation
+   * @param {string} repoDir - Repository directory
+   */
+  constructor(storage, fs, repoDir) {
+    this.storage = storage;
+    this.fs = fs;
+    this.repoDir = repoDir;
+    this.workspaces = new Map(); // workspaceId -> Workspace
+  }
+
+  /**
+   * Initialize workspace manager
+   */
+  async init() {
+    // Create default workspace (main working copy)
+    const defaultWorkspace = {
+      id: 'default',
+      name: 'default',
+      path: this.repoDir,
+      changeId: null,
+      created: new Date().toISOString(),
+    };
+
+    this.workspaces.set('default', defaultWorkspace);
+    await this.save();
+  }
+
+  /**
+   * Load workspaces from storage
+   */
+  async load() {
+    try {
+      const data = await this.storage.read('repo/store/workspaces.json');
+      if (data) {
+        this.workspaces = new Map(Object.entries(data.workspaces || {}));
+      }
+    } catch (error) {
+      // No workspaces file yet, initialize with default
+      await this.init();
+    }
+  }
+
+  /**
+   * Save workspaces to storage
+   */
+  async save() {
+    const data = {
+      workspaces: Object.fromEntries(this.workspaces),
+    };
+    await this.storage.write('repo/store/workspaces.json', data);
+  }
+
+  /**
+   * Add a new workspace
+   *
+   * @param {Object} args - Workspace options
+   * @param {string} args.path - Path for the new workspace
+   * @param {string} [args.name] - Optional name for the workspace
+   * @param {string} [args.changeId] - Change to check out in new workspace
+   * @returns {Promise<Object>} Created workspace
+   */
+  async add(args) {
+    if (!args || !args.path) {
+      throw new JJError('INVALID_ARGUMENT', 'Missing path for workspace', {
+        suggestion: 'Provide a path for the new workspace',
+      });
+    }
+
+    // Workspace paths can be absolute (unlike regular file paths)
+    // Just validate changeId if provided
+    if (args.changeId) {
+      validateChangeId(args.changeId);
+    }
+
+    // Check if path already exists as a workspace
+    for (const workspace of this.workspaces.values()) {
+      if (workspace.path === args.path) {
+        throw new JJError('WORKSPACE_EXISTS', `Workspace already exists at ${args.path}`, {
+          path: args.path,
+        });
+      }
+    }
+
+    const workspaceId = generateId('workspace');
+    const workspace = {
+      id: workspaceId,
+      name: args.name || `workspace-${workspaceId.slice(0, 8)}`,
+      path: args.path,
+      changeId: args.changeId || null,
+      created: new Date().toISOString(),
+    };
+
+    // Create workspace directory
+    await this.fs.promises.mkdir(args.path, { recursive: true });
+
+    // Create workspace-specific working_copy directory in .jj
+    const workspaceCopyDir = path.join(this.repoDir, '.jj', 'working_copy', workspaceId);
+    await this.fs.promises.mkdir(workspaceCopyDir, { recursive: true });
+
+    // Create .git file pointing to main repo's .git directory
+    // This allows Git tools to work in the workspace
+    // IMPORTANT: Must use absolute paths for Git compatibility
+    const gitFilePath = path.join(args.path, '.git');
+    const mainGitDir = path.resolve(this.repoDir, '.git');
+    const gitFileContent = `gitdir: ${mainGitDir}\n`;
+    await this.fs.promises.writeFile(gitFilePath, gitFileContent, 'utf8');
+
+    // Create .jj file pointing to main repo's .jj directory
+    // This allows JJ tools to work in the workspace
+    // IMPORTANT: Must use absolute paths for JJ CLI compatibility
+    const jjFilePath = path.join(args.path, '.jj');
+    const mainJJDir = path.resolve(this.repoDir, '.jj');
+    const jjFileContent = `jjdir: ${mainJJDir}\n`;
+    await this.fs.promises.writeFile(jjFilePath, jjFileContent, 'utf8');
+
+    this.workspaces.set(workspaceId, workspace);
+    await this.save();
+
+    return workspace;
+  }
+
+  /**
+   * Remove a workspace
+   *
+   * @param {string} workspaceId - Workspace ID to remove
+   * @param {boolean} [force=false] - Force removal even if files exist
+   */
+  async remove(workspaceId, force = false) {
+    if (workspaceId === 'default') {
+      throw new JJError('INVALID_OPERATION', 'Cannot remove default workspace', {
+        suggestion: 'Use a different workspace ID',
+      });
+    }
+
+    const workspace = this.workspaces.get(workspaceId);
+    if (!workspace) {
+      throw new JJError('WORKSPACE_NOT_FOUND', `Workspace ${workspaceId} not found`, {
+        workspaceId,
+      });
+    }
+
+    // Check if directory is empty (unless force is true)
+    if (!force) {
+      try {
+        const files = await this.fs.promises.readdir(workspace.path);
+        if (files.length > 0) {
+          throw new JJError('WORKSPACE_NOT_EMPTY', `Workspace at ${workspace.path} is not empty`, {
+            path: workspace.path,
+            suggestion: 'Use force=true to remove anyway',
+          });
+        }
+      } catch (error) {
+        if (error.code !== 'ENOENT') {
+          throw error;
+        }
+      }
+    }
+
+    // Remove the workspace directory and all its contents
+    try {
+      await this.fs.promises.rm(workspace.path, { recursive: true, force: true });
+    } catch (error) {
+      // Ignore errors if directory doesn't exist
+      if (error.code !== 'ENOENT') {
+        throw new JJError(
+          'WORKSPACE_REMOVAL_FAILED',
+          `Failed to remove workspace directory: ${error.message}`,
+          { path: workspace.path, originalError: error.message }
+        );
+      }
+    }
+
+    this.workspaces.delete(workspaceId);
+    await this.save();
+  }
+
+  /**
+   * Forget a workspace without deleting files
+   *
+   * @param {string} workspaceId - Workspace ID to forget
+   */
+  async forget(workspaceId) {
+    if (workspaceId === 'default') {
+      throw new JJError('INVALID_OPERATION', 'Cannot forget default workspace', {
+        suggestion: 'Use a different workspace ID',
+      });
+    }
+
+    const workspace = this.workspaces.get(workspaceId);
+    if (!workspace) {
+      throw new JJError('WORKSPACE_NOT_FOUND', `Workspace ${workspaceId} not found`, {
+        workspaceId,
+      });
+    }
+
+    // Just remove from tracking, leave files alone
+    this.workspaces.delete(workspaceId);
+    await this.save();
+  }
+
+  /**
+   * Get a workspace by ID
+   *
+   * @param {string} workspaceId - Workspace ID
+   * @returns {Object|undefined} Workspace object
+   */
+  get(workspaceId) {
+    return this.workspaces.get(workspaceId);
+  }
+
+  /**
+   * Get workspace by path
+   *
+   * @param {string} path - Workspace path
+   * @returns {Object|null} Workspace object or null
+   */
+  getByPath(path) {
+    for (const workspace of this.workspaces.values()) {
+      if (workspace.path === path) {
+        return workspace;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * List all workspaces
+   *
+   * @returns {Array<Object>} Array of workspaces
+   */
+  list() {
+    return Array.from(this.workspaces.values());
+  }
+
+  /**
+   * Update a workspace's change
+   *
+   * @param {string} workspaceId - Workspace ID
+   * @param {string} changeId - New change ID
+   */
+  async updateChange(workspaceId, changeId) {
+    validateChangeId(changeId);
+
+    const workspace = this.workspaces.get(workspaceId);
+    if (!workspace) {
+      throw new JJError('WORKSPACE_NOT_FOUND', `Workspace ${workspaceId} not found`, {
+        workspaceId,
+      });
+    }
+
+    workspace.changeId = changeId;
+    await this.save();
+  }
+
+  /**
+   * Clear all workspaces (except default)
+   */
+  async clear() {
+    const defaultWorkspace = this.workspaces.get('default');
+    this.workspaces.clear();
+    if (defaultWorkspace) {
+      this.workspaces.set('default', defaultWorkspace);
+    }
+    await this.save();
+  }
+}