@gitgov/core 1.13.0 → 2.1.0

package/dist/src/memory.d.ts

@@ -0,0 +1,262 @@
+import { R as RecordStore, C as ConfigStore, G as GitGovConfig, S as SessionStore, a as GitGovSession, I as IGitModule, f as CommitInfo, E as ExecOptions, c as ExecResult, d as ChangedFile, e as GetCommitHistoryOptions, g as CommitAuthor } from './index--ahcnsG3.js';
+export { M as MemoryFileListerOptions } from './index--ahcnsG3.js';
+export { E as EnvKeyProvider, a as EnvKeyProviderOptions, c as MemoryFileLister, M as MockKeyProvider, b as MockKeyProviderOptions } from './memory_file_lister-BkQ_C3ZU.js';
+
+/**
+ * Options for MemoryRecordStore
+ */
+interface MemoryRecordStoreOptions<T> {
+    /** Initial data */
+    initial?: Map<string, T>;
+    /** Clone data on get/put (default: true) */
+    deepClone?: boolean;
+}
+/**
+ * MemoryRecordStore<T> - In-memory implementation of RecordStore<T>
+ *
+ * Designed for unit tests and scenarios without persistence.
+ * By default, clones values on get/put to prevent accidental mutations.
+ *
+ * @example
+ * // Test setup
+ * const store = new MemoryRecordStore<TaskRecord>();
+ * await store.put('test-task-1', mockTask);
+ *
+ * // Assertions
+ * expect(await store.exists('test-task-1')).toBe(true);
+ * expect(store.size()).toBe(1);
+ *
+ * // Cleanup
+ * store.clear();
+ */
+declare class MemoryRecordStore<T> implements RecordStore<T> {
+    private readonly data;
+    private readonly deepClone;
+    constructor(options?: MemoryRecordStoreOptions<T>);
+    private clone;
+    get(id: string): Promise<T | null>;
+    put(id: string, value: T): Promise<void>;
+    delete(id: string): Promise<void>;
+    list(): Promise<string[]>;
+    exists(id: string): Promise<boolean>;
+    /** Clears all records from the store */
+    clear(): void;
+    /** Returns the number of records */
+    size(): number;
+    /** Returns a copy of the internal Map (for assertions) */
+    getAll(): Map<string, T>;
+}
+
+/**
+ * MemoryConfigStore - In-memory implementation of ConfigStore
+ *
+ * Useful for testing and serverless environments where filesystem
+ * access is not available or not desired.
+ *
+ * NOTE: Session state is handled by MemorySessionStore, not this class.
+ */
+
+/**
+ * In-memory ConfigStore implementation for tests.
+ *
+ * Stores configuration in memory without filesystem I/O.
+ * Provides methods to pre-populate data for testing scenarios.
+ *
+ * @example
+ * ```typescript
+ * const configStore = new MemoryConfigStore();
+ * const sessionStore = new MemorySessionStore();
+ *
+ * // Pre-populate for testing
+ * configStore.setConfig({
+ *   protocolVersion: '1.0',
+ *   projectId: 'test-project',
+ *   projectName: 'Test Project',
+ *   rootCycle: '1234567890-cycle-test'
+ * });
+ *
+ * // Use in ConfigManager
+ * const manager = new ConfigManager(configStore, sessionStore);
+ * const config = await manager.loadConfig();
+ * ```
+ */
+declare class MemoryConfigStore implements ConfigStore {
+    private config;
+    /**
+     * 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
+     */
+    loadConfig(): Promise<GitGovConfig | null>;
+    /**
+     * Save configuration to memory
+     *
+     * [EARS-A4] Persists config in memory, accessible via getConfig()
+     */
+    saveConfig(config: GitGovConfig): Promise<void>;
+    /**
+     * Set configuration directly (for test setup)
+     *
+     * [EARS-B1] Sets config synchronously, available via getConfig()
+     * [EARS-B2] Accepts null to clear config
+     */
+    setConfig(config: GitGovConfig | null): void;
+    /**
+     * Get current configuration (for test assertions)
+     */
+    getConfig(): GitGovConfig | null;
+    /**
+     * Clear all stored data (for test cleanup)
+     *
+     * [EARS-B3] Resets store to initial state (config = null)
+     */
+    clear(): void;
+}
+
+/**
+ * MemorySessionStore - In-memory implementation of SessionStore
+ *
+ * Useful for testing and serverless environments where filesystem
+ * access is not available or not desired.
+ */
+
+/**
+ * In-memory SessionStore implementation for tests.
+ *
+ * Stores session state in memory without filesystem I/O.
+ * Provides methods to pre-populate data for testing scenarios.
+ *
+ * @example
+ * ```typescript
+ * const store = new MemorySessionStore();
+ *
+ * // Pre-populate for testing
+ * store.setSession({
+ *   lastSession: { actorId: 'human:test', timestamp: '2024-01-01T00:00:00Z' },
+ *   actorState: {}
+ * });
+ *
+ * // Use in ConfigManager
+ * const manager = new ConfigManager(configStore, store);
+ * const session = await manager.loadSession();
+ * ```
+ */
+declare class MemorySessionStore implements SessionStore {
+    private session;
+    private keyFiles;
+    /**
+     * Load session from memory
+     * @returns GitGovSession or null if not set
+     */
+    loadSession(): Promise<GitGovSession | null>;
+    /**
+     * Save session to memory
+     */
+    saveSession(session: GitGovSession): Promise<void>;
+    /**
+     * Detect actor from simulated .key files
+     *
+     * In MemorySessionStore, .key files are simulated via setKeyFiles().
+     *
+     * @returns Actor ID or null if no key files configured
+     */
+    detectActorFromKeyFiles(): Promise<string | null>;
+    /**
+     * Set session directly (for test setup)
+     */
+    setSession(session: GitGovSession | null): void;
+    /**
+     * Get current session (for test assertions)
+     */
+    getSession(): GitGovSession | null;
+    /**
+     * Set simulated .key files (for EARS-B9 testing)
+     * @param keyFiles - Array of key filenames (e.g., ["human:camilo.key"])
+     */
+    setKeyFiles(keyFiles: string[]): void;
+    /**
+     * Clear all stored data (for test cleanup)
+     */
+    clear(): void;
+}
+
+/**
+ * MemoryGitModule - In-memory Git implementation for tests
+ *
+ * This module provides a mock implementation of IGitModule for unit testing.
+ * All state is kept in memory with no filesystem operations.
+ *
+ * Test Helpers:
+ * - setBranch(name): Set current branch
+ * - setCommits(commits[]): Set commit history
+ * - setFiles(files): Set file contents
+ * - clear(): Reset all state
+ *
+ * @module git/memory
+ */
+
+/**
+ * MemoryGitModule - In-memory Git mock for unit tests
+ */
+declare class MemoryGitModule implements IGitModule {
+    private state;
+    constructor(repoRoot?: string);
+    setBranch(name: string): void;
+    setBranches(names: string[]): void;
+    setCommits(commits: CommitInfo[]): void;
+    setFiles(files: Record<string, string>): void;
+    setFileContent(commitHash: string, filePath: string, content: string): void;
+    setStagedFiles(files: string[]): void;
+    setRebaseInProgress(inProgress: boolean, conflictedFiles?: string[]): void;
+    setRemoteBranches(remote: string, branches: string[]): void;
+    clear(): void;
+    exec(_command: string, _args: string[], _options?: ExecOptions): Promise<ExecResult>;
+    init(): Promise<void>;
+    getRepoRoot(): Promise<string>;
+    getCurrentBranch(): Promise<string>;
+    getCommitHash(ref?: string): Promise<string>;
+    setConfig(key: string, value: string, _scope?: 'local' | 'global' | 'system'): Promise<void>;
+    getMergeBase(branchA: string, branchB: string): Promise<string>;
+    getChangedFiles(_fromCommit: string, _toCommit: string, _pathFilter: string): Promise<ChangedFile[]>;
+    getStagedFiles(): Promise<string[]>;
+    getFileContent(commitHash: string, filePath: string): Promise<string>;
+    getCommitHistory(_branch: string, options?: GetCommitHistoryOptions): Promise<CommitInfo[]>;
+    getCommitHistoryRange(fromHash: string, toHash: string, options?: GetCommitHistoryOptions): Promise<CommitInfo[]>;
+    getCommitMessage(commitHash: string): Promise<string>;
+    hasUncommittedChanges(_pathFilter?: string): Promise<boolean>;
+    isRebaseInProgress(): Promise<boolean>;
+    branchExists(branchName: string): Promise<boolean>;
+    listRemoteBranches(remoteName: string): Promise<string[]>;
+    isRemoteConfigured(remoteName: string): Promise<boolean>;
+    getBranchRemote(branchName: string): Promise<string | null>;
+    getConflictedFiles(): Promise<string[]>;
+    checkoutBranch(branchName: string): Promise<void>;
+    stash(message?: string): Promise<string | null>;
+    stashPop(): Promise<boolean>;
+    stashDrop(_stashHash?: string): Promise<void>;
+    checkoutOrphanBranch(branchName: string): Promise<void>;
+    fetch(_remote: string): Promise<void>;
+    pull(_remote: string, _branchName: string): Promise<void>;
+    pullRebase(_remote: string, _branchName: string): Promise<void>;
+    resetHard(_target: string): Promise<void>;
+    checkoutFilesFromBranch(sourceBranch: string, _filePaths: string[]): Promise<void>;
+    add(filePaths: string[], _options?: {
+        force?: boolean;
+    }): Promise<void>;
+    rm(filePaths: string[]): Promise<void>;
+    commit(message: string, author?: CommitAuthor): Promise<string>;
+    commitAllowEmpty(message: string, author?: CommitAuthor): Promise<string>;
+    push(_remote: string, branchName: string): Promise<void>;
+    pushWithUpstream(_remote: string, branchName: string): Promise<void>;
+    setUpstream(branchName: string, _remote: string, _remoteBranch: string): Promise<void>;
+    rebaseContinue(): Promise<string>;
+    rebaseAbort(): Promise<void>;
+    createBranch(branchName: string, _startPoint?: string): Promise<void>;
+    rebase(_targetBranch: string): Promise<void>;
+}
+
+export { MemoryConfigStore, MemoryGitModule, MemoryRecordStore, MemorySessionStore };