isomorphic-jj 1.1.3 → 1.3.0

package/dist/index.mjs

@@ -1309,6 +1309,7 @@ class BookmarkStore {
     this.storage = storage;
     this.local = new Map();
     this.remote = new Map(); // remote → (bookmark → changeId)
+    this.tracking = {}; // bookmark → { remote, ref } tracking info (v0.35.0)
   }
 
   /**
@@ -1351,6 +1352,7 @@ class BookmarkStore {
 
     this.local.clear();
     this.remote.clear();
+    this.tracking = data.tracked || {}; // Load tracking info (v0.35.0)
 
     // Load local bookmarks
     for (const [name, target] of Object.entries(data.local)) {
@@ -1388,7 +1390,7 @@ class BookmarkStore {
       version: 1,
       local,
       remote,
-      tracked: {},
+      tracked: this.tracking || {}, // Save tracking info (v0.35.0)
     });
   }
 
@@ -1501,13 +1503,23 @@ class BookmarkStore {
   async list() {
     const result = [];
 
-    // Add local bookmarks
+    // Add local bookmarks with tracking info (v0.35.0)
     for (const [name, target] of this.local.entries()) {
-      result.push({
+      const bookmark = {
         name,
         changeId: target,
         remote: null,
-      });
+      };
+
+      // Include tracking info if available
+      if (this.tracking && this.tracking[name]) {
+        bookmark.tracking = {
+          remote: this.tracking[name].remote,
+          ref: this.tracking[name].remoteName || name,
+        };
+      }
+
+      result.push(bookmark);
     }
 
     // Add remote bookmarks
@@ -1829,6 +1841,24 @@ class RevsetEngine {
       }
     }
 
+    // v0.36.0: visible() - non-abandoned changes
+    if (trimmed === 'visible()') {
+      await this.graph.load();
+      const all = this.graph.getAll();
+      return all
+        .filter(c => !c.abandoned)
+        .map(c => c.changeId);
+    }
+
+    // v0.36.0: hidden() - abandoned changes
+    if (trimmed === 'hidden()') {
+      await this.graph.load();
+      const all = this.graph.getAll();
+      return all
+        .filter(c => c.abandoned === true)
+        .map(c => c.changeId);
+    }
+
     // ancestors(changeId) - all ancestors including the change itself
     const ancestorsMatch = trimmed.match(/^ancestors\(([0-9a-f]{32})\)$/);
     if (ancestorsMatch) {
@@ -4276,9 +4306,15 @@ class UserConfig {
   }
 
   /**
-   * Load config from storage
+   * Load config from storage and/or programmatic object
+   * v0.35.0: Also loads workspace-specific config from workspace-config.json
+   * v0.36.0: Accepts optional config object for programmatic configuration
+   *
+   * @param {Object} [opts] - Optional config options
+   * @param {Object} [opts.workspace] - Workspace-specific config to merge (highest priority)
+   * @param {Object} [opts.override] - Config object to merge over loaded config
    */
