@grafema/core 0.1.0-alpha.5 → 0.1.1-alpha

package/dist/core/CoverageAnalyzer.d.ts

@@ -0,0 +1,65 @@
+/**
+ * CoverageAnalyzer - Calculates analysis coverage for a project
+ *
+ * Determines which files in a project have been analyzed and categorizes
+ * files into three groups:
+ * - Analyzed: Files that appear as MODULE nodes in the graph
+ * - Unsupported: Files with extensions that no indexer can handle
+ * - Unreachable: Files with supported extensions but not in the graph
+ *
+ * Usage:
+ *   const analyzer = new CoverageAnalyzer(graphBackend, '/path/to/project');
+ *   const result = await analyzer.analyze();
+ */
+import type { GraphBackend } from '@grafema/types';
+/**
+ * Coverage analysis result
+ */
+export interface CoverageResult {
+    projectPath: string;
+    total: number;
+    analyzed: {
+        count: number;
+        files: string[];
+    };
+    unsupported: {
+        count: number;
+        byExtension: Record<string, string[]>;
+    };
+    unreachable: {
+        count: number;
+        files: string[];
+        byExtension: Record<string, string[]>;
+    };
+    percentages: {
+        analyzed: number;
+        unsupported: number;
+        unreachable: number;
+    };
+}
+/**
+ * CoverageAnalyzer calculates what percentage of a codebase has been analyzed.
+ */
+export declare class CoverageAnalyzer {
+    private graph;
+    private projectPath;
+    constructor(graph: GraphBackend, projectPath: string);
+    /**
+     * Analyze the project and return coverage statistics
+     */
+    analyze(): Promise<CoverageResult>;
+    /**
+     * Get list of analyzed files from the graph (MODULE nodes)
+     */
+    private getAnalyzedFiles;
+    /**
+     * Scan project directory for all code files
+     * Respects common ignore patterns (node_modules, .git, etc.)
+     */
+    private scanProjectFiles;
+    /**
+     * Recursively walk directory and collect code files
+     */
+    private walkDirectory;
+}
+//# sourceMappingURL=CoverageAnalyzer.d.ts.map

package/dist/core/CoverageAnalyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CoverageAnalyzer.d.ts","sourceRoot":"","sources":["../../src/core/CoverageAnalyzer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAc,MAAM,gBAAgB,CAAC;AAwC/D;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE;QACR,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,EAAE,CAAC;KACjB,CAAC;IACF,WAAW,EAAE;QACX,KAAK,EAAE,MAAM,CAAC;QACd,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;KACvC,CAAC;IACF,WAAW,EAAE;QACX,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,EAAE,CAAC;QAChB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;KACvC,CAAC;IACF,WAAW,EAAE;QACX,QAAQ,EAAE,MAAM,CAAC;QACjB,WAAW,EAAE,MAAM,CAAC;QACpB,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC;CACH;AAED;;GAEG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,KAAK,CAAe;IAC5B,OAAO,CAAC,WAAW,CAAS;gBAEhB,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM;IAKpD;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,cAAc,CAAC;IAsExC;;OAEG;YACW,gBAAgB;IAiB9B;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAMxB;;OAEG;IACH,OAAO,CAAC,aAAa;CA0CtB"}

package/dist/core/CoverageAnalyzer.js

