isomorphic-jj 1.1.0 → 1.1.3

package/dist/index.mjs

@@ -266,10 +266,26 @@ function validateChangeId(changeId) {
   }
 }
 
+/**
+ * Normalize a file path by stripping leading slashes
+ *
+ * @param {string} path - File path to normalize
+ * @returns {string} Normalized path (without leading slash)
+ */
+function normalizePath(path) {
+  if (typeof path !== 'string') {
+    return path;
+  }
+
+  // Strip leading slashes for compatibility with REST APIs and absolute paths
+  return path.replace(/^\/+/, '');
+}
+
 /**
  * Validate a file path
- * 
+ *
  * @param {string} path - File path to validate
+ * @returns {string} Normalized path
  * @throws {JJError} If path is invalid or contains path traversal
  */
 function validatePath(path) {
@@ -279,27 +295,25 @@ function validatePath(path) {
     });
   }
 
-  if (path.includes('..')) {
+  // Auto-normalize: strip leading slashes (common with REST APIs)
+  const normalizedPath = normalizePath(path);
+
+  if (normalizedPath.includes('..')) {
     throw new JJError('INVALID_PATH', 'Path traversal (..) not allowed', {
-      path,
+      path: normalizedPath,
       suggestion: 'Use relative paths without .. components',
     });
   }
 
-  if (path.startsWith('/')) {
-    throw new JJError('INVALID_PATH', 'Absolute paths not allowed', {
-      path,
-      suggestion: 'Use relative paths from repository root',
-    });
-  }
-
-  if (path.length > 4096) {
+  if (normalizedPath.length > 4096) {
     throw new JJError('INVALID_PATH', 'Path exceeds maximum length', {
-      path,
+      path: normalizedPath,
       maxLength: 4096,
       suggestion: 'Use shorter file paths',
     });
   }
+
+  return normalizedPath;
 }
 
 /**
@@ -773,7 +787,7 @@ class WorkingCopy {
    * @param {Object} fileState - File state (mtime, size, mode, hash)
    */
   async trackFile(path, fileState) {
-    validatePath(path);
+    path = validatePath(path); // Normalize path
 
     if (!this.state) {
       await this.load();
@@ -785,11 +799,11 @@ class WorkingCopy {
 
   /**
    * Untrack a file from the working copy
-   * 
+   *
    * @param {string} path - File path to untrack
    */
   async untrackFile(path) {
-    validatePath(path);
+    path = validatePath(path); // Normalize path
 
     if (!this.state) {
       await this.load();
@@ -1576,7 +1590,7 @@ class TagStore {
    */
   async load() {
     try {
-      const data = await this.fs.readFile(this.tagsFile, 'utf8');
+      const data = await this.fs.promises.readFile(this.tagsFile, 'utf8');
       return JSON.parse(data);
     } catch (error) {
       if (error.code === 'ENOENT') {
@@ -1592,7 +1606,14 @@ class TagStore {
    * @returns {Promise<void>}
    */
   async save(tags) {
-    await this.fs.writeFile(this.tagsFile, JSON.stringify(tags, null, 2));
+    // Ensure the store directory exists
+    const storeDir = `${this.jjDir}/store`;
+    try {
+      await this.fs.promises.mkdir(storeDir, { recursive: true });
+    } catch (err) {
+      // Directory might already exist, ignore
+    }
+    await this.fs.promises.writeFile(this.tagsFile, JSON.stringify(tags, null, 2));
   }
 
   /**
@@ -4370,11 +4391,17 @@ class UserConfig {
 const __filename$3 = fileURLToPath(import.meta.url);
 const __dirname$3 = path.dirname(__filename$3);
 
+// Determine proto path based on whether we're running from dist or src
+const inDist$3 = __dirname$3.includes('/dist') || __dirname$3.includes('\\dist');
+const protoDir$3 = inDist$3
+  ? path.join(__dirname$3, '..', 'src', 'protos')
+  : path.join(__dirname$3, '..', 'protos');
+
 class JJCheckout {
   constructor(fs, dir) {
     this.fs = fs;
     this.dir = dir;
-    this.protoPath = path.join(__dirname$3, '..', 'protos', 'local_working_copy.proto');
+    this.protoPath = path.join(protoDir$3, 'local_working_copy.proto');
   }
 
   /**
@@ -4446,11 +4473,17 @@ class JJCheckout {
 const __filename$2 = fileURLToPath(import.meta.url);
 const __dirname$2 = path.dirname(__filename$2);
 
+// Determine proto path based on whether we're running from dist or src
+const inDist$2 = __dirname$2.includes('/dist') || __dirname$2.includes('\\dist');
+const protoDir$2 = inDist$2
+  ? path.join(__dirname$2, '..', 'src', 'protos')
+  : path.join(__dirname$2, '..', 'protos');
+
 class JJTreeState {
   constructor(fs, dir) {
     this.fs = fs;
     this.dir = dir;
-    this.protoPath = path.join(__dirname$2, '..', 'protos', 'local_working_copy.proto');
+    this.protoPath = path.join(protoDir$2, 'local_working_copy.proto');
   }
 
   /**
@@ -4538,11 +4571,17 @@ class JJTreeState {
 const __filename$1 = fileURLToPath(import.meta.url);
 const __dirname$1 = path.dirname(__filename$1);
 
+// Determine proto path based on whether we're running from dist or src
+const inDist$1 = __dirname$1.includes('/dist') || __dirname$1.includes('\\dist');
+const protoDir$1 = inDist$1
+  ? path.join(__dirname$1, '..', 'src', 'protos')
+  : path.join(__dirname$1, '..', 'protos');
+
 class JJOperationStore {
   constructor(fs, dir) {
     this.fs = fs;
     this.dir = dir;
-    this.protoPath = path.join(__dirname$1, '..', 'protos', 'simple_op_store.proto');
+    this.protoPath = path.join(protoDir$1, 'simple_op_store.proto');
   }
 
   /**
@@ -4656,11 +4695,17 @@ class JJOperationStore {
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
+// Determine proto path based on whether we're running from dist or src
+const inDist = __dirname.includes('/dist') || __dirname.includes('\\dist');
+const protoDir = inDist
+  ? path.join(__dirname, '..', 'src', 'protos')
+  : path.join(__dirname, '..', 'protos');
+
 class JJViewStore {
   constructor(fs, dir) {
     this.fs = fs;
     this.dir = dir;
-    this.protoPath = path.join(__dirname, '..', 'protos', 'simple_op_store.proto');
+    this.protoPath = path.join(protoDir, 'simple_op_store.proto');
   }
 
   /**
@@ -6236,8 +6281,9 @@ async function createJJ(options) {
     async _moveChange(args) {
       await graph.load();
 
-      const changeId = args.changeId || args.from;
-      const newParent = args.newParent || args.to;
+      // Support multiple parameter names for flexibility
+      const changeId = args.changeId || args.from || args.source;
+      const newParent = args.newParent || args.to || args.destination;
 
       if (!changeId || typeof changeId !== 'string') {
         throw new JJError('INVALID_ARGUMENT', 'Missing or invalid changeId', {
@@ -6577,11 +6623,14 @@ async function createJJ(options) {
     /**
      * Edit change metadata without modifying content
      *
-     * Allows updating author, committer information, and optionally regenerating the change ID.
+     * Allows updating author, committer, description, and optionally regenerating the change ID.
      * The file content and snapshot remain unchanged.
      *
      * @param {Object} [args={}] - Arguments
      * @param {string} [args.revision] - Change ID to edit (defaults to working copy @)
+     * @param {string} [args.change] - Alias for revision
+     * @param {string} [args.description] - Update the change description
+     * @param {string} [args.message] - Alias for description
      * @param {Object} [args.author] - Author information to update
      * @param {string} [args.author.name] - Author name
      * @param {string} [args.author.email] - Author email
@@ -6592,6 +6641,16 @@ async function createJJ(options) {
      * @returns {Promise<Object>} Updated change object
      */
     async metaedit(args = {}) {
+      // Normalize: accept 'change' as alias for 'revision'
+      if (args.change && !args.revision) {
+        args = { ...args, revision: args.change };
+      }
+
+      // Normalize: accept 'message' as alias for 'description'
+      if (args.message && !args.description) {
+        args = { ...args, description: args.message };
+      }
+
       await graph.load();
       await workingCopy.load();
       await userConfig.load();
@@ -6609,13 +6668,14 @@ async function createJJ(options) {
       const hasAuthor = args.author && (args.author.name || args.author.email);
       const hasCommitter = args.committer && (args.committer.name || args.committer.email);
       const hasResetChangeId = args.resetChangeId === true;
+      const hasDescription = args.description !== undefined;
 
-      if (!hasAuthor && !hasCommitter && !hasResetChangeId) {
+      if (!hasAuthor && !hasCommitter && !hasResetChangeId && !hasDescription) {
         throw new JJError(
           'INVALID_ARGUMENT',
           'No metadata provided to update',
           {
-            suggestion: 'Provide author, committer, or resetChangeId: true',
+            suggestion: 'Provide author, committer, description, or resetChangeId: true',
           }
         );
       }
@@ -6660,6 +6720,11 @@ async function createJJ(options) {
         change.committer.timestamp = new Date().toISOString();
       }
 
+      // Update description if provided
+      if (args.description !== undefined) {
+        change.description = args.description;
+      }
+
       // Regenerate change ID if requested
       if (args.resetChangeId) {
         // For now, resetChangeId is not fully implemented as it requires complex graph operations
@@ -7093,9 +7158,14 @@ async function createJJ(options) {
      * @returns {Promise<Object>} Information about the edited change including changeId, description, and file count
      */
     async edit(args) {
+      // Normalize: accept both 'change' and 'changeId' parameters
+      if (args && args.change && !args.changeId) {
+        args = { ...args, changeId: args.change };
+      }
+
       if (!args || !args.changeId) {
         throw new JJError('INVALID_ARGUMENT', 'Missing changeId argument', {
-          suggestion: 'Provide a changeId to edit',
+          suggestion: 'Provide a changeId (or change) to edit',
         });
       }
 
@@ -8937,6 +9007,23 @@ async function createJJ(options) {
      * @returns {Promise<Object>} The un-abandoned change object including changeId, description, and abandoned flag (now false)
      */
     async unabandon(args) {
+      // Normalize: accept both 'change' and 'changeId' parameters
+      if (args && args.change && !args.changeId) {
+        args = { ...args, changeId: args.change };
+      }
+
+      if (!args || !args.changeId) {
+        throw new JJError('INVALID_ARGUMENT', 'Missing changeId argument', {
+          suggestion: 'Provide a changeId (or change) to unabandon',
+        });
+      }
+
+      if (typeof args.changeId !== 'string') {
+        throw new JJError('INVALID_ARGUMENT', 'Change ID must be a string', {
+          changeId: args.changeId,
+        });
+      }
+
       await graph.load();
       await userConfig.load();
 
@@ -10301,6 +10388,13 @@ async function createJJ(options) {
        */
       async add(args) {
         await workspaces.load();
+
+        // If no changeId specified, default to current working copy change
+        if (!args.changeId) {
+          const currentChangeId = workingCopy.getCurrentChangeId();
+          args = { ...args, changeId: currentChangeId };
+        }
+
         const workspace = await workspaces.add(args);
 
         // If a change was specified, check it out in the new workspace
@@ -10697,9 +10791,21 @@ async function createJJ(options) {
        * @returns {Promise<Object>} Bookmark info
        */
       async set(args) {
+        // Normalize: accept common parameter aliases
+        if (args) {
+          if (args.target && !args.changeId) {
+            args = { ...args, changeId: args.target };
+          } else if (args.change && !args.changeId) {
+            args = { ...args, changeId: args.change };
+          } else if (args.revision && !args.changeId) {
+            args = { ...args, changeId: args.revision };
+          }
+        }
+
         if (!args || !args.name || !args.changeId) {
           throw new JJError('INVALID_ARGUMENT', 'Missing name or changeId', {
-            suggestion: 'Provide both: { name: "main", changeId: "abc123..." }',
+            args,
+            suggestion: 'Provide both: { name: "main", changeId: "abc123..." } (or use target/change/revision instead of changeId)',
           });
         }
 
@@ -10735,6 +10841,17 @@ async function createJJ(options) {
        * @returns {Promise<Object>} Bookmark info
        */
       async create(args) {
+        // Normalize: accept common parameter aliases
+        if (args) {
+          if (args.target && !args.changeId) {
+            args = { ...args, changeId: args.target };
+          } else if (args.change && !args.changeId) {
+            args = { ...args, changeId: args.change };
+          } else if (args.revision && !args.changeId) {
+            args = { ...args, changeId: args.revision };
+          }
+        }
+
         if (!args || !args.name) {
           throw new JJError('INVALID_ARGUMENT', 'Missing name argument', {
             suggestion: 'Provide: { name: "main", changeId: "abc123..." } or { name: "main" } for working copy',
@@ -10787,9 +10904,23 @@ async function createJJ(options) {
        * @returns {Promise<Object>} Move result
        */
       async move(args) {
+        // Normalize: accept common parameter aliases
+        if (args) {
+          if (args.target && !args.to) {
+            args = { ...args, to: args.target };
+          } else if (args.changeId && !args.to) {
+            args = { ...args, to: args.changeId };
+          } else if (args.change && !args.to) {
+            args = { ...args, to: args.change };
+          } else if (args.revision && !args.to) {
+            args = { ...args, to: args.revision };
+          }
+        }
+
         if (!args || !args.name || !args.to) {
           throw new JJError('INVALID_ARGUMENT', 'Missing name or to', {
-            suggestion: 'Provide both: { name: "main", to: "abc123..." }',
+            args,
+            suggestion: 'Provide both: { name: "main", to: "abc123..." } (or use target/changeId/change/revision instead of to)',
           });
         }