-  async load() {
+  async load(opts = {}) {
     try {
       const data = await this.storage.read('config.json');
       if (data) {
@@ -4288,6 +4324,45 @@ class UserConfig {
       // No config file yet, use defaults
       await this.init();
     }
+
+    // Merge programmatic override config if provided
+    if (opts.override) {
+      this.config = this._deepMerge(this.config, opts.override);
+    }
+
+    // Load workspace-specific config from file (v0.35.0)
+    try {
+      const workspaceData = await this.storage.read('workspace-config.json');
+      if (workspaceData) {
+        // Merge workspace config over global config (workspace takes precedence)
+        this.config = this._deepMerge(this.config, workspaceData);
+      }
+    } catch (error) {
+      // No workspace config, that's fine
+    }
+
+    // Merge programmatic workspace config if provided (highest priority)
+    if (opts.workspace) {
+      this.config = this._deepMerge(this.config, opts.workspace);
+    }
+  }
+
+  /**
+   * Deep merge two config objects (workspace overrides global)
+   * @private
+   */
+  _deepMerge(target, source) {
+    const result = { ...target };
+
+    for (const key in source) {
+      if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+        result[key] = this._deepMerge(target[key] || {}, source[key]);
+      } else {
+        result[key] = source[key];
+      }
+    }
+
+    return result;
   }
 
   /**
@@ -6216,69 +6291,116 @@ async function createJJ(options) {
      * @param {string[]} [args.paths] - Paths to move between changes (for history operations)
      * @returns {Promise<Object>} Returns change object for history operations, file info for file operations
      */
-    async move(args) {
-      if (!args || typeof args !== 'object') {
-        throw new JJError('INVALID_ARGUMENT', 'Missing or invalid arguments', {
-          suggestion: 'Use file.move({ from, to }) for files or rebase({ changeId, newParent }) for history',
+    /**
+     * Move a file in the working copy
+     *
+     * @param {Object} args - Move file arguments
+     * @param {string} args.from - Source file path
+     * @param {string} args.to - Destination file path
+     * @returns {Promise<Object>} Operation result including from, to paths and file stats
+     */
+    async moveFile(args) {
+      if (!args.from || typeof args.from !== 'string') {
+        throw new JJError('INVALID_ARGUMENT', 'Missing or invalid from path', {
+          suggestion: 'Provide a valid source file path',
+          provided: { from: args.from, type: typeof args.from },
         });
       }
 
-      // Detect operation type based on arguments
-      const isHistoryOp = this._detectHistoryOperation(args);
+      if (!args.to || typeof args.to !== 'string') {
+        throw new JJError('INVALID_ARGUMENT', 'Missing or invalid to path', {
+          suggestion: 'Provide a valid destination file path',
+          provided: { to: args.to, type: typeof args.to },
+        });
+      }
 
-      if (isHistoryOp) {
-        return await this._moveChange(args);
-      } else {
-        return await this._moveFile(args);
+      // Prevent moving to the same location
+      if (args.from === args.to) {
+        throw new JJError('INVALID_OPERATION', 'Source and destination paths are the same', {
+          path: args.from,
+          suggestion: 'Specify a different destination path',
+        });
       }
-    },
 
-    /**
-     * Detect if move operation is for history (rebase) or files
-     *
-     * @private
-     * @param {Object} args - Move arguments
-     * @returns {boolean} True if history operation, false if file operation
-     */
-    _detectHistoryOperation(args) {
-      // Explicit history operation indicators
-      if (args.paths || args.changeId || args.newParent) {
-        return true;
+      // Prevent absolute paths
+      if (args.from.startsWith('/') || args.to.startsWith('/')) {
+        throw new JJError('INVALID_PATH', 'Absolute paths are not allowed', {
+          suggestion: 'Use paths relative to the repository root',
+          provided: { from: args.from, to: args.to },
+        });
       }
 
-      // If only from/to are present, check if they look like change IDs
-      if (args.from && args.to && !args.changeId && !args.newParent && !args.paths) {
-        // Change IDs are 32-character hex strings
-        const changeIdPattern = /^[0-9a-f]{32}$/;
-        const fromLooksLikeChangeId = changeIdPattern.test(args.from);
-        const toLooksLikeChangeId = changeIdPattern.test(args.to);
+      // Prevent parent directory traversal
+      if (args.from.includes('..') || args.to.includes('..')) {
+        throw new JJError('INVALID_PATH', 'Parent directory traversal (..) is not allowed', {
+          suggestion: 'Use paths within the repository',
+          provided: { from: args.from, to: args.to },
+        });
+      }
 
-        // If both look like change IDs, it's likely a history operation
-        // However, we err on the side of file operations to be safe
-        // Users should use explicit { changeId, newParent } for clarity
-        if (fromLooksLikeChangeId && toLooksLikeChangeId) {
-          // This is ambiguous - throw a helpful error
-          throw new JJError('AMBIGUOUS_OPERATION',
-            'Ambiguous move operation: arguments look like change IDs', {
-            suggestion: 'Use { changeId, newParent } for history operations or ensure file paths don\'t match change ID pattern',
-            args,
-          });
-        }
+      const fromPath = `${dir}/${args.from}`;
+      const toPath = `${dir}/${args.to}`;
 
-        return false; // Treat as file operation
+      // Check if source file exists
+      try {
+        await fs.promises.stat(fromPath);
+      } catch (error) {
+        throw new JJError('FILE_NOT_FOUND', `Source file not found: ${args.from}`, {
+          path: args.from,
+          suggestion: 'Check that the source file exists',
+        });
       }
 
-      return false;
+      // Ensure destination directory exists
+      const toDir = toPath.substring(0, toPath.lastIndexOf('/'));
+      try {
+        await fs.promises.mkdir(toDir, { recursive: true });
+      } catch (error) {
+        throw new JJError('FILE_SYSTEM_ERROR', `Failed to create destination directory: ${error.message}`, {
+          path: toDir,
+          error: error.message,
+        });
+      }
+
+      // Move the file
+      try {
+        await fs.promises.rename(fromPath, toPath);
+      } catch (error) {
+        throw new JJError('FILE_SYSTEM_ERROR', `Failed to move file: ${error.message}`, {
+          from: args.from,
+          to: args.to,
+          error: error.message,
+        });
+      }
+
+      // Update working copy tracking
+      await workingCopy.load();
+      await workingCopy.untrackFile(args.from);
+      const stats = await fs.promises.stat(toPath);
+      await workingCopy.trackFile(args.to, {
+        mtime: stats.mtime,
+        size: stats.size,
+        mode: stats.mode,
+      });
+
+      return {
+        from: args.from,
+        to: args.to,
+        size: stats.size,
+        mode: stats.mode,
+        mtime: stats.mtime,
+      };
     },
 
     /**
-     * Move/rebase a change to a new parent (history operation)
+     * Move (rebase) a change to a new parent
      *
-     * @private
-     * @param {Object} args - Move arguments
+     * @param {Object} args - Move change arguments
+     * @param {string} args.changeId - Change ID to move (also accepts 'from' or 'source')
+     * @param {string} args.newParent - New parent change ID (also accepts 'to' or 'destination')
      * @returns {Promise<Object>} Updated change object
      */
-    async _moveChange(args) {
+    async moveChange(args) {
       await graph.load();
 
       // Support multiple parameter names for flexibility
@@ -6366,110 +6488,62 @@ async function createJJ(options) {
     },
 
     /**
-     * Move/rename a file in the working copy (file operation)
-     *
-     * @private
-     * @param {Object} args - Move arguments
-     * @returns {Promise<Object>} Operation result including from, to paths and file stats
+     * @deprecated Use moveFile() for files or moveChange() for history operations
+     * Move operation - delegates to moveFile or moveChange based on arguments
      */
-    async _moveFile(args) {
-      if (!args.from || typeof args.from !== 'string') {
-        throw new JJError('INVALID_ARGUMENT', 'Missing or invalid from path', {
-          suggestion: 'Provide a valid source file path',
-          provided: { from: args.from, type: typeof args.from },
-        });
-      }
-
-      if (!args.to || typeof args.to !== 'string') {
-        throw new JJError('INVALID_ARGUMENT', 'Missing or invalid to path', {
-          suggestion: 'Provide a valid destination file path',
-          provided: { to: args.to, type: typeof args.to },
+    async move(args) {
+      if (!args || typeof args !== 'object') {
+        throw new JJError('INVALID_ARGUMENT', 'Missing or invalid arguments', {
+          suggestion: 'Use moveFile({ from, to }) for files or moveChange({ changeId, newParent }) for history',
         });
       }
 
-      // Prevent moving to the same location
-      if (args.from === args.to) {
-        throw new JJError('INVALID_OPERATION', 'Source and destination paths are the same', {
-          path: args.from,
-          suggestion: 'Specify a different destination path',
-        });
-      }
+      // Detect operation type based on arguments
+      const isHistoryOp = this._detectHistoryOperation(args);
 
-      // Prevent absolute paths
-      if (args.from.startsWith('/') || args.to.startsWith('/')) {
-        throw new JJError('INVALID_PATH', 'Absolute paths are not allowed', {
-          suggestion: 'Use paths relative to the repository root',
-          provided: { from: args.from, to: args.to },
-        });
+      if (isHistoryOp) {
+        return await this.moveChange(args);
+      } else {
+        return await this.moveFile(args);
       }
+    },
 
-      // Prevent parent directory traversal
-      if (args.from.includes('..') || args.to.includes('..')) {
-        throw new JJError('INVALID_PATH', 'Parent directory traversal (..) is not allowed', {
-          suggestion: 'Use paths within the repository',
-          provided: { from: args.from, to: args.to },
-        });
+    /**
+     * Detect if move operation is for history (rebase) or files
+     *
+     * @private
+     * @param {Object} args - Move arguments
+     * @returns {boolean} True if history operation, false if file operation
+     */
+    _detectHistoryOperation(args) {
+      // Explicit history operation indicators
+      if (args.paths || args.changeId || args.newParent) {
+        return true;
       }
 
-      const fromPath = `${dir}/${args.from}`;
-      const toPath = `${dir}/${args.to}`;
-
-      // Check if source file exists
-      try {
-        await fs.promises.access(fromPath);
-      } catch (error) {
-        throw new JJError('FILE_NOT_FOUND', `Source file not found: ${args.from}`, {
-          path: args.from,
-          fullPath: fromPath,
-          suggestion: 'Check that the file exists',
-        });
-      }
+      // If only from/to are present, check if they look like change IDs
+      if (args.from && args.to && !args.changeId && !args.newParent && !args.paths) {
+        // Change IDs are 32-character hex strings
+        const changeIdPattern = /^[0-9a-f]{32}$/;
+        const fromLooksLikeChangeId = changeIdPattern.test(args.from);
+        const toLooksLikeChangeId = changeIdPattern.test(args.to);
 
-      // Ensure destination directory exists
-      const pathParts = args.to.split('/');
-      if (pathParts.length > 1) {
-        const dirPath = pathParts.slice(0, -1).join('/');
-        const fullDirPath = `${dir}/${dirPath}`;
-        try {
-          await fs.promises.mkdir(fullDirPath, { recursive: true });
-        } catch (error) {
-          throw new JJError('DIRECTORY_CREATE_FAILED',
-            `Failed to create destination directory: ${dirPath}`, {
-            directory: dirPath,
-            originalError: error.message,
+        // If both look like change IDs, it's likely a history operation
+        // However, we err on the side of file operations to be safe
+        // Users should use explicit { changeId, newParent } for clarity
+        if (fromLooksLikeChangeId && toLooksLikeChangeId) {
+          // This is ambiguous - throw a helpful error
+          throw new JJError('AMBIGUOUS_OPERATION',
+            'Ambiguous move operation: arguments look like change IDs', {
+            suggestion: 'Use { changeId, newParent } for history operations or ensure file paths don\'t match change ID pattern',
+            args,
           });
         }
-      }
 
-      // Move the file
-      try {
-        await fs.promises.rename(fromPath, toPath);
-      } catch (error) {
-        throw new JJError('FILE_MOVE_FAILED', `Failed to move file: ${error.message}`, {
-          from: args.from,
-          to: args.to,
-          originalError: error.message,
-        });
+        return false; // Treat as file operation
       }
 
-      // Update working copy tracking
-      await workingCopy.load();
-      await workingCopy.untrackFile(args.from);
-      const stats = await fs.promises.stat(toPath);
-      await workingCopy.trackFile(args.to, {
-        mtime: stats.mtime,
-        size: stats.size,
-        mode: stats.mode,
-      });
-
-      // Return useful information about the move operation
-      return {
-        from: args.from,
-        to: args.to,
-        size: stats.size,
-        mode: stats.mode,
-        mtime: stats.mtime,
-      };
+      return false;
     },
 
     /**
@@ -7014,7 +7088,8 @@ async function createJJ(options) {
      * @param {Object} args - Arguments
      * @param {string} [args.revset='all()'] - Revset expression to filter changes
      * @param {number} [args.limit] - Maximum number of changes to return
-     * @returns {Promise<Array>} Array of changes
+     * @param {boolean} [args.count=false] - If true, return count instead of changes (v0.36.0)
+     * @returns {Promise<Array|number>} Array of changes or count if args.count is true
      */
     async log(args = {}) {
       await graph.load();
@@ -7023,6 +7098,11 @@ async function createJJ(options) {
       const revsetExpr = args.revset || 'all()';
       const changeIds = await revset.evaluate(revsetExpr);
 
+      // If count mode, return count early (v0.36.0 feature)
+      if (args.count) {
+        return changeIds.length;
+      }
+
       let changes = [];
       for (const changeId of changeIds) {
         const change = await graph.getChange(changeId);
@@ -7970,7 +8050,7 @@ async function createJJ(options) {
      * });
      */
     async rebase(args) {
-      return await this._moveChange(args);
+      return await this.moveChange(args);
     },
 
     /**
@@ -8043,9 +8123,18 @@ async function createJJ(options) {
      * @returns {Promise<Object>} The new backout change including changeId, description, and backedOut field
      */
     async backout(args) {
+      // Normalize: accept common parameter aliases
+      if (args && args.change && !args.revision) {
+        args = { ...args, revision: args.change };
+      } else if (args && args.changeId && !args.revision) {
+        args = { ...args, revision: args.changeId };
+      } else if (args && args.target && !args.revision) {
+        args = { ...args, revision: args.target };
+      }
+
       if (!args || !args.revision) {
         throw new JJError('INVALID_ARGUMENT', 'Missing revision argument', {
-          suggestion: 'Provide the change ID to back out: { revision: "abc123..." }',
+          suggestion: 'Provide the change ID to back out: { revision: "abc123..." } (or use change/changeId/target)',
         });
       }
 
@@ -9080,6 +9169,15 @@ async function createJJ(options) {
      * @param {string[]} [args.paths] - Specific paths to include in first split (full implementation planned for future)
      */
     async split(args) {
+      // Normalize: accept common parameter aliases
+      if (args && args.change && !args.changeId) {
+        args = { ...args, changeId: args.change };
+      } else if (args && args.revision && !args.changeId) {
+        args = { ...args, changeId: args.revision };
+      } else if (args && args.target && !args.changeId) {
+        args = { ...args, changeId: args.target };
+      }
+
       // Check for interactive mode (not supported)
       if (args.interactive) {
         throw new JJError(
@@ -11321,21 +11419,13 @@ async function createJJ(options) {
           });
         }
 
-        await userConfig.load();
-
-        // Handle nested keys (e.g., 'user.name')
-        const parts = key.split('.');
-        let value = userConfig.config;
-
-        for (const part of parts) {
-          if (value && typeof value === 'object') {
-            value = value[part];
-          } else {
-            return null;
-          }
+        // Ensure config is loaded at least once
+        if (!userConfig.config) {
+          await userConfig.load();
         }
 
-        return value;
+        // Use userConfig.get() to preserve programmatic config
+        return userConfig.get(key);
       },
 
       /**
@@ -11384,6 +11474,87 @@ async function createJJ(options) {
         await userConfig.load();
         return userConfig.config;
       },
+
+      /**
+       * Reload configuration (including workspace-specific config)
+       * v0.35.0: Loads workspace-config.json if present
+       * v0.36.0: Accepts optional config object for programmatic configuration
+       *
+       * @param {Object} [opts] - Optional config options
+       * @param {Object} [opts.workspace] - Workspace-specific config to merge (highest priority)
+       * @param {Object} [opts.override] - Config object to merge over loaded config
+       * @returns {Promise<void>}
+       *
+       * @example
+       * // Load from files only
+       * await repo.config.load();
+       *
+       * @example
+       * // Programmatic workspace config (no file I/O needed)
+       * await repo.config.load({
+       *   workspace: { user: { email: 'test@example.com' } }
+       * });
+       *
+       * @example
+       * // Override global config programmatically
+       * await repo.config.load({
+       *   override: { test: { value: 'override' } }
+       * });
+       */
+      async load(opts) {
+        await userConfig.load(opts);
+      },
+    },
+
+    /**
+     * Template helper functions (v0.36.0)
+     *
+     * Utilities for displaying and formatting JJ data
+     */
+    template: {
+      /**
+       * Get files modified in a change
+       *
+       * @param {string} changeId - Change ID
+       * @returns {Promise<string[]>} Array of file paths
+       */
+      async files(changeId) {
+        await graph.load();
+        const change = await graph.getChange(changeId);
+        if (!change || !change.fileSnapshot) {
+          return [];
+        }
+        return Object.keys(change.fileSnapshot);
+      },
+
+      /**
+       * Join array elements with a separator
+       *
+       * @param {string[]} array - Array of strings
+       * @param {string} separator - Separator string
+       * @returns {string} Joined string
+       */
+      join(array, separator) {
+        if (!Array.isArray(array)) {
+          return '';
+        }
+        return array.join(separator);
+      },
+
+      /**
+       * Format path for display
+       *
+       * @param {string} path - File path
+       * @returns {string} Formatted path
+       */
+      format_path(path) {
+        if (!path) {
+          return '';
+        }
+        // Simple formatting: just return the path as-is for now
+        // In real JJ, this might apply colors, truncation, etc.
+        return path;
+      },
     },
 
     /**