isomorphic-jj 1.0.0

package/src/core/storage-manager.js

@@ -0,0 +1,207 @@
+/**
+ * Storage Manager for isomorphic-jj
+ * 
+ * Manages JSON storage in .jj directory with atomic writes and caching.
+ */
+
+import { JJError } from '../utils/errors.js';
+
+export class Storage {
+  /**
+   * @param {Object} fs - Filesystem implementation (Node fs, LightningFS, etc.)
+   * @param {string} dir - Repository directory path
+   */
+  constructor(fs, dir) {
+    this.fs = fs;
+    this.dir = dir;
+    this.jjDir = `${dir}/.jj`;
+    this.repoDir = `${dir}/.jj/repo`;  // Core repo data
+    this.workingCopyDir = `${dir}/.jj/working_copy`;  // Default workspace working copy
+    this.cache = new Map();
+  }
+
+  /**
+   * Initialize .jj directory structure (JJ workspace model)
+   *
+   * Structure:
+   * .jj/
+   *   repo/           - Core repository data (shared by all workspaces)
+   *     store/        - Change graph, operations, bookmarks
+   *   working_copy/   - Default workspace working copy state
+   */
+  async init() {
+    try {
+      // Create main directories
+      await this.fs.promises.mkdir(this.jjDir, { recursive: true });
+      await this.fs.promises.mkdir(this.repoDir, { recursive: true });
+      await this.fs.promises.mkdir(this.workingCopyDir, { recursive: true });
+
+      // Create repo subdirectories
+      await this.fs.promises.mkdir(`${this.repoDir}/store`, { recursive: true });
+      await this.fs.promises.mkdir(`${this.repoDir}/op_log`, { recursive: true });
+      await this.fs.promises.mkdir(`${this.repoDir}/conflicts`, { recursive: true });
+
+      // Create default workspace directory
+      await this.fs.promises.mkdir(`${this.workingCopyDir}/default`, { recursive: true });
+    } catch (error) {
+      throw new JJError('STORAGE_INIT_FAILED', `Failed to initialize .jj directory: ${error.message}`, {
+        dir: this.jjDir,
+        originalError: error,
+      });
+    }
+  }
+
+  /**
+   * Read and parse JSON file
+   * 
+   * @param {string} path - Relative path from .jj directory
+   * @returns {Promise<Object|null>} Parsed JSON or null if file doesn't exist
+   */
+  async read(path) {
+    const fullPath = `${this.jjDir}/${path}`;
+
+    // Check cache
+    if (this.cache.has(path)) {
+      return this.cache.get(path);
+    }
+
+    try {
+      const content = await this.fs.promises.readFile(fullPath, 'utf8');
+      const data = JSON.parse(content);
+      this.cache.set(path, data);
+      return data;
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        return null;
+      }
+      throw new JJError('STORAGE_READ_FAILED', `Failed to read ${path}: ${error.message}`, {
+        path: fullPath,
+        originalError: error,
+      });
+    }
+  }
+
+  /**
+   * Write JSON file atomically
+   * 
+   * @param {string} path - Relative path from .jj directory
+   * @param {Object|string} data - Data to write (object will be stringified)
+   */
+  async write(path, data) {
+    const fullPath = `${this.jjDir}/${path}`;
+    const tmpPath = `${fullPath}.tmp.${Date.now()}`;
+    const jsonData = typeof data === 'string' ? data : JSON.stringify(data, null, 2);
+
+    try {
+      // Ensure parent directory exists
+      const dirPath = fullPath.substring(0, fullPath.lastIndexOf('/'));
+      await this.fs.promises.mkdir(dirPath, { recursive: true });
+
+      // Write to temp file
+      await this.fs.promises.writeFile(tmpPath, jsonData, 'utf8');
+
+      // Atomic rename
+      await this.fs.promises.rename(tmpPath, fullPath);
+
+      // Update cache
+      if (typeof data !== 'string') {
+        this.cache.set(path, data);
+      }
+    } catch (error) {
+      // Clean up temp file
+      try {
+        await this.fs.promises.unlink(tmpPath);
+      } catch {}
+
+      throw new JJError('STORAGE_WRITE_FAILED', `Failed to write ${path}: ${error.message}`, {
+        path: fullPath,
+        originalError: error,
+      });
+    }
+  }
+
+  /**
+   * Read JSONL file (newline-delimited JSON)
+   * 
+   * @param {string} path - Relative path from .jj directory
+   * @returns {Promise<Array>} Array of parsed JSON objects
+   */
+  async readLines(path) {
+    const fullPath = `${this.jjDir}/${path}`;
+
+    try {
+      const content = await this.fs.promises.readFile(fullPath, 'utf8');
+      return content
+        .trim()
+        .split('\n')
+        .filter((line) => line.length > 0)
+        .map((line) => JSON.parse(line));
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        return [];
+      }
+      throw new JJError('STORAGE_READ_FAILED', `Failed to read ${path}: ${error.message}`, {
+        path: fullPath,
+        originalError: error,
+      });
+    }
+  }
+
+  /**
+   * Append line to JSONL file
+   * 
+   * @param {string} path - Relative path from .jj directory
+   * @param {string} line - JSON string to append
+   */
+  async appendLine(path, line) {
+    const fullPath = `${this.jjDir}/${path}`;
+
+    try {
+      // Read existing content
+      let existing = '';
+      try {
+        existing = await this.fs.promises.readFile(fullPath, 'utf8');
+      } catch (error) {
+        if (error.code !== 'ENOENT') throw error;
+      }
+
+      // Write atomically
+      await this.write(path, existing + line + '\n');
+    } catch (error) {
+      throw new JJError('STORAGE_WRITE_FAILED', `Failed to append to ${path}: ${error.message}`, {
+        path: fullPath,
+        originalError: error,
+      });
+    }
+  }
+
+  /**
+   * Check if file exists
+   * 
+   * @param {string} path - Relative path from .jj directory
+   * @returns {Promise<boolean>}
+   */
+  async exists(path) {
+    const fullPath = `${this.jjDir}/${path}`;
+    
+    try {
+      await this.fs.promises.stat(fullPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Invalidate cache
+   * 
+   * @param {string} [path] - Specific path to invalidate, or all if not provided
+   */
+  invalidateCache(path) {
+    if (path) {
+      this.cache.delete(path);
+    } else {
+      this.cache.clear();
+    }
+  }
+}

package/src/core/tag-store.js

@@ -0,0 +1,167 @@
+/**
+ * Tag Store - Manages immutable references to changes
+ *
+ * Tags are immutable references that cannot be moved once created.
+ * They are typically used for release points and important milestones.
+ */
+
+import { JJError } from '../utils/errors.js';
+
+/**
+ * Validates tag name format
+ * @param {string} name - Tag name to validate
+ * @throws {JJError} If name is invalid
+ */
+function validateTagName(name) {
+  if (!name || typeof name !== 'string') {
+    throw new JJError('INVALID_TAG_NAME', 'Tag name must be a non-empty string');
+  }
+
+  if (name.trim() !== name || name.includes(' ')) {
+    throw new JJError(
+      'INVALID_TAG_NAME',
+      'Tag name cannot contain spaces or leading/trailing whitespace',
+      { name }
+    );
+  }
+
+  if (name.length === 0) {
+    throw new JJError('INVALID_TAG_NAME', 'Tag name cannot be empty');
+  }
+}
+
+/**
+ * Simple tag pattern matching (supports glob-like patterns)
+ * @param {string} name - Tag name
+ * @param {string} pattern - Pattern (e.g., "v1*", "*-rc")
+ * @returns {boolean} True if name matches pattern
+ */
+function matchesPattern(name, pattern) {
+  // Convert glob pattern to regex
+  const regexPattern = pattern
+    .replace(/[.+^${}()|[\]\\]/g, '\\$&') // Escape regex special chars
+    .replace(/\*/g, '.*') // Convert * to .*
+    .replace(/\?/g, '.'); // Convert ? to .
+
+  const regex = new RegExp(`^${regexPattern}$`);
+  return regex.test(name);
+}
+
+export class TagStore {
+  /**
+   * @param {Object} fs - Filesystem interface
+   * @param {string} jjDir - Path to .jj directory
+   */
+  constructor(fs, jjDir) {
+    this.fs = fs;
+    this.jjDir = jjDir;
+    this.tagsFile = `${jjDir}/store/tags.json`;
+  }
+
+  /**
+   * Loads tags from storage
+   * @returns {Promise<Object>} Map of tag name to changeId
+   */
+  async load() {
+    try {
+      const data = await this.fs.readFile(this.tagsFile, 'utf8');
+      return JSON.parse(data);
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        return {};
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Saves tags to storage
+   * @param {Object} tags - Map of tag name to changeId
+   * @returns {Promise<void>}
+   */
+  async save(tags) {
+    await this.fs.writeFile(this.tagsFile, JSON.stringify(tags, null, 2));
+  }
+
+  /**
+   * Creates a new tag
+   * @param {string} name - Tag name
+   * @param {string} changeId - Change ID to tag
+   * @returns {Promise<{name: string, changeId: string}>}
+   * @throws {JJError} If tag already exists or name is invalid
+   */
+  async create(name, changeId) {
+    validateTagName(name);
+
+    const tags = await this.load();
+
+    if (tags[name]) {
+      throw new JJError('TAG_EXISTS', `Tag "${name}" already exists`, {
+        name,
+        existingChangeId: tags[name],
+      });
+    }
+
+    tags[name] = changeId;
+    await this.save(tags);
+
+    return { name, changeId };
+  }
+
+  /**
+   * Lists all tags, optionally filtered by pattern
+   * @param {string} [pattern] - Optional glob pattern
+   * @returns {Promise<Array<{name: string, changeId: string}>>}
+   */
+  async list(pattern) {
+    const tags = await this.load();
+
+    let tagNames = Object.keys(tags);
+
+    if (pattern) {
+      tagNames = tagNames.filter((name) => matchesPattern(name, pattern));
+    }
+
+    return tagNames.map((name) => ({
+      name,
+      changeId: tags[name],
+    }));
+  }
+
+  /**
+   * Deletes a tag
+   * @param {string} name - Tag name to delete
+   * @returns {Promise<void>}
+   * @throws {JJError} If tag doesn't exist
+   */
+  async delete(name) {
+    const tags = await this.load();
+
+    if (!tags[name]) {
+      throw new JJError('TAG_NOT_FOUND', `Tag "${name}" not found`, { name });
+    }
+
+    delete tags[name];
+    await this.save(tags);
+  }
+
+  /**
+   * Checks if a tag exists
+   * @param {string} name - Tag name
+   * @returns {Promise<boolean>}
+   */
+  async exists(name) {
+    const tags = await this.load();
+    return !!tags[name];
+  }
+
+  /**
+   * Gets the changeId for a tag
+   * @param {string} name - Tag name
+   * @returns {Promise<string|null>} Change ID or null if not found
+   */
+  async get(name) {
+    const tags = await this.load();
+    return tags[name] || null;
+  }
+}

package/src/core/user-config.js

@@ -0,0 +1,142 @@
+/**
+ * UserConfig - Manages user configuration (name, email, etc.)
+ *
+ * In real JJ, this would come from:
+ * - ~/.jjconfig.toml (global config)
+ * - .jj/repo/config.toml (repo config)
+ * - Environment variables
+ *
+ * For now, we store it in the repository.
+ */
+
+export class UserConfig {
+  /**
+   * @param {Storage} storage - Storage manager instance
+   */
+  constructor(storage) {
+    this.storage = storage;
+    this.config = null;
+  }
+
+  /**
+   * Initialize with default config
+   *
+   * @param {Object} opts - Initial config
+   * @param {string} [opts.userName='User'] - User name
+   * @param {string} [opts.userEmail='user@example.com'] - User email
+   */
+  async init(opts = {}) {
+    this.config = {
+      user: {
+        name: opts.userName || 'User',
+        email: opts.userEmail || 'user@example.com',
+      },
+    };
+
+    await this.save();
+  }
+
+  /**
+   * Load config from storage
+   */
+  async load() {
+    try {
+      const data = await this.storage.read('config.json');
+      if (data) {
+        this.config = data;
+      }
+    } catch (error) {
+      // No config file yet, use defaults
+      await this.init();
+    }
+  }
+
+  /**
+   * Save config to storage
+   */
+  async save() {
+    await this.storage.write('config.json', this.config);
+  }
+
+  /**
+   * Get user info
+   *
+   * @returns {Object} User info { name, email }
+   */
+  getUser() {
+    if (!this.config) {
+      return { name: 'User', email: 'user@example.com' };
+    }
+    return this.config.user;
+  }
+
+  /**
+   * Set user info
+   *
+   * @param {Object} user - User info
+   * @param {string} user.name - User name
+   * @param {string} user.email - User email
+   */
+  async setUser(user) {
+    if (!this.config) {
+      await this.load();
+    }
+
+    this.config.user = {
+      name: user.name,
+      email: user.email,
+    };
+
+    await this.save();
+  }
+
+  /**
+   * Get config value
+   *
+   * @param {string} key - Config key (dot notation supported)
+   * @returns {*} Config value
+   */
+  get(key) {
+    if (!this.config) {
+      return undefined;
+    }
+
+    const parts = key.split('.');
+    let value = this.config;
+
+    for (const part of parts) {
+      value = value?.[part];
+      if (value === undefined) {
+        return undefined;
+      }
+    }
+
+    return value;
+  }
+
+  /**
+   * Set config value
+   *
+   * @param {string} key - Config key (dot notation supported)
+   * @param {*} value - Config value
+   */
+  async set(key, value) {
+    if (!this.config) {
+      await this.load();
+    }
+
+    const parts = key.split('.');
+    const lastPart = parts.pop();
+    let target = this.config;
+
+    for (const part of parts) {
+      if (!target[part]) {
+        target[part] = {};
+      }
+      target = target[part];
+    }
+
+    target[lastPart] = value;
+    await this.save();
+  }
+}