@@ -0,0 +1,198 @@
+/**
+ * CoverageAnalyzer - Calculates analysis coverage for a project
+ *
+ * Determines which files in a project have been analyzed and categorizes
+ * files into three groups:
+ * - Analyzed: Files that appear as MODULE nodes in the graph
+ * - Unsupported: Files with extensions that no indexer can handle
+ * - Unreachable: Files with supported extensions but not in the graph
+ *
+ * Usage:
+ *   const analyzer = new CoverageAnalyzer(graphBackend, '/path/to/project');
+ *   const result = await analyzer.analyze();
+ */
+import { readdirSync, existsSync, lstatSync } from 'fs';
+import { join, relative, extname } from 'path';
+/**
+ * Supported file extensions by language
+ */
+const JS_SUPPORTED = ['.js', '.mjs', '.cjs', '.jsx', '.ts', '.tsx'];
+const RUST_SUPPORTED = ['.rs'];
+const SUPPORTED_EXTENSIONS = new Set([...JS_SUPPORTED, ...RUST_SUPPORTED]);
+/**
+ * Known code file extensions (for scanning)
+ * Files with these extensions are considered source code
+ */
+const CODE_EXTENSIONS = new Set([
+    // Supported
+    ...JS_SUPPORTED,
+    ...RUST_SUPPORTED,
+    // Unsupported but tracked
+    '.go', '.kt', '.java', '.py', '.rb', '.php', '.c', '.cpp', '.h', '.hpp',
+    '.cs', '.swift', '.scala', '.sql', '.graphql', '.gql',
+]);
+/**
+ * Directories to always skip during scanning
+ */
+const SKIP_DIRS = new Set([
+    'node_modules',
+    '.git',
+    '.grafema',
+    'dist',
+    'build',
+    'out',
+    'coverage',
+    '.next',
+    '.nuxt',
+    '__pycache__',
+    'target', // Rust
+    'vendor',
+]);
+/**
+ * CoverageAnalyzer calculates what percentage of a codebase has been analyzed.
+ */
+export class CoverageAnalyzer {
+    graph;
+    projectPath;
+    constructor(graph, projectPath) {
+        this.graph = graph;
+        this.projectPath = projectPath;
+    }
+    /**
+     * Analyze the project and return coverage statistics
+     */
+    async analyze() {
+        // Step 1: Get all MODULE nodes from the graph
+        const analyzedFiles = await this.getAnalyzedFiles();
+        const analyzedSet = new Set(analyzedFiles);
+        // Step 2: Scan project for all code files
+        const allCodeFiles = this.scanProjectFiles();
+        // Step 3: Categorize files
+        const unsupportedByExt = {};
+        const unreachableByExt = {};
+        const unreachableFiles = [];
+        for (const file of allCodeFiles) {
+            if (analyzedSet.has(file)) {
+                continue; // Already analyzed
+            }
+            const ext = extname(file).toLowerCase();
+            if (SUPPORTED_EXTENSIONS.has(ext)) {
+                // Supported but not in graph = unreachable
+                unreachableFiles.push(file);
+                if (!unreachableByExt[ext]) {
+                    unreachableByExt[ext] = [];
+                }
+                unreachableByExt[ext].push(file);
+            }
+            else {
+                // Not supported = unsupported
+                if (!unsupportedByExt[ext]) {
+                    unsupportedByExt[ext] = [];
+                }
+                unsupportedByExt[ext].push(file);
+            }
+        }
+        // Calculate counts
+        const unsupportedCount = Object.values(unsupportedByExt)
+            .reduce((sum, files) => sum + files.length, 0);
+        const unreachableCount = unreachableFiles.length;
+        const analyzedCount = analyzedFiles.length;
+        const total = analyzedCount + unsupportedCount + unreachableCount;
+        // Calculate percentages (handle division by zero)
+        const percentages = {
+            analyzed: total > 0 ? Math.round((analyzedCount / total) * 100) : 0,
+            unsupported: total > 0 ? Math.round((unsupportedCount / total) * 100) : 0,
+            unreachable: total > 0 ? Math.round((unreachableCount / total) * 100) : 0,
+        };
+        return {
+            projectPath: this.projectPath,
+            total,
+            analyzed: {
+                count: analyzedCount,
+                files: analyzedFiles,
+            },
+            unsupported: {
+                count: unsupportedCount,
+                byExtension: unsupportedByExt,
+            },
+            unreachable: {
+                count: unreachableCount,
+                files: unreachableFiles,
+                byExtension: unreachableByExt,
+            },
+            percentages,
+        };
+    }
+    /**
+     * Get list of analyzed files from the graph (MODULE nodes)
+     */
+    async getAnalyzedFiles() {
+        const files = [];
+        // Use queryNodes with type: 'MODULE'
+        for await (const node of this.graph.queryNodes({ type: 'MODULE' })) {
+            if (node.file) {
+                // Store relative path for consistency
+                const relativePath = node.file.startsWith(this.projectPath)
+                    ? relative(this.projectPath, node.file)
+                    : node.file;
+                files.push(relativePath);
+            }
+        }
+        return files;
+    }
+    /**
+     * Scan project directory for all code files
+     * Respects common ignore patterns (node_modules, .git, etc.)
+     */
+    scanProjectFiles() {
+        const files = [];
+        this.walkDirectory(this.projectPath, files);
+        return files;
+    }
+    /**
+     * Recursively walk directory and collect code files
+     */
+    walkDirectory(dir, files, depth = 0) {
+        // Safety: limit recursion depth
+        if (depth > 20)
+            return;
+        if (!existsSync(dir))
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return; // Skip directories we can't read
+        }
+        for (const entry of entries) {
+            // Skip hidden files and directories
+            if (entry.startsWith('.'))
+                continue;
+            // Skip known non-source directories
+            if (SKIP_DIRS.has(entry))
+                continue;
+            const fullPath = join(dir, entry);
+            // Skip symlinks to avoid infinite loops
+            try {
+                const stat = lstatSync(fullPath);
+                if (stat.isSymbolicLink())
+                    continue;
+                if (stat.isDirectory()) {
+                    this.walkDirectory(fullPath, files, depth + 1);
+                }
+                else if (stat.isFile()) {
+                    const ext = extname(entry).toLowerCase();
+                    if (CODE_EXTENSIONS.has(ext)) {
+                        // Store relative path
+                        files.push(relative(this.projectPath, fullPath));
+                    }
+                }
+            }
+            catch {
+                // Skip files we can't stat
+                continue;
+            }
+        }
+    }
+}

