@gitgov/core 1.13.0 → 2.1.0

package/dist/src/index--ahcnsG3.d.ts

@@ -0,0 +1,798 @@
+/**
+ * RecordStore<T> - Generic interface for record persistence
+ *
+ * Abstracts CRUD operations without assuming storage backend.
+ * Each implementation decides how to persist (fs, memory, db, remote).
+ */
+interface RecordStore<T> {
+    /**
+     * Gets a record by ID
+     * @returns The record or null if it doesn't exist
+     */
+    get(id: string): Promise<T | null>;
+    /**
+     * Persists a record
+     * @param id - Unique identifier
+     * @param value - The record to persist
+     */
+    put(id: string, value: T): Promise<void>;
+    /**
+     * Deletes a record
+     * @param id - Identifier of the record to delete
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Lists all record IDs
+     * @returns Array of IDs
+     */
+    list(): Promise<string[]>;
+    /**
+     * Checks if a record exists
+     * @param id - Identifier to check
+     */
+    exists(id: string): Promise<boolean>;
+}
+
+/**
+ * ConfigManager Types
+ */
+/**
+ * GitGovernance Configuration
+ * Based on config_file.md blueprint
+ */
+type GitGovConfig = {
+    protocolVersion: string;
+    projectId: string;
+    projectName: string;
+    rootCycle: string;
+    state?: {
+        branch?: string;
+        sync?: {
+            strategy?: "manual" | "immediate" | "batched";
+            maxRetries?: number;
+            pushIntervalSeconds?: number;
+            batchIntervalSeconds?: number;
+        };
+        defaults?: {
+            pullScheduler?: {
+                defaultIntervalSeconds?: number;
+                defaultEnabled?: boolean;
+                defaultContinueOnNetworkError?: boolean;
+                defaultStopOnConflict?: boolean;
+            };
+            fileWatcher?: {
+                defaultDebounceMs?: number;
+                defaultIgnoredPatterns?: string[];
+            };
+        };
+        audit?: {
+            lastFullAuditCommit?: string;
+            lastFullAuditTimestamp?: string;
+            lastFullAuditFindingsCount?: number;
+        };
+    };
+};
+/**
+ * Audit state stored in config.json for incremental mode
+ */
+type AuditState = {
+    lastFullAuditCommit: string | null;
+    lastFullAuditTimestamp: string | null;
+    lastFullAuditFindingsCount: number | null;
+};
+/**
+ * Sync configuration from config.json
+ */
+type SyncConfig = {
+    strategy: "manual" | "immediate" | "batched";
+    maxRetries: number;
+    pushIntervalSeconds: number;
+    batchIntervalSeconds: number;
+};
+/**
+ * Sync defaults from config.json
+ */
+type SyncDefaults = {
+    pullScheduler: {
+        defaultIntervalSeconds: number;
+        defaultEnabled: boolean;
+        defaultContinueOnNetworkError: boolean;
+        defaultStopOnConflict: boolean;
+    };
+    fileWatcher: {
+        defaultDebounceMs: number;
+        defaultIgnoredPatterns: string[];
+    };
+};
+/**
+ * Audit state update payload
+ */
+type AuditStateUpdate = {
+    lastFullAuditCommit: string;
+    lastFullAuditTimestamp: string;
+    lastFullAuditFindingsCount: number;
+};
+/**
+ * IConfigManager interface
+ *
+ * Provides typed access to GitGovernance project configuration.
+ * Configuration is versioned in Git and shared between collaborators.
+ */
+interface IConfigManager {
+    /**
+     * Load GitGovernance configuration
+     */
+    loadConfig(): Promise<GitGovConfig | null>;
+    /**
+     * Get root cycle from configuration
+     */
+    getRootCycle(): Promise<string | null>;
+    /**
+     * Get project information from configuration
+     */
+    getProjectInfo(): Promise<{
+        id: string;
+        name: string;
+    } | null>;
+    /**
+     * Get sync configuration from config.json
+     * Returns sync strategy and related settings with defaults
+     */
+    getSyncConfig(): Promise<SyncConfig | null>;
+    /**
+     * Get sync defaults from config.json
+     * Returns recommended defaults for pullScheduler and fileWatcher
+     */
+    getSyncDefaults(): Promise<SyncDefaults>;
+    /**
+     * Get audit state from config.json
+     * Returns last full audit commit and timestamp for incremental mode
+     */
+    getAuditState(): Promise<AuditState>;
+    /**
+     * Update audit state in config.json after a full audit
+     * This is used to enable incremental audits
+     */
+    updateAuditState(auditState: AuditStateUpdate): Promise<void>;
+    /**
+     * Get state branch name from configuration
+     */
+    getStateBranch(): Promise<string>;
+}
+
+/**
+ * SessionManager Types
+ */
+/**
+ * Sync status for an actor's synchronization state.
+ */
+type SyncStatus = {
+    lastSyncPush?: string;
+    lastSyncPull?: string;
+    status?: 'synced' | 'pending' | 'pulling' | 'pushing' | 'conflict';
+    lastError?: string;
+};
+/**
+ * State for a specific actor on this machine.
+ */
+type ActorState = {
+    activeTaskId?: string | undefined;
+    activeCycleId?: string | undefined;
+    lastSync?: string;
+    syncStatus?: SyncStatus;
+    [key: string]: unknown;
+};
+/**
+ * GitGovernance Session State
+ * Based on session_state.md blueprint
+ */
+type GitGovSession = {
+    cloud?: {
+        sessionToken?: string;
+    };
+    lastSession?: {
+        actorId: string;
+        timestamp: string;
+    };
+    actorState?: Record<string, ActorState>;
+    syncPreferences?: {
+        pullScheduler?: {
+            enabled?: boolean;
+            pullIntervalSeconds?: number;
+            continueOnNetworkError?: boolean;
+            stopOnConflict?: boolean;
+        };
+        fileWatcher?: {
+            enabled?: boolean;
+            debounceMs?: number;
+            ignoredPatterns?: string[];
+        };
+    };
+};
+/**
+ * Sync preferences update payload
+ */
+type SyncPreferencesUpdate = {
+    pullScheduler?: Partial<{
+        enabled: boolean;
+        pullIntervalSeconds: number;
+        continueOnNetworkError: boolean;
+        stopOnConflict: boolean;
+    }>;
+    fileWatcher?: Partial<{
+        enabled: boolean;
+        debounceMs: number;
+        ignoredPatterns: string[];
+    }>;
+};
+/**
+ * ISessionManager interface
+ *
+ * Provides typed access to GitGovernance session state.
+ * Session state is ephemeral, machine-local, and NOT versioned in Git.
+ */
+interface ISessionManager {
+    /**
+     * Load GitGovernance session state
+     * [EARS-B9] Auto-detects actor from .key files if no session or no actorId exists
+     */
+    loadSession(): Promise<GitGovSession | null>;
+    /**
+     * [EARS-B9] Detect actor from .key files in .gitgov/actors/
+     */
+    detectActorFromKeyFiles(): Promise<string | null>;
+    /**
+     * Get actor state for a specific actor
+     */
+    getActorState(actorId: string): Promise<ActorState | null>;
+    /**
+     * Update actor state for a specific actor
+     */
+    updateActorState(actorId: string, state: Partial<ActorState>): Promise<void>;
+    /**
+     * Get cloud session token
+     */
+    getCloudSessionToken(): Promise<string | null>;
+    /**
+     * Get sync preferences from session
+     */
+    getSyncPreferences(): Promise<GitGovSession['syncPreferences'] | null>;
+    /**
+     * Update sync preferences in .session.json
+     * These are local machine preferences that override project defaults
+     */
+    updateSyncPreferences(preferences: SyncPreferencesUpdate): Promise<void>;
+    /**
+     * Get last session info (last human who interacted)
+     */
+    getLastSession(): Promise<{
+        actorId: string;
+        timestamp: string;
+    } | null>;
+}
+
+/**
+ * SessionStore - Session persistence abstraction
+ *
+ * Interface for storing and retrieving local session state (.session.json).
+ * Session state is ephemeral, machine-local, and NOT versioned in Git.
+ *
+ * Implementations:
+ * - FsSessionStore: Filesystem-based (production)
+ * - MemorySessionStore: In-memory (tests, serverless)
+ */
+
+/**
+ * Interface for session state persistence.
+ *
+ * Session state includes:
+ * - Actor state (activeTaskId, activeCycleId, syncStatus)
+ * - Sync preferences (pullScheduler, fileWatcher settings)
+ * - Cloud session tokens
+ * - Last session information
+ *
+ * Unlike ConfigStore, SessionStore handles ephemeral, machine-local state
+ * that is NOT shared between collaborators.
+ */
+interface SessionStore {
+    /**
+     * Load session state from storage.
+     *
+     * @returns GitGovSession object or null if not found
+     */
+    loadSession(): Promise<GitGovSession | null>;
+    /**
+     * Save session state to storage.
+     *
+     * @param session - The session state to persist
+     */
+    saveSession(session: GitGovSession): Promise<void>;
+    /**
+     * Detect actor from private key files.
+     *
+     * Optional method for implementations that support actor auto-detection
+     * from .key files in the actors directory.
+     *
+     * @returns Actor ID (e.g., "human:camilo-v2") or null if not detectable
+     */
+    detectActorFromKeyFiles?(): Promise<string | null>;
+}
+
+/**
+ * ConfigStore Interface
+ *
+ * Abstraction for config.json persistence.
+ * Enables backend-agnostic access to GitGovernance project configuration
+ * (filesystem, memory for tests, or future cloud backends).
+ *
+ * NOTE: Session state (.session.json) is handled by SessionStore, not ConfigStore.
+ * This separation allows different backends for config (immutable, versioned)
+ * vs session (ephemeral, local).
+ */
+
+/**
+ * Interface for project configuration persistence.
+ *
+ * ConfigStore manages the project config.json file which is:
+ * - Versioned in Git (shared between collaborators)
+ * - Contains project-level settings (protocolVersion, projectId, rootCycle, etc.)
+ * - Rarely changes after initial setup
+ *
+ * Implementations:
+ * - FsConfigStore: Filesystem-based (.gitgov/config.json)
+ * - MemoryConfigStore: In-memory for tests
+ *
+ * @example
+ * ```typescript
+ * // Production with filesystem
+ * const store = new FsConfigStore('/path/to/project');
+ * const config = await store.loadConfig();
+ *
+ * // Tests with memory
+ * const store = new MemoryConfigStore();
+ * store.setConfig({ protocolVersion: '1.0', ... });
+ * ```
+ */
+interface ConfigStore {
+    /**
+     * Load project configuration from config.json
+     *
+     * @returns GitGovConfig or null if not found/invalid
+     */
+    loadConfig(): Promise<GitGovConfig | null>;
+    /**
+     * Save project configuration to config.json
+     *
+     * @param config - Configuration to persist
+     */
+    saveConfig(config: GitGovConfig): Promise<void>;
+}
+
+/**
+ * KeyProvider Interface
+ *
+ * Abstracts private key storage for Actor signing operations.
+ * Enables different backends: filesystem (development), environment variables (serverless),
+ * or cloud KMS (enterprise).
+ *
+ * @module key_provider
+ */
+/**
+ * Error codes for KeyProvider operations.
+ */
+type KeyProviderErrorCode = 'KEY_NOT_FOUND' | 'KEY_READ_ERROR' | 'KEY_WRITE_ERROR' | 'KEY_DELETE_ERROR' | 'INVALID_KEY_FORMAT' | 'INVALID_ACTOR_ID';
+/**
+ * Error thrown when key operations fail.
+ */
+declare class KeyProviderError extends Error {
+    readonly code: KeyProviderErrorCode;
+    readonly actorId?: string | undefined;
+    constructor(message: string, code: KeyProviderErrorCode, actorId?: string | undefined);
+}
+/**
+ * Interface for managing private key storage.
+ * Implementations handle the actual persistence mechanism.
+ *
+ * @example
+ * ```typescript
+ * // Filesystem backend (development)
+ * const provider = new FsKeyProvider({ actorsDir: '.gitgov/actors' });
+ *
+ * // Environment backend (serverless)
+ * const provider = new EnvKeyProvider({ prefix: 'GITGOV_KEY_' });
+ *
+ * // Usage
+ * const privateKey = await provider.getPrivateKey('actor:human:alice');
+ * if (privateKey) {
+ *   const signature = signPayload(payload, privateKey, actorId, role);
+ * }
+ * ```
+ */
+interface KeyProvider {
+    /**
+     * Retrieves the private key for an actor.
+     * @param actorId - The actor's ID (e.g., 'actor:human:alice')
+     * @returns The base64-encoded private key, or null if not found
+     */
+    getPrivateKey(actorId: string): Promise<string | null>;
+    /**
+     * Stores a private key for an actor.
+     * @param actorId - The actor's ID
+     * @param privateKey - The base64-encoded private key
+     * @throws KeyProviderError if write fails
+     */
+    setPrivateKey(actorId: string, privateKey: string): Promise<void>;
+    /**
+     * Checks if a private key exists for an actor.
+     * @param actorId - The actor's ID
+     * @returns true if key exists, false otherwise
+     */
+    hasPrivateKey(actorId: string): Promise<boolean>;
+    /**
+     * Deletes the private key for an actor.
+     * @param actorId - The actor's ID
+     * @returns true if key was deleted, false if it didn't exist
+     */
+    deletePrivateKey(actorId: string): Promise<boolean>;
+}
+
+/**
+ * Options for file listing.
+ */
+type FileListOptions = {
+    /** Glob patterns to ignore (e.g., ['node_modules/**']) */
+    ignore?: string[];
+    /** Only return files (not directories). Default: true */
+    onlyFiles?: boolean;
+    /** Return absolute paths instead of relative. Default: false */
+    absolute?: boolean;
+    /** Maximum depth to traverse. Default: unlimited */
+    maxDepth?: number;
+};
+/**
+ * File statistics returned by stat().
+ */
+type FileStats = {
+    /** File size in bytes */
+    size: number;
+    /** Last modification time as timestamp (ms since epoch) */
+    mtime: number;
+    /** Whether it's a file (not directory) */
+    isFile: boolean;
+};
+/**
+ * Options for FsFileLister.
+ */
+type FsFileListerOptions = {
+    /** Base directory for all operations */
+    cwd: string;
+};
+/**
+ * Options for MemoryFileLister.
+ */
+type MemoryFileListerOptions = {
+    /** Map of filePath -> content */
+    files?: Map<string, string> | Record<string, string>;
+    /** Map of filePath -> stats (optional, generated if not provided) */
+    stats?: Map<string, FileStats>;
+};
+
+/**
+ * FileLister Interface
+ *
+ * Abstracts file listing and reading operations for serverless compatibility.
+ * Enables modules like ScopeSelector and IndexerAdapter to work without
+ * direct filesystem dependencies.
+ *
+ * @module file_lister
+ */
+
+/**
+ * Interface for listing and reading files.
+ * Abstracts filesystem operations for serverless compatibility.
+ *
+ * @example
+ * ```typescript
+ * // Filesystem backend (development/CLI)
+ * import { FsFileLister } from '@gitgov/core/fs';
+ * const lister = new FsFileLister({ cwd: '/path/to/project' });
+ *
+ * // Memory backend (testing)
+ * import { MemoryFileLister } from '@gitgov/core/memory';
+ * const lister = new MemoryFileLister({ files: { 'src/index.ts': 'code...' } });
+ *
+ * // Usage
+ * const files = await lister.list(['**\/*.ts']);
+ * const content = await lister.read('src/index.ts');
+ * ```
+ */
+interface FileLister {
+    /**
+     * [EARS-FL01] Lists files matching glob patterns.
+     * @param patterns - Glob patterns to match (e.g., ['**\/*.ts', 'src/**'])
+     * @param options - Optional configuration for listing
+     * @returns Array of file paths relative to cwd
+     */
+    list(patterns: string[], options?: FileListOptions): Promise<string[]>;
+    /**
+     * [EARS-FL02] Checks if a file exists.
+     * @param filePath - Path relative to cwd
+     * @returns true if file exists, false otherwise
+     */
+    exists(filePath: string): Promise<boolean>;
+    /**
+     * [EARS-FL03] Reads file content as string.
+     * @param filePath - Path relative to cwd
+     * @returns File content as UTF-8 string
+     * @throws FileListerError if file doesn't exist or can't be read
+     */
+    read(filePath: string): Promise<string>;
+    /**
+     * [EARS-FL04] Gets file statistics.
+     * @param filePath - Path relative to cwd
+     * @returns File stats (size, mtime)
+     * @throws FileListerError if file doesn't exist
+     */
+    stat(filePath: string): Promise<FileStats>;
+}
+
+/**
+ * Type Definitions for GitModule
+ *
+ * These types define the contracts for Git operations,
+ * dependencies, and data structures used throughout the module.
+ */
+/**
+ * Options for executing shell commands
+ */
+type ExecOptions = {
+    /** Working directory for the command */
+    cwd?: string;
+    /** Additional environment variables */
+    env?: Record<string, string>;
+    /** Timeout in milliseconds */
+    timeout?: number;
+};
+/**
+ * Result of executing a shell command
+ */
+type ExecResult = {
+    /** Exit code (0 = success) */
+    exitCode: number;
+    /** Standard output */
+    stdout: string;
+    /** Standard error output */
+    stderr: string;
+};
+/**
+ * Dependencies required by LocalGitModule
+ *
+ * This module uses dependency injection to allow testing with mocks
+ * and support different execution environments.
+ */
+type GitModuleDependencies = {
+    /** Path to the Git repository root (optional, auto-detected if not provided) */
+    repoRoot?: string;
+    /** Function to execute shell commands (required) */
+    execCommand: (command: string, args: string[], options?: ExecOptions) => Promise<ExecResult>;
+};
+/**
+ * Options for retrieving commit history
+ */
+type GetCommitHistoryOptions = {
+    /** Maximum number of commits to return */
+    maxCount?: number;
+    /** Path filter (e.g., ".gitgov/") */
+    pathFilter?: string;
+    /** Output format (default: "json") */
+    format?: 'json' | 'text';
+};
+/**
+ * Information about a commit in the history
+ */
+type CommitInfo = {
+    /** Commit hash */
+    hash: string;
+    /** Commit message */
+    message: string;
+    /** Commit author (name <email>) */
+    author: string;
+    /** Commit date (ISO 8601) */
+    date: string;
+    /** List of modified files (optional) */
+    files?: string[];
+};
+/**
+ * Information about a changed file
+ */
+type ChangedFile = {
+    /** Change status: A (Added), M (Modified), D (Deleted) */
+    status: 'A' | 'M' | 'D';
+    /** File path relative to repository root */
+    file: string;
+};
+/**
+ * Author information for commits
+ */
+type CommitAuthor = {
+    /** Author name */
+    name: string;
+    /** Author email */
+    email: string;
+};
+
+/**
+ * Custom Error Classes for GitModule
+ *
+ * These errors provide typed exceptions for better error handling
+ * and diagnostics in the Git module operations.
+ */
+/**
+ * Base error class for all Git-related errors
+ */
+declare class GitError extends Error {
+    constructor(message: string);
+}
+/**
+ * Error thrown when a Git command fails
+ */
+declare class GitCommandError extends GitError {
+    readonly stderr: string;
+    readonly stdout?: string | undefined;
+    readonly command?: string | undefined;
+    constructor(message: string, stderr?: string, command?: string | undefined, stdout?: string);
+}
+/**
+ * Error thrown when a branch does not exist
+ */
+declare class BranchNotFoundError extends GitError {
+    readonly branchName: string;
+    constructor(branchName: string);
+}
+/**
+ * Error thrown when a file does not exist in a commit
+ */
+declare class FileNotFoundError extends GitError {
+    readonly filePath: string;
+    readonly commitHash: string;
+    constructor(filePath: string, commitHash: string);
+}
+/**
+ * Error thrown when a merge conflict occurs
+ */
+declare class MergeConflictError extends GitError {
+    readonly conflictedFiles: string[];
+    constructor(conflictedFiles: string[]);
+}
+/**
+ * Error thrown when a rebase conflict occurs
+ */
+declare class RebaseConflictError extends GitError {
+    readonly conflictedFiles: string[];
+    constructor(conflictedFiles: string[]);
+}
+/**
+ * Error thrown when trying to continue/abort a rebase that is not in progress
+ */
+declare class RebaseNotInProgressError extends GitError {
+    constructor();
+}
+/**
+ * Error thrown when trying to create a branch that already exists
+ */
+declare class BranchAlreadyExistsError extends GitError {
+    readonly branchName: string;
+    constructor(branchName: string);
+}
+
+/**
+ * GitModule - Low-level Git Operations
+ *
+ * This module provides backend-agnostic access to Git operations.
+ *
+ * IMPORTANT: This module only exports the interface and types.
+ * For implementations, use:
+ * - @gitgov/core/fs for LocalGitModule (CLI-based)
+ * - @gitgov/core/memory for MemoryGitModule (testing)
+ *
+ * @example
+ * ```typescript
+ * // Import interface and types
+ * import type { IGitModule } from '@gitgov/core';
+ *
+ * // Import CLI implementation from fs entry point
+ * import { LocalGitModule } from '@gitgov/core/fs';
+ *
+ * // Import memory implementation from memory entry point
+ * import { MemoryGitModule } from '@gitgov/core/memory';
+ * ```
+ *
+ * @module git
+ */
+
+/**
+ * IGitModule - Interface for Git operations
+ *
+ * Implementations:
+ * - LocalGitModule: Uses execCommand to run git CLI (production)
+ * - MemoryGitModule: In-memory mock for unit tests
+ * - Future: GitHubGitModule for SaaS API-based operations
+ *
+ * All methods are async to support both local CLI execution
+ * and future API-based implementations (GitHub REST/GraphQL).
+ */
+interface IGitModule {
+    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>;
+}
+
+type index_BranchAlreadyExistsError = BranchAlreadyExistsError;
+declare const index_BranchAlreadyExistsError: typeof BranchAlreadyExistsError;
+type index_BranchNotFoundError = BranchNotFoundError;
+declare const index_BranchNotFoundError: typeof BranchNotFoundError;
+type index_ChangedFile = ChangedFile;
+type index_CommitAuthor = CommitAuthor;
+type index_CommitInfo = CommitInfo;
+type index_ExecOptions = ExecOptions;
+type index_ExecResult = ExecResult;
+type index_FileNotFoundError = FileNotFoundError;
+declare const index_FileNotFoundError: typeof FileNotFoundError;
+type index_GetCommitHistoryOptions = GetCommitHistoryOptions;
+type index_GitCommandError = GitCommandError;
+declare const index_GitCommandError: typeof GitCommandError;
+type index_GitError = GitError;
+declare const index_GitError: typeof GitError;
+type index_GitModuleDependencies = GitModuleDependencies;
+type index_IGitModule = IGitModule;
+type index_MergeConflictError = MergeConflictError;
+declare const index_MergeConflictError: typeof MergeConflictError;
+type index_RebaseConflictError = RebaseConflictError;
+declare const index_RebaseConflictError: typeof RebaseConflictError;
+type index_RebaseNotInProgressError = RebaseNotInProgressError;
+declare const index_RebaseNotInProgressError: typeof RebaseNotInProgressError;
+declare namespace index {
+  export { index_BranchAlreadyExistsError as BranchAlreadyExistsError, index_BranchNotFoundError as BranchNotFoundError, type index_ChangedFile as ChangedFile, type index_CommitAuthor as CommitAuthor, type index_CommitInfo as CommitInfo, type index_ExecOptions as ExecOptions, type index_ExecResult as ExecResult, index_FileNotFoundError as FileNotFoundError, type index_GetCommitHistoryOptions as GetCommitHistoryOptions, index_GitCommandError as GitCommandError, index_GitError as GitError, type index_GitModuleDependencies as GitModuleDependencies, type index_IGitModule as IGitModule, index_MergeConflictError as MergeConflictError, index_RebaseConflictError as RebaseConflictError, index_RebaseNotInProgressError as RebaseNotInProgressError };
+}
+
+export { type ActorState as A, type ConfigStore as C, type ExecOptions as E, type FsFileListerOptions as F, type GitGovConfig as G, type IGitModule as I, type KeyProvider as K, type MemoryFileListerOptions as M, type RecordStore as R, type SessionStore as S, type GitGovSession as a, type GitModuleDependencies as b, type ExecResult as c, type ChangedFile as d, type GetCommitHistoryOptions as e, type CommitInfo as f, type CommitAuthor as g, type ISessionManager as h, type SyncPreferencesUpdate as i, type SyncStatus as j, type AuditState as k, type AuditStateUpdate as l, type IConfigManager as m, type SyncConfig as n, type SyncDefaults as o, KeyProviderError as p, type KeyProviderErrorCode as q, type FileListOptions as r, type FileLister as s, type FileStats as t, index as u };