@gitgov/core 1.13.0 → 2.0.0

package/dist/src/memory.js

@@ -0,0 +1,790 @@
+import picomatch from 'picomatch';
+
+// src/record_store/memory/memory_record_store.ts
+var MemoryRecordStore = class {
+  data;
+  deepClone;
+  constructor(options = {}) {
+    this.data = options.initial ?? /* @__PURE__ */ new Map();
+    this.deepClone = options.deepClone ?? true;
+  }
+  clone(value) {
+    if (!this.deepClone) return value;
+    return JSON.parse(JSON.stringify(value));
+  }
+  async get(id) {
+    const value = this.data.get(id);
+    return value !== void 0 ? this.clone(value) : null;
+  }
+  async put(id, value) {
+    this.data.set(id, this.clone(value));
+  }
+  async delete(id) {
+    this.data.delete(id);
+  }
+  async list() {
+    return Array.from(this.data.keys());
+  }
+  async exists(id) {
+    return this.data.has(id);
+  }
+  // ─────────────────────────────────────────────────────────
+  // Test Helpers (not part of RecordStore<T>, only for tests)
+  // ─────────────────────────────────────────────────────────
+  /** Clears all records from the store */
+  clear() {
+    this.data.clear();
+  }
+  /** Returns the number of records */
+  size() {
+    return this.data.size;
+  }
+  /** Returns a copy of the internal Map (for assertions) */
+  getAll() {
+    return new Map(this.data);
+  }
+};
+
+// src/config_store/memory/memory_config_store.ts
+var MemoryConfigStore = class {
+  config = null;
+  /**
+   * Load configuration from memory
+   *
+   * [EARS-A1] Returns null if no config set
+   * [EARS-A2] Returns config set via setConfig
+   * [EARS-A3] Returns config saved via saveConfig
+   *
+   * @returns GitGovConfig or null if not set
+   */
+  async loadConfig() {
+    return this.config;
+  }
+  /**
+   * Save configuration to memory
+   *
+   * [EARS-A4] Persists config in memory, accessible via getConfig()
+   */
+  async saveConfig(config) {
+    this.config = config;
+  }
+  // ==================== Test Helper Methods ====================
+  /**
+   * Set configuration directly (for test setup)
+   *
+   * [EARS-B1] Sets config synchronously, available via getConfig()
+   * [EARS-B2] Accepts null to clear config
+   */
+  setConfig(config) {
+    this.config = config;
+  }
+  /**
+   * Get current configuration (for test assertions)
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Clear all stored data (for test cleanup)
+   *
+   * [EARS-B3] Resets store to initial state (config = null)
+   */
+  clear() {
+    this.config = null;
+  }
+};
+
+// src/session_store/memory/memory_session_store.ts
+var MemorySessionStore = class {
+  session = null;
+  keyFiles = [];
+  /**
+   * Load session from memory
+   * @returns GitGovSession or null if not set
+   */
+  async loadSession() {
+    return this.session;
+  }
+  /**
+   * Save session to memory
+   */
+  async saveSession(session) {
+    this.session = session;
+  }
+  /**
+   * Detect actor from simulated .key files
+   *
+   * In MemorySessionStore, .key files are simulated via setKeyFiles().
+   *
+   * @returns Actor ID or null if no key files configured
+   */
+  async detectActorFromKeyFiles() {
+    const firstKeyFile = this.keyFiles[0];
+    if (!firstKeyFile) {
+      return null;
+    }
+    return firstKeyFile.replace(".key", "");
+  }
+  // ==================== Test Helper Methods ====================
+  /**
+   * Set session directly (for test setup)
+   */
+  setSession(session) {
+    this.session = session;
+  }
+  /**
+   * Get current session (for test assertions)
+   */
+  getSession() {
+    return this.session;
+  }
+  /**
+   * Set simulated .key files (for EARS-B9 testing)
+   * @param keyFiles - Array of key filenames (e.g., ["human:camilo.key"])
+   */
+  setKeyFiles(keyFiles) {
+    this.keyFiles = keyFiles;
+  }
+  /**
+   * Clear all stored data (for test cleanup)
+   */
+  clear() {
+    this.session = null;
+    this.keyFiles = [];
+  }
+};
+
+// src/key_provider/key_provider.ts
+var KeyProviderError = class extends Error {
+  constructor(message, code, actorId) {
+    super(message);
+    this.code = code;
+    this.actorId = actorId;
+    this.name = "KeyProviderError";
+  }
+};
+
+// src/key_provider/memory/env_key_provider.ts
+var EnvKeyProvider = class {
+  prefix;
+  env;
+  allowWrites;
+  constructor(options = {}) {
+    this.prefix = options.prefix ?? "GITGOV_KEY_";
+    this.env = options.env ?? process.env;
+    this.allowWrites = options.allowWrites ?? options.env !== void 0;
+  }
+  /**
+   * [EARS-KP01] Retrieves the private key from environment variable.
+   * [EARS-EKP01] Reads from {prefix}{SANITIZED_ACTOR_ID}.
+   * [EARS-EKP07] Returns null for empty or whitespace-only value.
+   * [EARS-EKP08] Trims whitespace from value.
+   */
+  async getPrivateKey(actorId) {
+    const varName = this.getEnvVarName(actorId);
+    const value = this.env[varName];
+    if (!value || value.trim() === "") {
+      return null;
+    }
+    return value.trim();
+  }
+  /**
+   * [EARS-KP03] Stores a private key in the environment object.
+   * [EARS-EKP02] Sets env var in custom env object.
+   * [EARS-EKP03] Throws KEY_WRITE_ERROR when writing to process.env.
+   */
+  async setPrivateKey(actorId, privateKey) {
+    if (!this.allowWrites) {
+      throw new KeyProviderError(
+        "Cannot write to environment variables in read-only mode. Use a custom env object with allowWrites: true for writable storage.",
+        "KEY_WRITE_ERROR",
+        actorId
+      );
+    }
+    const varName = this.getEnvVarName(actorId);
+    this.env[varName] = privateKey;
+  }
+  /**
+   * Checks if a private key exists in environment variables.
+   */
+  async hasPrivateKey(actorId) {
+    const varName = this.getEnvVarName(actorId);
+    const value = this.env[varName];
+    return value !== void 0 && value.trim() !== "";
+  }
+  /**
+   * [EARS-KP04] Deletes the private key from environment object.
+   * [EARS-EKP10] Throws KEY_DELETE_ERROR in read-only mode.
+   */
+  async deletePrivateKey(actorId) {
+    if (!this.allowWrites) {
+      throw new KeyProviderError(
+        "Cannot delete environment variables in read-only mode.",
+        "KEY_DELETE_ERROR",
+        actorId
+      );
+    }
+    const varName = this.getEnvVarName(actorId);
+    const existed = this.env[varName] !== void 0;
+    delete this.env[varName];
+    return existed;
+  }
+  /**
+   * [EARS-EKP04] Builds environment variable name from actorId.
+   * [EARS-EKP05] Converts to UPPERCASE.
+   * [EARS-EKP06] Collapses multiple underscores.
+   * [EARS-EKP11] Throws INVALID_ACTOR_ID if empty after sanitization.
+   */
+  getEnvVarName(actorId) {
+    const sanitized = actorId.toUpperCase().replace(/[^A-Z0-9]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
+    if (!sanitized) {
+      throw new KeyProviderError(
+        "Invalid actorId: empty after sanitization",
+        "INVALID_ACTOR_ID",
+        actorId
+      );
+    }
+    return `${this.prefix}${sanitized}`;
+  }
+};
+
+// src/key_provider/memory/mock_key_provider.ts
+var MockKeyProvider = class {
+  keys;
+  constructor(options = {}) {
+    if (options.keys instanceof Map) {
+      this.keys = new Map(options.keys);
+    } else if (options.keys) {
+      this.keys = new Map(Object.entries(options.keys));
+    } else {
+      this.keys = /* @__PURE__ */ new Map();
+    }
+  }
+  /**
+   * [EARS-KP01] Retrieves the private key for an actor.
+   */
+  async getPrivateKey(actorId) {
+    return this.keys.get(actorId) ?? null;
+  }
+  /**
+   * [EARS-KP03] Stores a private key for an actor.
+   * [EARS-MKP03] Overwrites existing key if present.
+   */
+  async setPrivateKey(actorId, privateKey) {
+    this.keys.set(actorId, privateKey);
+  }
+  /**
+   * [EARS-MKP07] Checks if a private key exists for an actor.
+   */
+  async hasPrivateKey(actorId) {
+    return this.keys.has(actorId);
+  }
+  /**
+   * [EARS-KP04] Deletes the private key for an actor.
+   */
+  async deletePrivateKey(actorId) {
+    return this.keys.delete(actorId);
+  }
+  /**
+   * [EARS-MKP04] Returns the number of stored keys (useful for testing).
+   */
+  size() {
+    return this.keys.size;
+  }
+  /**
+   * [EARS-MKP05] Clears all stored keys (useful for test cleanup).
+   */
+  clear() {
+    this.keys.clear();
+  }
+  /**
+   * [EARS-MKP06] Returns all stored actor IDs (useful for testing).
+   */
+  listActorIds() {
+    return Array.from(this.keys.keys());
+  }
+};
+
+// src/file_lister/file_lister.errors.ts
+var FileListerError = class extends Error {
+  constructor(message, code, filePath) {
+    super(message);
+    this.code = code;
+    this.filePath = filePath;
+    this.name = "FileListerError";
+  }
+};
+
+// src/file_lister/memory/memory_file_lister.ts
+function matchPatterns(patterns, filePaths) {
+  const isMatch = picomatch(patterns);
+  return filePaths.filter((filePath) => isMatch(filePath));
+}
+function filterIgnored(filePaths, ignorePatterns) {
+  if (!ignorePatterns.length) return filePaths;
+  const isIgnored = picomatch(ignorePatterns);
+  return filePaths.filter((filePath) => !isIgnored(filePath));
+}
+var MemoryFileLister = class {
+  files;
+  stats;
+  /**
+   * [EARS-MFL01] Constructs MemoryFileLister with provided files.
+   */
+  constructor(options = {}) {
+    if (options.files instanceof Map) {
+      this.files = new Map(options.files);
+    } else if (options.files) {
+      this.files = new Map(Object.entries(options.files));
+    } else {
+      this.files = /* @__PURE__ */ new Map();
+    }
+    this.stats = options.stats ?? /* @__PURE__ */ new Map();
+  }
+  /**
+   * [EARS-FL01] Lists files matching glob patterns.
+   * [EARS-MFL02] Filters files using glob patterns.
+   */
+  async list(patterns, options) {
+    const allPaths = Array.from(this.files.keys());
+    let matched = matchPatterns(patterns, allPaths);
+    if (options?.ignore?.length) {
+      matched = filterIgnored(matched, options.ignore);
+    }
+    return matched.sort();
+  }
+  /**
+   * [EARS-FL02] Checks if a file exists.
+   */
+  async exists(filePath) {
+    return this.files.has(filePath);
+  }
+  /**
+   * [EARS-FL03] Reads file content as string.
+   */
+  async read(filePath) {
+    const content = this.files.get(filePath);
+    if (content === void 0) {
+      throw new FileListerError(
+        `File not found: ${filePath}`,
+        "FILE_NOT_FOUND",
+        filePath
+      );
+    }
+    return content;
+  }
+  /**
+   * [EARS-FL04] Gets file statistics.
+   * [EARS-MFL03] Generates stats from content if not explicitly provided.
+   */
+  async stat(filePath) {
+    if (!this.files.has(filePath)) {
+      throw new FileListerError(
+        `File not found: ${filePath}`,
+        "FILE_NOT_FOUND",
+        filePath
+      );
+    }
+    const explicitStats = this.stats.get(filePath);
+    if (explicitStats) {
+      return explicitStats;
+    }
+    const content = this.files.get(filePath);
+    return {
+      size: content.length,
+      mtime: Date.now(),
+      isFile: true
+    };
+  }
+  // ============================================
+  // Testing utilities
+  // ============================================
+  /**
+   * [EARS-MFL04] Adds a file to the mock filesystem.
+   */
+  addFile(filePath, content) {
+    this.files.set(filePath, content);
+  }
+  /**
+   * Removes a file from the mock filesystem.
+   */
+  removeFile(filePath) {
+    this.stats.delete(filePath);
+    return this.files.delete(filePath);
+  }
+  /**
+   * Returns the number of files.
+   */
+  size() {
+    return this.files.size;
+  }
+  /**
+   * Clears all files.
+   */
+  clear() {
+    this.files.clear();
+    this.stats.clear();
+  }
+  /**
+   * Returns all file paths.
+   */
+  listPaths() {
+    return Array.from(this.files.keys());
+  }
+};
+
+// src/git/errors.ts
+var GitError = class _GitError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "GitError";
+    Object.setPrototypeOf(this, _GitError.prototype);
+  }
+};
+var BranchNotFoundError = class _BranchNotFoundError extends GitError {
+  branchName;
+  constructor(branchName) {
+    super(`Branch not found: ${branchName}`);
+    this.name = "BranchNotFoundError";
+    this.branchName = branchName;
+    Object.setPrototypeOf(this, _BranchNotFoundError.prototype);
+  }
+};
+var FileNotFoundError = class _FileNotFoundError extends GitError {
+  filePath;
+  commitHash;
+  constructor(filePath, commitHash) {
+    super(`File not found: ${filePath} in commit ${commitHash}`);
+    this.name = "FileNotFoundError";
+    this.filePath = filePath;
+    this.commitHash = commitHash;
+    Object.setPrototypeOf(this, _FileNotFoundError.prototype);
+  }
+};
+var RebaseNotInProgressError = class _RebaseNotInProgressError extends GitError {
+  constructor() {
+    super("No rebase in progress");
+    this.name = "RebaseNotInProgressError";
+    Object.setPrototypeOf(this, _RebaseNotInProgressError.prototype);
+  }
+};
+var BranchAlreadyExistsError = class _BranchAlreadyExistsError extends GitError {
+  branchName;
+  constructor(branchName) {
+    super(`Branch already exists: ${branchName}`);
+    this.name = "BranchAlreadyExistsError";
+    this.branchName = branchName;
+    Object.setPrototypeOf(this, _BranchAlreadyExistsError.prototype);
+  }
+};
+
+// src/git/memory/memory_git_module.ts
+var MemoryGitModule = class {
+  state;
+  constructor(repoRoot = "/test/repo") {
+    this.state = {
+      repoRoot,
+      currentBranch: "main",
+      branches: /* @__PURE__ */ new Set(["main"]),
+      commits: [],
+      stagedFiles: [],
+      files: /* @__PURE__ */ new Map(),
+      isRebaseInProgress: false,
+      conflictedFiles: [],
+      remotes: /* @__PURE__ */ new Map([["origin", ["main"]]]),
+      stashes: [],
+      config: /* @__PURE__ */ new Map()
+    };
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // TEST HELPERS
+  // ═══════════════════════════════════════════════════════════════════════
+  setBranch(name) {
+    this.state.currentBranch = name;
+    this.state.branches.add(name);
+  }
+  setBranches(names) {
+    this.state.branches = new Set(names);
+    if (!this.state.branches.has(this.state.currentBranch)) {
+      this.state.currentBranch = names[0] || "main";
+    }
+  }
+  setCommits(commits) {
+    this.state.commits = commits.map((c) => ({
+      ...c,
+      files: /* @__PURE__ */ new Map(),
+      branch: this.state.currentBranch
+    }));
+  }
+  setFiles(files) {
+    this.state.files = new Map(Object.entries(files));
+  }
+  setFileContent(commitHash, filePath, content) {
+    const commit = this.state.commits.find((c) => c.hash === commitHash);
+    if (commit) {
+      commit.files.set(filePath, content);
+    }
+    this.state.files.set(filePath, content);
+  }
+  setStagedFiles(files) {
+    this.state.stagedFiles = files;
+  }
+  setRebaseInProgress(inProgress, conflictedFiles = []) {
+    this.state.isRebaseInProgress = inProgress;
+    this.state.conflictedFiles = conflictedFiles;
+  }
+  setRemoteBranches(remote, branches) {
+    this.state.remotes.set(remote, branches);
+  }
+  clear() {
+    this.state = {
+      repoRoot: this.state.repoRoot,
+      currentBranch: "main",
+      branches: /* @__PURE__ */ new Set(["main"]),
+      commits: [],
+      stagedFiles: [],
+      files: /* @__PURE__ */ new Map(),
+      isRebaseInProgress: false,
+      conflictedFiles: [],
+      remotes: /* @__PURE__ */ new Map([["origin", ["main"]]]),
+      stashes: [],
+      config: /* @__PURE__ */ new Map()
+    };
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // IGitModule IMPLEMENTATION
+  // ═══════════════════════════════════════════════════════════════════════
+  async exec(_command, _args, _options) {
+    return { exitCode: 0, stdout: "", stderr: "" };
+  }
+  async init() {
+    this.state.branches.add("main");
+    this.state.currentBranch = "main";
+  }
+  async getRepoRoot() {
+    return this.state.repoRoot;
+  }
+  async getCurrentBranch() {
+    return this.state.currentBranch;
+  }
+  async getCommitHash(ref = "HEAD") {
+    if (ref === "HEAD") {
+      const lastCommit = this.state.commits[this.state.commits.length - 1];
+      return lastCommit?.hash || "abc123def456";
+    }
+    const commit = this.state.commits.find((c) => c.hash.startsWith(ref));
+    return commit?.hash || ref;
+  }
+  async setConfig(key, value, _scope) {
+    this.state.config.set(key, value);
+  }
+  async getMergeBase(branchA, branchB) {
+    if (!this.state.branches.has(branchA)) {
+      throw new BranchNotFoundError(branchA);
+    }
+    if (!this.state.branches.has(branchB)) {
+      throw new BranchNotFoundError(branchB);
+    }
+    return this.state.commits[0]?.hash || "merge-base-hash";
+  }
+  async getChangedFiles(_fromCommit, _toCommit, _pathFilter) {
+    return [];
+  }
+  async getStagedFiles() {
+    return this.state.stagedFiles;
+  }
+  async getFileContent(commitHash, filePath) {
+    const commit = this.state.commits.find((c) => c.hash === commitHash);
+    if (commit?.files.has(filePath)) {
+      return commit.files.get(filePath);
+    }
+    if (this.state.files.has(filePath)) {
+      return this.state.files.get(filePath);
+    }
+    throw new FileNotFoundError(filePath, commitHash);
+  }
+  async getCommitHistory(_branch, options) {
+    let commits = [...this.state.commits];
+    if (options?.maxCount) {
+      commits = commits.slice(0, options.maxCount);
+    }
+    return commits.map((c) => ({
+      hash: c.hash,
+      message: c.message,
+      author: c.author,
+      date: c.date
+    }));
+  }
+  async getCommitHistoryRange(fromHash, toHash, options) {
+    const fromIndex = this.state.commits.findIndex((c) => c.hash === fromHash);
+    const toIndex = this.state.commits.findIndex((c) => c.hash === toHash);
+    let commits = fromIndex >= 0 && toIndex >= 0 ? this.state.commits.slice(fromIndex + 1, toIndex + 1) : [];
+    if (options?.maxCount) {
+      commits = commits.slice(0, options.maxCount);
+    }
+    return commits.map((c) => ({
+      hash: c.hash,
+      message: c.message,
+      author: c.author,
+      date: c.date
+    }));
+  }
+  async getCommitMessage(commitHash) {
+    const commit = this.state.commits.find((c) => c.hash === commitHash);
+    return commit?.message || "";
+  }
+  async hasUncommittedChanges(_pathFilter) {
+    return this.state.stagedFiles.length > 0;
+  }
+  async isRebaseInProgress() {
+    return this.state.isRebaseInProgress;
+  }
+  async branchExists(branchName) {
+    return this.state.branches.has(branchName);
+  }
+  async listRemoteBranches(remoteName) {
+    return this.state.remotes.get(remoteName) || [];
+  }
+  async isRemoteConfigured(remoteName) {
+    return this.state.remotes.has(remoteName);
+  }
+  async getBranchRemote(branchName) {
+    if (!this.state.branches.has(branchName)) {
+      throw new BranchNotFoundError(branchName);
+    }
+    for (const [remote, branches] of this.state.remotes) {
+      if (branches.includes(branchName)) {
+        return remote;
+      }
+    }
+    return null;
+  }
+  async getConflictedFiles() {
+    return this.state.conflictedFiles;
+  }
+  async checkoutBranch(branchName) {
+    if (!this.state.branches.has(branchName)) {
+      throw new BranchNotFoundError(branchName);
+    }
+    this.state.currentBranch = branchName;
+  }
+  async stash(message) {
+    if (this.state.stagedFiles.length === 0) {
+      return null;
+    }
+    const hash = `stash-${Date.now()}`;
+    this.state.stashes.push({
+      hash,
+      message: message || "WIP",
+      files: new Map(this.state.files)
+    });
+    this.state.stagedFiles = [];
+    return hash;
+  }
+  async stashPop() {
+    const stash = this.state.stashes.pop();
+    if (!stash) {
+      return false;
+    }
+    for (const [path, content] of stash.files) {
+      this.state.files.set(path, content);
+    }
+    return true;
+  }
+  async stashDrop(_stashHash) {
+    this.state.stashes.pop();
+  }
+  async checkoutOrphanBranch(branchName) {
+    this.state.branches.add(branchName);
+    this.state.currentBranch = branchName;
+  }
+  async fetch(_remote) {
+  }
+  async pull(_remote, _branchName) {
+  }
+  async pullRebase(_remote, _branchName) {
+  }
+  async resetHard(_target) {
+    this.state.stagedFiles = [];
+  }
+  async checkoutFilesFromBranch(sourceBranch, _filePaths) {
+    if (!this.state.branches.has(sourceBranch)) {
+      throw new BranchNotFoundError(sourceBranch);
+    }
+  }
+  async add(filePaths, _options) {
+    for (const path of filePaths) {
+      if (!this.state.stagedFiles.includes(path)) {
+        this.state.stagedFiles.push(path);
+      }
+    }
+  }
+  async rm(filePaths) {
+    for (const path of filePaths) {
+      this.state.files.delete(path);
+      this.state.stagedFiles = this.state.stagedFiles.filter((f) => f !== path);
+    }
+  }
+  async commit(message, author) {
+    const hash = `commit-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    this.state.commits.push({
+      hash,
+      message,
+      author: author ? `${author.name} <${author.email}>` : "Test User <test@example.com>",
+      date: (/* @__PURE__ */ new Date()).toISOString(),
+      files: new Map(this.state.files),
+      branch: this.state.currentBranch
+    });
+    this.state.stagedFiles = [];
+    return hash;
+  }
+  async commitAllowEmpty(message, author) {
+    return this.commit(message, author);
+  }
+  async push(_remote, branchName) {
+    const branches = this.state.remotes.get("origin") || [];
+    if (!branches.includes(branchName)) {
+      branches.push(branchName);
+      this.state.remotes.set("origin", branches);
+    }
+  }
+  async pushWithUpstream(_remote, branchName) {
+    return this.push("origin", branchName);
+  }
+  async setUpstream(branchName, _remote, _remoteBranch) {
+    if (!this.state.branches.has(branchName)) {
+      throw new BranchNotFoundError(branchName);
+    }
+  }
+  async rebaseContinue() {
+    if (!this.state.isRebaseInProgress) {
+      throw new RebaseNotInProgressError();
+    }
+    this.state.isRebaseInProgress = false;
+    this.state.conflictedFiles = [];
+    return this.state.commits[this.state.commits.length - 1]?.hash || "rebase-hash";
+  }
+  async rebaseAbort() {
+    if (!this.state.isRebaseInProgress) {
+      throw new RebaseNotInProgressError();
+    }
+    this.state.isRebaseInProgress = false;
+    this.state.conflictedFiles = [];
+  }
+  async createBranch(branchName, _startPoint) {
+    if (this.state.branches.has(branchName)) {
+      throw new BranchAlreadyExistsError(branchName);
+    }
+    this.state.branches.add(branchName);
+    this.state.currentBranch = branchName;
+  }
+  async rebase(_targetBranch) {
+    if (this.state.conflictedFiles.length > 0) {
+      this.state.isRebaseInProgress = true;
+    }
+  }
+};
+
+export { EnvKeyProvider, MemoryConfigStore, MemoryFileLister, MemoryGitModule, MemoryRecordStore, MemorySessionStore, MockKeyProvider };
+//# sourceMappingURL=memory.js.map
+//# sourceMappingURL=memory.js.map