package/dist/core/FileNodeManager.d.ts

@@ -0,0 +1,40 @@
+/**
+ * FileNodeManager - utility for idempotent file node clearing
+ *
+ * Problem: Multiple phases create nodes for the same file:
+ * - INDEXING creates MODULE nodes
+ * - ANALYSIS creates FUNCTION, CLASS, SCOPE, etc. nodes
+ *
+ * When re-analyzing with forceAnalysis=true, we need to clear existing
+ * nodes BEFORE any phase creates new nodes for that file.
+ *
+ * Solution: Track "touched" files. First touch clears all nodes for that file.
+ * Subsequent touches (from other phases) are no-ops.
+ */
+import type { GraphBackend } from '@grafema/types';
+/**
+ * Clear all nodes for a file if it hasn't been touched yet in this analysis run.
+ *
+ * Thread-safety note: The touchedFiles Set is shared across concurrent Promise.all
+ * calls, but this is safe because:
+ * 1. The check (has) and add are synchronous operations
+ * 2. We add to the set BEFORE the async clear operation
+ * 3. Other concurrent calls will see the file as touched immediately
+ *
+ * @param graph - Graph backend with deleteNode support
+ * @param file - Absolute file path to clear nodes for
+ * @param touchedFiles - Set tracking files already touched in this run
+ * @returns Number of nodes deleted (0 if file was already touched or backend doesn't support delete)
+ */
+export declare function clearFileNodesIfNeeded(graph: GraphBackend, file: string, touchedFiles: Set<string>): Promise<number>;
+/**
+ * Clear a SERVICE node by ID.
+ * SERVICE nodes have file=directory_path (not individual files), so they need
+ * explicit clearing separate from file-based clearing.
+ *
+ * @param graph - Graph backend with deleteNode support
+ * @param serviceId - SERVICE node ID (e.g., "SERVICE:apps/api")
+ * @returns true if node was deleted, false otherwise
+ */
+export declare function clearServiceNodeIfExists(graph: GraphBackend, serviceId: string): Promise<boolean>;
+//# sourceMappingURL=FileNodeManager.d.ts.map

package/dist/core/FileNodeManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileNodeManager.d.ts","sourceRoot":"","sources":["../../src/core/FileNodeManager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,sBAAsB,CAC1C,KAAK,EAAE,YAAY,EACnB,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,GACxB,OAAO,CAAC,MAAM,CAAC,CAsCjB;AAED;;;;;;;;GAQG;AACH,wBAAsB,wBAAwB,CAC5C,KAAK,EAAE,YAAY,EACnB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,OAAO,CAAC,CAalB"}

package/dist/core/FileNodeManager.js

