@egentica/codemap 0.1.5

package/dist/core/CodeMap.js

@@ -0,0 +1,880 @@
+"use strict";
+/**
+ * CodeMap - Main orchestrator class.
+ *
+ * Ties together FileSystemGraph, FileSystemIO, Scanner, PluginRegistry, and QueryEngine
+ * into a single cohesive API. This is the entry point for all CodeMap consumers.
+ *
+ * Architecture:
+ * - Single entry point for all operations
+ * - Dependency injection via FileSystemProvider
+ * - Plugin-based extensibility
+ * - Event-driven lifecycle hooks
+ * - Zero Egentica coupling
+ *
+ * @codemap.domain.name CodeMap Core API
+ * @codemap.usage Initialize CodeMap instances and configure root path and file system provider
+ * @codemap.usage Register or unregister plugins for language parsing and feature extensions
+ * @codemap.usage Access query engine, filesystem gateway, or target resolver APIs
+ * @codemap.usage Hook into lifecycle events (scan, file operations) for custom behavior
+ * @codemap.usage Change core CodeMap architecture or orchestration logic
+ * @codemap.policy This is the ONLY public API. All other classes are internal implementation.
+ * @codemap.policy FileSystemProvider defaults to Node.js filesystem — consumers can override if needed.
+ *
+ * @example Basic Usage
+ * ```typescript
+ * import { CodeMap, NodeFsProvider } from '@egentica/codemap';
+ *
+ * // Initialize
+ * const codemap = new CodeMap({
+ *   rootPath: '/project',
+ *   provider: new NodeFsProvider()
+ * });
+ *
+ * // Register plugins
+ * codemap.registerPlugin(new TypeScriptParser());
+ * codemap.registerPlugin(new TimeWarpPlugin());
+ *
+ * // Scan project
+ * await codemap.scan();
+ *
+ * // Query
+ * const results = codemap.query.search({ query: 'auth login' });
+ * ```
+ *
+ * @example Event Hooks
+ * ```typescript
+ * // Hook into file writes
+ * codemap.on('file:write:before', async (payload) => {
+ *   console.log('About to write:', payload.path);
+ * });
+ *
+ * // Hook into scan events
+ * codemap.on('scan:file', async (payload) => {
+ *   console.log('Scanned:', payload.file.relativePath);
+ * });
+ * ```
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeMap = void 0;
+const FileSystemGraph_1 = require("./FileSystemGraph");
+const FileSystemIO_1 = require("./FileSystemIO");
+const TargetResolver_1 = require("./TargetResolver");
+const Scanner_1 = require("./Scanner");
+const PluginRegistry_1 = require("./PluginRegistry");
+const ParserRegistry_1 = require("./ParserRegistry");
+const QueryEngine_1 = require("./QueryEngine");
+const EventBus_1 = require("./EventBus");
+const HelpRegistry_1 = require("./HelpRegistry");
+const GroupStore_1 = require("./GroupStore");
+const SessionTransactionLog_1 = require("./SessionTransactionLog");
+const ChecklistStore_1 = require("./ChecklistStore");
+const BackupManager_1 = require("./BackupManager");
+const AnnotationStore_1 = require("./AnnotationStore");
+const LabelStore_1 = require("./LabelStore");
+const DisplayFilter_1 = require("./DisplayFilter");
+const path = __importStar(require("node:path"));
+const NodeFsProvider_js_1 = __importDefault(require("../storage/NodeFsProvider.js"));
+/**
+ * CodeMap orchestrator.
+ * Main entry point for all CodeMap operations.
+ */
+class CodeMap {
+    // ── Core Components ────────────────────────────────────────────────────────
+    /**
+     * Root path of the project.
+     */
+    rootPath;
+    /**
+     * Knowledge graph access.
+     *
+     * Direct read-only access to the file system graph.
+     * Contains all files, symbols, and dependencies.
+     *
+     * @example
+     * ```typescript
+     * const file = codemap.graph.getFile('src/auth/login.ts');
+     * const allFiles = codemap.graph.getAllFiles();
+     * ```
+     */
+    graph;
+    /**
+     * Internal event bus.
+     */
+    eventBus;
+    /**
+     * Target resolver (central path/symbol formatting).
+     */
+    targetResolver;
+    /**
+     * File system gateway (emits lifecycle events).
+     */
+    fsGateway;
+    /**
+     * Scanner (walks directory tree).
+     */
+    scanner;
+    /**
+     * Plugin registry for managing plugin lifecycle.
+     */
+    pluginRegistry;
+    /**
+     * Parser registry for bundled language parsers.
+     */
+    parserRegistry;
+    /**
+     * Help registry (core + plugin help topics).
+     */
+    _helpRegistry;
+    /**
+     * Backup manager (hybrid backup system for persistent storage).
+     */
+    _backupManager;
+    /**
+     * Display filter (hint and annotation suppression).
+     */
+    _displayFilter;
+    /**
+     * Group store (persistent code organization).
+     */
+    _groupStore;
+    /**
+     * Annotation store (persistent metadata storage).
+     */
+    _annotationStore;
+    /**
+     * Label store (persistent label system).
+     */
+    _labelStore;
+    /**
+     * Session transaction log (semi-persistent session tracking).
+     */
+    _sessionLog;
+    /**
+     * Checklist store (persistent workflow guidance).
+     */
+    _checklistStore;
+    /**
+     * Query engine (search and traversal).
+     */
+    queryEngine;
+    /**
+     * File system provider (always defined after construction).
+     */
+    provider;
+    /**
+     * Full config loaded from .codemap/config.json.
+     */
+    _config = {};
+    /**
+     * Track whether parsers have been auto-loaded.
+     */
+    _parsersLoaded = false;
+    // ── Public API ─────────────────────────────────────────────────────────────
+    constructor(config) {
+        this.rootPath = config.rootPath;
+        this.provider = config.provider ?? NodeFsProvider_js_1.default; // Always assigned
+        // Load full config from disk asynchronously (non-blocking)
+        this.loadConfig().catch(err => {
+            console.error('[CodeMap] Failed to load config:', err);
+        });
+        // Initialize core components
+        this.graph = new FileSystemGraph_1.FileSystemGraph(config.rootPath);
+        this.eventBus = new EventBus_1.EventBus();
+        this.targetResolver = new TargetResolver_1.TargetResolver(config.rootPath);
+        this.fsGateway = new FileSystemIO_1.FileSystemIO(this.provider);
+        // Give FileSystemIO access to CodeMap for parser lookups
+        this.fsGateway.setCodeMap(this);
+        // Bridge FileSystemIO events to EventBus (for session tracking and external listeners)
+        this.fsGateway.on('file:write:before', (payload) => {
+            this.eventBus.emit('file:write:before', payload);
+        });
+        this.fsGateway.on('file:write:after', (payload) => {
+            this.eventBus.emit('file:write:after', payload);
+        });
+        this.fsGateway.on('file:delete', (payload) => {
+            this.eventBus.emit('file:delete', payload);
+        });
+        this.fsGateway.on('file:rename', (payload) => {
+            this.eventBus.emit('file:rename', payload);
+        });
+        this.scanner = new Scanner_1.Scanner({
+            rootPath: config.rootPath,
+            provider: this.provider,
+            eventBus: this.eventBus,
+            graph: this.graph,
+            ignorePatterns: config.ignorePatterns,
+            bypassHardcodedIgnoreList: config.bypassHardcodedIgnoreList
+        });
+        this.pluginRegistry = new PluginRegistry_1.PluginRegistry(this);
+        this.parserRegistry = new ParserRegistry_1.ParserRegistry();
+        this._helpRegistry = new HelpRegistry_1.HelpRegistry();
+        // Initialize backup manager first (needed by stores)
+        this._backupManager = new BackupManager_1.BackupManager(config.rootPath, this.provider);
+        // Load config asynchronously (non-blocking)
+        this._backupManager.loadConfig().catch(err => {
+            console.error('[CodeMap] Failed to load backup config:', err);
+        });
+        // Initialize display filter
+        this._displayFilter = new DisplayFilter_1.DisplayFilter(config.rootPath, this.provider);
+        // Load config and state asynchronously (non-blocking)
+        this._displayFilter.loadConfig().catch(err => {
+            console.error('[CodeMap] Failed to load display filter config:', err);
+        });
+        this._displayFilter.load().catch(err => {
+            console.error('[CodeMap] Failed to load display filter state:', err);
+        });
+        // Initialize stores with backup manager
+        this._groupStore = new GroupStore_1.GroupStore(config.rootPath, this.provider, this._backupManager);
+        this._annotationStore = new AnnotationStore_1.AnnotationStore(this.provider, path.join(config.rootPath, '.codemap'), this._backupManager);
+        this._labelStore = new LabelStore_1.LabelStore(config.rootPath, this.provider, this._backupManager);
+        this._sessionLog = new SessionTransactionLog_1.SessionTransactionLog(this.provider, path.join(config.rootPath, '.codemap'));
+        this._checklistStore = new ChecklistStore_1.ChecklistStore(this.provider, path.join(config.rootPath, '.codemap'));
+        this.queryEngine = new QueryEngine_1.QueryEngine({
+            graph: this.graph,
+            groupStore: this._groupStore,
+            eventBus: this.eventBus
+        });
+        // Wire up automatic session transaction tracking
+        this.setupSessionTracking();
+    }
+    /**
+     * Setup automatic transaction tracking for session logging.
+     *
+     * Hooks into lifecycle events to automatically track:
+     * - File operations (create, update, delete, rename)
+     * - Group operations (add, notate)
+     * - Annotation operations (add)
+     *
+     * All tracked operations are logged to .codemap/session-transactions.json
+     * until session close (codemap_close).
+     */
+    setupSessionTracking() {
+        // Track file writes (create and update)
+        this.eventBus.on('file:write:after', async (payload) => {
+            const { path: filePath } = payload;
+            if (!filePath)
+                return;
+            await this._sessionLog.track('file:update', filePath);
+        });
+        // Track file deletions
+        this.eventBus.on('file:delete', async (payload) => {
+            const { path: filePath } = payload;
+            if (!filePath)
+                return;
+            await this._sessionLog.track('file:delete', filePath);
+        });
+        // Track file renames
+        this.eventBus.on('file:rename', async (payload) => {
+            const { oldPath, newPath } = payload;
+            if (!oldPath || !newPath)
+                return;
+            await this._sessionLog.track('file:rename', oldPath, { from: oldPath, to: newPath });
+        });
+    }
+    /**
+     * Load config from .codemap/config.json.
+     * Called during initialization, stores config for tool access.
+     */
+    async loadConfig() {
+        const configPath = path.join(this.rootPath, '.codemap', 'config.json');
+        try {
+            const exists = await this.provider.exists(configPath);
+            if (!exists) {
+                return; // Use defaults
+            }
+            const content = await this.provider.read(configPath);
+            this._config = JSON.parse(content);
+        }
+        catch (error) {
+            console.error('[CodeMap] Failed to load config:', error);
+            // Continue with empty config
+        }
+    }
+    /**
+     * Register a plugin.
+     *
+     * Plugins hook into lifecycle events and extend CodeMap functionality.
+     * Examples: language parsers, TimeWarp, custom enrichments.
+     *
+     * @param plugin - Plugin to register
+     */
+    async registerPlugin(plugin) {
+        await this.pluginRegistry.register(plugin);
+    }
+    /**
+     * Unregister a plugin by name.
+     *
+     * @param name - Plugin name
+     * @returns True if plugin was unregistered
+     */
+    async unregisterPlugin(name) {
+        return this.pluginRegistry.unregister(name);
+    }
+    /**
+     * Execute full project scan.
+     *
+     * Walks directory tree, emits events, populates graph.
+     * Automatically loads bundled parsers on first scan.
+     * Plugins hook into scan:file events to extract symbols.
+     *
+     * @returns Scan statistics
+     */
+    async scan() {
+        // Auto-load parsers and plugins on first scan (only if not already loaded)
+        if (!this._parsersLoaded && this.parserRegistry.count === 0) {
+            await this.parserRegistry.autoloadParsers(this, this._config);
+            await this.pluginRegistry.autoloadPlugins(this._config);
+            this._parsersLoaded = true;
+        }
+        return this.scanner.scan();
+    }
+    /**
+     * Query engine access.
+     *
+     * Provides search, traversal, and discovery methods.
+     *
+     * @example
+     * ```typescript
+     * const results = codemap.query.search({ query: 'auth' });
+     * const importers = codemap.query.findImporters('src/auth.ts');
+     * ```
+     */
+    get query() {
+        return this.queryEngine;
+    }
+    /**
+     * File system gateway access.
+     *
+     * All file operations go through this gateway.
+     * Emits lifecycle events (file:write:before, file:write:after, etc.).
+     *
+     * @example
+     * ```typescript
+     * const content = await codemap.fs.read('src/index.ts');
+     * await codemap.fs.write('src/new.ts', 'export const x = 1;');
+     * ```
+     */
+    get fs() {
+        return {
+            read: (path) => this.fsGateway.read(path),
+            write: async (path, content) => {
+                await this.fsGateway.write(path, content);
+            },
+            exists: (path) => this.fsGateway.exists(path)
+        };
+    }
+    /**
+     * I/O gateway access.
+     *
+     * Provides full filesystem operations with lifecycle event emission.
+     * Storage-agnostic: works with any FileSystemProvider (Node.js fs, database, memory, S3, etc.).
+     *
+     * All write operations (write, remove, rename, mkdir) emit lifecycle events
+     * that plugins hook into (TimeWarp, graph updates, logging, etc.).
+     *
+     * @example
+     * ```typescript
+     * // Read operations
+     * const entries = await codemap.io.readdir(dirPath);
+     * const stats = await codemap.io.stat(filePath);
+     * const content = await codemap.io.read(filePath);
+     *
+     * // Write operations (emit events)
+     * await codemap.io.write(path, content);     // Emits file:write:before/after
+     * await codemap.io.remove(path);             // Emits file:delete
+     * await codemap.io.rename(oldPath, newPath); // Emits file:rename
+     * await codemap.io.mkdir(dirPath);           // Creates directory
+     * await codemap.io.append(path, text);       // Appends to file
+     * ```
+     */
+    get io() {
+        return this.fsGateway;
+    }
+    /**
+     * Target resolver access.
+     *
+     * Central resolution and formatting for all paths/symbols.
+     * Use this to convert between absolute paths and relative paths.
+     *
+     * @example
+     * ```typescript
+     * const resolved = codemap.resolver.resolve('src/main/index.ts');
+     * const relativePath = resolved.relativePath; // "src/main/index.ts"
+     * ```
+     */
+    get resolver() {
+        return this.targetResolver;
+    }
+    /**
+     * Label store access.
+     *
+     * Manage labels for organizing and categorizing code entities.
+     *
+     * @example
+     * ```typescript
+     * const labels = await codemap.labels.list();
+     * await codemap.labels.assign('my-label', ['src/auth/login.ts']);
+     * ```
+     */
+    get labels() {
+        return this._labelStore;
+    }
+    /**
+     * Group store access.
+     *
+     * Manage code groups for organizing related files and symbols.
+     *
+     * @example
+     * ```typescript
+     * const groups = await codemap.groups.list();
+     * const group = await codemap.groups.get('auth-system');
+     * ```
+     */
+    get groups() {
+        return this._groupStore;
+    }
+    /**
+     * Session transaction log access.
+     *
+     * Track changes and operations during a session.
+     *
+     * @example
+     * ```typescript
+     * const history = await codemap.sessions.list();
+     * const session = await codemap.sessions.get(sessionId);
+     * ```
+     */
+    get sessions() {
+        return this._sessionLog;
+    }
+    /**
+     * Annotation store access.
+     *
+     * Manage code annotations for documentation and metadata.
+     *
+     * @example
+     * ```typescript
+     * await codemap.annotations.add('src/auth.ts', {
+     *   key: 'domain.name',
+     *   value: 'Authentication System'
+     * });
+     * ```
+     */
+    get annotations() {
+        return this._annotationStore;
+    }
+    /**
+     * Register a lifecycle event handler.
+     *
+     * Implements CodeMapHost interface for plugins.
+     *
+     * @param event - Event name
+     * @param handler - Event handler
+     */
+    on(event, handler) {
+        this.eventBus.on(event, handler);
+    }
+    /**
+     * Remove event handler.
+     *
+     * @param event - Event name
+     * @param handler - Handler to remove
+     */
+    off(event, handler) {
+        this.eventBus.off(event, handler);
+    }
+    /**
+     * Add a symbol to the graph.
+     *
+     * Implements CodeMapHost interface for plugins.
+     * Used by language parsers to enrich the graph.
+     *
+     * @param symbol - Symbol metadata
+     */
+    addSymbol(symbol) {
+        // Add symbol to file's symbols array
+        const file = this.graph.getFile(symbol.file.relativePath);
+        if (!file) {
+            throw new Error(`Cannot add symbol: file not found: ${symbol.file.relativePath}`);
+        }
+        if (!file.symbols) {
+            file.symbols = [];
+        }
+        const symbolEntry = {
+            name: symbol.name,
+            kind: symbol.kind,
+            startLine: symbol.line,
+            startCol: 0,
+            endLine: symbol.line,
+            endCol: 0,
+            exported: false, // Parsers can override if available
+            // Deprecated fields for backward compatibility
+            line: symbol.line,
+            bodyEnd: symbol.line
+        };
+        file.symbols.push(symbolEntry);
+    }
+    /**
+     * Add a dependency edge to the graph.
+     *
+     * Implements CodeMapHost interface for plugins.
+     * Used by parsers to track import relationships.
+     *
+     * @param from - Source file (relative path)
+     * @param to - Target file (relative path)
+     */
+    addDependency(from, to) {
+        this.graph.addDependency(from, to);
+    }
+    /**
+     * Get plugin-specific configuration from .codemap/config.json.
+     * Returns undefined if plugin config not present.
+     *
+     * @param pluginName - Name of the plugin (should match Plugin.name)
+     * @returns Plugin configuration object or undefined
+     */
+    getPluginConfig(pluginName) {
+        if (!this._config || !this._config.plugins) {
+            return undefined;
+        }
+        return this._config.plugins[pluginName];
+    }
+    /**
+     * Set plugin metadata on a file.
+     * Emits 'metadata:set' event for tracking.
+     *
+     * @param path - File path (relative or absolute)
+     * @param key - Metadata key (namespace: pluginName.fieldName)
+     * @param value - Metadata value (must be JSON-serializable)
+     */
+    setMetadata(path, key, value) {
+        const file = this.graph.getFile(path);
+        if (!file) {
+            throw new Error(`File not found: ${path}`);
+        }
+        if (!file.metadata) {
+            file.metadata = {};
+        }
+        file.metadata[key] = value;
+        // Emit event for tracking
+        this.eventBus.emit('metadata:set', { path, key, value });
+    }
+    /**
+     * Get plugin metadata from a file.
+     * Emits 'metadata:get' event for tracking.
+     *
+     * @param path - File path (relative or absolute)
+     * @param key - Metadata key (namespace: pluginName.fieldName)
+     * @returns Metadata value or undefined if not found
+     */
+    getMetadata(path, key) {
+        const file = this.graph.getFile(path);
+        if (!file || !file.metadata) {
+            return undefined;
+        }
+        const value = file.metadata[key];
+        // Emit event for tracking
+        this.eventBus.emit('metadata:get', { path, key, value });
+        return value;
+    }
+    /**
+     * Get a file entry from the graph (read-only).
+     * Delegates to FileSystemGraph for consistent access.
+     *
+     * @param path - File path (relative or absolute)
+     * @returns File entry or undefined if not found
+     */
+    getFile(path) {
+        return this.graph.getFile(path);
+    }
+    /**
+     * Query the graph with advanced filters (read-only).
+     * Delegates to QueryEngine for consistent search behavior.
+     *
+     * @param options - Search options
+     * @returns Search results sorted by relevance
+     */
+    queryGraph(options) {
+        const envelope = this.queryEngine.search({
+            query: options.query,
+            mode: options.mode || 'text',
+            maxResults: options.maxResults || 10,
+        });
+        // Extract results from envelope (handle empty data gracefully)
+        if (!envelope.data) {
+            return [];
+        }
+        return envelope.data.results.map(result => ({
+            file: result.file,
+            relevance: result.relevance,
+            reasons: result.reasons,
+        }));
+    }
+    /**
+     * Get all files that import or are imported by a given file.
+     * Traverses the dependency graph recursively.
+     *
+     * @param path - File path (relative or absolute)
+     * @param direction - 'imports' (what it imports) or 'importers' (what imports it)
+     * @param maxDepth - Maximum traversal depth (default: 3)
+     * @returns Array of file entries in dependency chain
+     */
+    traverseDependencies(path, direction, maxDepth = 3) {
+        const file = this.graph.getFile(path);
+        if (!file) {
+            return [];
+        }
+        const visited = new Set();
+        const results = [];
+        const traverse = (currentPath, depth) => {
+            if (depth > maxDepth || visited.has(currentPath)) {
+                return;
+            }
+            visited.add(currentPath);
+            const current = this.graph.getFile(currentPath);
+            if (!current) {
+                return;
+            }
+            // Get related paths based on direction
+            const relatedPaths = direction === 'imports'
+                ? current.references
+                : current.referencedBy;
+            for (const relatedPath of relatedPaths) {
+                const relatedFile = this.graph.getFile(relatedPath);
+                if (relatedFile && !visited.has(relatedPath)) {
+                    results.push(relatedFile);
+                    traverse(relatedPath, depth + 1);
+                }
+            }
+        };
+        traverse(path, 0);
+        return results;
+    }
+    /**
+     * Get graph statistics.
+     *
+     * @returns File/directory/symbol counts
+     */
+    getStats() {
+        let symbolCount = 0;
+        for (const file of this.graph.getAllFiles()) {
+            symbolCount += file.symbols?.length || 0;
+        }
+        return {
+            files: this.graph.getFileCount(),
+            directories: this.graph.getDirectoryCount(),
+            symbols: symbolCount,
+            dependencies: this.graph.getDependencyCount()
+        };
+    }
+    /**
+     * Get file entry by relative path.
+     * Returns file metadata including symbols if available.
+    /**
+     * Get registered plugins.
+     *
+     * @returns Array of plugin names
+     */
+    getPlugins() {
+        return this.pluginRegistry.getRegisteredPlugins();
+    }
+    /**
+     * Get plugin info (name, version, registration time).
+     * \n   * @returns Array of plugin metadata
+     */
+    getPluginInfo() {
+        return this.pluginRegistry.getPluginInfo();
+    }
+    /**
+     * Get help registry.
+     *
+     * Provides access to the help topic registry for both core and plugin help content.
+     * Plugins can register their own help topics via this registry.
+     *
+     * @returns HelpRegistry instance
+     */
+    get helpRegistry() {
+        return this._helpRegistry;
+    }
+    /**
+     * Get group store.
+     *
+     * Provides access to the persistent group storage for organizing code.
+     * Groups persist in .codemap/groups.json and survive reboots.
+     *
+     * @returns GroupStore instance
+     */
+    get groupStore() {
+        return this._groupStore;
+    }
+    /**
+     * Get annotation store.
+     *
+     * Provides access to the annotation metadata storage system.
+     * Annotations persist in .codemap/annotations.json.
+     *
+     * @returns AnnotationStore instance
+     */
+    get annotationStore() {
+        return this._annotationStore;
+    }
+    /**
+     * Get label store.
+     *
+     * Provides access to the persistent label system for organizing code.
+     * Labels persist in .codemap/labels.json and survive reboots.
+     *
+     * @returns LabelStore instance
+     */
+    get labelStore() {
+        return this._labelStore;
+    }
+    /**
+     * Get backup manager.
+     *
+     * Provides access to the backup system for persistent storage files.
+     * Manages daily and turn-based backups with configurable retention.
+     *
+     * @returns BackupManager instance
+     */
+    get backupManager() {
+        return this._backupManager;
+    }
+    /**
+     * Get display filter.
+     *
+     * Provides access to the hint and annotation suppression system.
+     * Reduces context pollution by tracking and suppressing repetitive content.
+     *
+     * @returns DisplayFilter instance
+     */
+    get displayFilter() {
+        return this._displayFilter;
+    }
+    /**
+     * Get session transaction log.
+     *
+     * Provides access to the semi-persistent session tracking system.
+     * Transactions persist in .codemap/session-transactions.json until session close.
+     *
+     * @returns SessionTransactionLog instance
+     */
+    get sessionLog() {
+        return this._sessionLog;
+    }
+    /**
+     * Get checklist store.
+     *
+     * Provides access to the persistent checklist system for workflow guidance.
+     * Checklists persist in .codemap/checklists.json (version controlled).
+     *
+     * @returns ChecklistStore instance
+     */
+    get checklistStore() {
+        return this._checklistStore;
+    }
+    /**
+     * Get config.
+     *
+     * Provides access to the full config loaded from .codemap/config.json.
+     * Config is loaded asynchronously during initialization.
+     *
+     * @returns Config object
+     */
+    get config() {
+        return this._config;
+    }
+    /**
+     * Set the parser registry.
+     * Called by the MCP server after creating ParserRegistry.
+     *
+     * @param registry - Parser registry instance
+     */
+    setParserRegistry(registry) {
+        this.parserRegistry = registry;
+    }
+    /**
+     * Get loaded language parsers.
+     *
+     * @returns Array of parser metadata (name, version, extensions)
+     */
+    getLoadedParsers() {
+        if (!this.parserRegistry) {
+            return [];
+        }
+        return this.parserRegistry.getLoadedParsers();
+    }
+    /**
+     * Get a language parser that can handle the given file.
+     * Used for annotation manipulation and other parser-specific operations.
+     *
+     * @param filePath - File path to find parser for
+     * @returns LanguageParser instance or undefined
+     */
+    getParserForFile(filePath) {
+        return this.pluginRegistry.getParserForFile(filePath);
+    }
+    /**
+     * Collect orient contributions from all registered plugins.
+     * Emits `orient:contribute` event and gathers markdown sections from plugins.
+     *
+     * @returns Array of plugin contributions sorted by priority (high to low)
+     */
+    async collectOrientContributions() {
+        const contributions = [];
+        // Emit orient:contribute event
+        // Plugins can push contributions to the array via the payload
+        await this.eventBus.emit('orient:contribute', { contributions });
+        // Sort by priority (higher first)
+        return contributions.sort((a, b) => (b.priority || 0) - (a.priority || 0));
+    }
+    /**
+     * Cleanup and shutdown.
+     *
+     * Unregisters all plugins, clears event handlers.
+     * Call this before disposing of CodeMap instance.
+     */
+    async dispose() {
+        await this.pluginRegistry.unregisterAll();
+        this.eventBus.removeAllListeners();
+    }
+}
+exports.CodeMap = CodeMap;
+//# sourceMappingURL=CodeMap.js.map