@@ -0,0 +1,84 @@
+/**
+ * FileNodeManager - utility for idempotent file node clearing
+ *
+ * Problem: Multiple phases create nodes for the same file:
+ * - INDEXING creates MODULE nodes
+ * - ANALYSIS creates FUNCTION, CLASS, SCOPE, etc. nodes
+ *
+ * When re-analyzing with forceAnalysis=true, we need to clear existing
+ * nodes BEFORE any phase creates new nodes for that file.
+ *
+ * Solution: Track "touched" files. First touch clears all nodes for that file.
+ * Subsequent touches (from other phases) are no-ops.
+ */
+/**
+ * Clear all nodes for a file if it hasn't been touched yet in this analysis run.
+ *
+ * Thread-safety note: The touchedFiles Set is shared across concurrent Promise.all
+ * calls, but this is safe because:
+ * 1. The check (has) and add are synchronous operations
+ * 2. We add to the set BEFORE the async clear operation
+ * 3. Other concurrent calls will see the file as touched immediately
+ *
+ * @param graph - Graph backend with deleteNode support
+ * @param file - Absolute file path to clear nodes for
+ * @param touchedFiles - Set tracking files already touched in this run
+ * @returns Number of nodes deleted (0 if file was already touched or backend doesn't support delete)
+ */
+export async function clearFileNodesIfNeeded(graph, file, touchedFiles) {
+    // Already touched in this run - nothing to clear
+    if (touchedFiles.has(file)) {
+        return 0;
+    }
+    // Mark as touched BEFORE clearing (sync operation, makes subsequent concurrent calls no-op)
+    touchedFiles.add(file);
+    // Skip if backend doesn't support deletion
+    if (!graph.deleteNode) {
+        return 0;
+    }
+    // Collect all nodes for this file
+    const nodesToDelete = [];
+    for await (const node of graph.queryNodes({ file })) {
+        nodesToDelete.push(node.id);
+    }
+    // Delete all of them - NO EXCLUSIONS
+    // MODULE nodes will be recreated by INDEXING phase
+    // FUNCTION/CLASS/etc will be recreated by ANALYSIS phase
+    for (const id of nodesToDelete) {
+        try {
+            await graph.deleteNode(id);
+        }
+        catch (err) {
+            // Log but continue - node might already be deleted by concurrent operation
+            console.warn(`[FileNodeManager] Failed to delete ${id}:`, err.message);
+        }
+    }
+    if (nodesToDelete.length > 0) {
+        const fileName = file.split('/').pop() || file;
+        console.log(`[FileNodeManager] Cleared ${nodesToDelete.length} nodes for ${fileName}`);
+    }
+    return nodesToDelete.length;
+}
+/**
+ * Clear a SERVICE node by ID.
+ * SERVICE nodes have file=directory_path (not individual files), so they need
+ * explicit clearing separate from file-based clearing.
+ *
+ * @param graph - Graph backend with deleteNode support
+ * @param serviceId - SERVICE node ID (e.g., "SERVICE:apps/api")
+ * @returns true if node was deleted, false otherwise
+ */
+export async function clearServiceNodeIfExists(graph, serviceId) {
+    if (!graph.deleteNode) {
+        return false;
+    }
+    try {
+        await graph.deleteNode(serviceId);
+        console.log(`[FileNodeManager] Cleared SERVICE node: ${serviceId}`);
+        return true;
+    }
+    catch (err) {
+        // Node might not exist on fresh analysis - that's OK
+        return false;
+    }
+}

package/dist/core/GraphFreshnessChecker.d.ts

@@ -0,0 +1,33 @@
+/**
+ * GraphFreshnessChecker - checks if graph data matches current files
+ *
+ * Compares contentHash stored in MODULE nodes against current file hashes.
+ * Used by `grafema check` to detect when files have changed since analysis.
+ */
+import type { NodeRecord } from '@grafema/types';
+export interface StaleModule {
+    id: string;
+    file: string;
+    storedHash: string;
+    currentHash: string | null;
+    reason: 'changed' | 'deleted' | 'unreadable';
+}
+export interface FreshnessResult {
+    isFresh: boolean;
+    staleModules: StaleModule[];
+    freshCount: number;
+    staleCount: number;
+    deletedCount: number;
+    checkDurationMs: number;
+}
+export interface FreshnessGraph {
+    queryNodes(query: {
+        type: string;
+    }): AsyncGenerator<NodeRecord, void, unknown>;
+}
+export declare class GraphFreshnessChecker {
+    checkFreshness(graph: FreshnessGraph): Promise<FreshnessResult>;
+    private _checkModuleFreshness;
+    private _fileExists;
+}
+//# sourceMappingURL=GraphFreshnessChecker.d.ts.map

package/dist/core/GraphFreshnessChecker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GraphFreshnessChecker.d.ts","sourceRoot":"","sources":["../../src/core/GraphFreshnessChecker.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,YAAY,CAAC;CAC9C;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE,WAAW,EAAE,CAAC;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,cAAc;IAC7B,UAAU,CAAC,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,cAAc,CAAC,UAAU,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;CAChF;AAUD,qBAAa,qBAAqB;IAC1B,cAAc,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC;YAyDvD,qBAAqB;YAoCrB,WAAW;CAQ1B"}

package/dist/core/GraphFreshnessChecker.js

@@ -0,0 +1,101 @@
+/**
+ * GraphFreshnessChecker - checks if graph data matches current files
+ *
+ * Compares contentHash stored in MODULE nodes against current file hashes.
+ * Used by `grafema check` to detect when files have changed since analysis.
+ */
+import { access, constants } from 'fs/promises';
+import { calculateFileHashAsync } from './HashUtils.js';
+const BATCH_SIZE = 50;
+export class GraphFreshnessChecker {
+    async checkFreshness(graph) {
+        const startTime = Date.now();
+        const modules = [];
+        for await (const node of graph.queryNodes({ type: 'MODULE' })) {
+            if (node.file && typeof node.contentHash === 'string') {
+                modules.push({
+                    id: node.id,
+                    file: node.file,
+                    contentHash: node.contentHash
+                });
+            }
+        }
+        if (modules.length === 0) {
+            return {
+                isFresh: true,
+                staleModules: [],
+                freshCount: 0,
+                staleCount: 0,
+                deletedCount: 0,
+                checkDurationMs: Date.now() - startTime
+            };
+        }
+        const staleModules = [];
+        let freshCount = 0;
+        let deletedCount = 0;
+        for (let i = 0; i < modules.length; i += BATCH_SIZE) {
+            const batch = modules.slice(i, i + BATCH_SIZE);
+            const results = await Promise.all(batch.map(module => this._checkModuleFreshness(module)));
+            for (const result of results) {
+                if (result === null) {
+                    freshCount++;
+                }
+                else {
+                    staleModules.push(result);
+                    if (result.reason === 'deleted') {
+                        deletedCount++;
+                    }
+                }
+            }
+        }
+        return {
+            isFresh: staleModules.length === 0,
+            staleModules,
+            freshCount,
+            staleCount: staleModules.length,
+            deletedCount,
+            checkDurationMs: Date.now() - startTime
+        };
+    }
+    async _checkModuleFreshness(module) {
+        const exists = await this._fileExists(module.file);
+        if (!exists) {
+            return {
+                id: module.id,
+                file: module.file,
+                storedHash: module.contentHash,
+                currentHash: null,
+                reason: 'deleted'
+            };
+        }
+        const currentHash = await calculateFileHashAsync(module.file);
+        if (currentHash === null) {
+            return {
+                id: module.id,
+                file: module.file,
+                storedHash: module.contentHash,
+                currentHash: null,
+                reason: 'unreadable'
+            };
+        }
+        if (currentHash !== module.contentHash) {
+            return {
+                id: module.id,
+                file: module.file,
+                storedHash: module.contentHash,
+                currentHash,
+                reason: 'changed'
+            };
+        }
+        return null;
+    }
+    async _fileExists(filePath) {
+        try {
+            await access(filePath, constants.R_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/core/HashUtils.d.ts

@@ -0,0 +1,24 @@
+/**
+ * HashUtils - unified hash computation for Grafema
+ *
+ * WHY THIS EXISTS:
+ * - 6 copies of the same hash computation existed across the codebase
+ * - Single source of truth ensures consistent hashing everywhere
+ * - Makes future algorithm changes (e.g., SHA-256 -> BLAKE3) trivial
+ */
+/**
+ * Calculate hash from a file path (synchronous).
+ * Returns null if file doesn't exist or is unreadable.
+ */
+export declare function calculateFileHash(filePath: string): string | null;
+/**
+ * Calculate hash from a file path (asynchronous).
+ * Returns null if file doesn't exist or is unreadable.
+ */
+export declare function calculateFileHashAsync(filePath: string): Promise<string | null>;
+/**
+ * Calculate hash from content string.
+ * Always returns a hash (never null).
+ */
+export declare function calculateContentHash(content: string): string;
+//# sourceMappingURL=HashUtils.d.ts.map

package/dist/core/HashUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HashUtils.d.ts","sourceRoot":"","sources":["../../src/core/HashUtils.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAQH;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAOjE;AAED;;;GAGG;AACH,wBAAsB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAOrF;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE5D"}

package/dist/core/HashUtils.js

@@ -0,0 +1,45 @@
+/**
+ * HashUtils - unified hash computation for Grafema
+ *
+ * WHY THIS EXISTS:
+ * - 6 copies of the same hash computation existed across the codebase
+ * - Single source of truth ensures consistent hashing everywhere
+ * - Makes future algorithm changes (e.g., SHA-256 -> BLAKE3) trivial
+ */
+import { createHash } from 'crypto';
+import { readFileSync } from 'fs';
+import { readFile } from 'fs/promises';
+const HASH_ALGORITHM = 'sha256';
+/**
+ * Calculate hash from a file path (synchronous).
+ * Returns null if file doesn't exist or is unreadable.
+ */
+export function calculateFileHash(filePath) {
+    try {
+        const content = readFileSync(filePath, 'utf-8');
+        return createHash(HASH_ALGORITHM).update(content).digest('hex');
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Calculate hash from a file path (asynchronous).
+ * Returns null if file doesn't exist or is unreadable.
+ */
+export async function calculateFileHashAsync(filePath) {
+    try {
+        const content = await readFile(filePath, 'utf-8');
+        return createHash(HASH_ALGORITHM).update(content).digest('hex');
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Calculate hash from content string.
+ * Always returns a hash (never null).
+ */
+export function calculateContentHash(content) {
+    return createHash(HASH_ALGORITHM).update(content).digest('hex');
+}

package/dist/core/IncrementalReanalyzer.d.ts

@@ -0,0 +1,36 @@
+/**
+ * IncrementalReanalyzer - selective re-analysis of stale modules
+ *
+ * HOW IT WORKS:
+ * 1. Clear all nodes for stale files (using clearFileNodesIfNeeded)
+ * 2. Re-create MODULE nodes with updated contentHash
+ * 3. Run JSASTAnalyzer.analyzeModule() for each stale module
+ * 4. Re-run enrichment plugins to rebuild cross-file edges
+ */
+import type { GraphBackend } from '@grafema/types';
+import type { StaleModule } from './GraphFreshnessChecker.js';
+export interface ReanalysisOptions {
+    skipEnrichment?: boolean;
+    onProgress?: (info: ReanalysisProgress) => void;
+}
+export interface ReanalysisProgress {
+    phase: 'clearing' | 'indexing' | 'analysis' | 'enrichment';
+    current: number;
+    total: number;
+    currentFile?: string;
+}
+export interface ReanalysisResult {
+    modulesReanalyzed: number;
+    modulesDeleted: number;
+    nodesCreated: number;
+    edgesCreated: number;
+    nodesCleared: number;
+    durationMs: number;
+}
+export declare class IncrementalReanalyzer {
+    private graph;
+    private projectPath;
+    constructor(graph: GraphBackend, projectPath: string);
+    reanalyze(staleModules: StaleModule[], options?: ReanalysisOptions): Promise<ReanalysisResult>;
+}
+//# sourceMappingURL=IncrementalReanalyzer.d.ts.map

package/dist/core/IncrementalReanalyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IncrementalReanalyzer.d.ts","sourceRoot":"","sources":["../../src/core/IncrementalReanalyzer.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAOH,OAAO,KAAK,EAAE,YAAY,EAAiB,MAAM,gBAAgB,CAAC;AAClE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAE9D,MAAM,WAAW,iBAAiB;IAChC,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,kBAAkB,KAAK,IAAI,CAAC;CACjD;AAED,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,UAAU,GAAG,UAAU,GAAG,UAAU,GAAG,YAAY,CAAC;IAC3D,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,gBAAgB;IAC/B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACpB;AAYD,qBAAa,qBAAqB;IAChC,OAAO,CAAC,KAAK,CAAe;IAC5B,OAAO,CAAC,WAAW,CAAS;gBAEhB,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM;IAK9C,SAAS,CACb,YAAY,EAAE,WAAW,EAAE,EAC3B,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAAC,gBAAgB,CAAC;CAkI7B"}