@grafema/core 0.2.5-beta → 0.2.7

package/src/core/GraphFreshnessChecker.ts

@@ -7,6 +7,7 @@
 
 import { access, constants } from 'fs/promises';
 import { calculateFileHashAsync } from './HashUtils.js';
+import { resolveNodeFile } from '../utils/resolveNodeFile.js';
 import type { NodeRecord } from '@grafema/types';
 
 export interface StaleModule {
@@ -39,7 +40,7 @@ interface ModuleInfo {
 const BATCH_SIZE = 50;
 
 export class GraphFreshnessChecker {
-  async checkFreshness(graph: FreshnessGraph): Promise<FreshnessResult> {
+  async checkFreshness(graph: FreshnessGraph, projectPath?: string): Promise<FreshnessResult> {
     const startTime = Date.now();
 
     const modules: ModuleInfo[] = [];
@@ -71,7 +72,7 @@ export class GraphFreshnessChecker {
     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))
+        batch.map(module => this._checkModuleFreshness(module, projectPath))
       );
 
       for (const result of results) {
@@ -96,8 +97,9 @@ export class GraphFreshnessChecker {
     };
   }
 
-  private async _checkModuleFreshness(module: ModuleInfo): Promise<StaleModule | null> {
-    const exists = await this._fileExists(module.file);
+  private async _checkModuleFreshness(module: ModuleInfo, projectPath?: string): Promise<StaleModule | null> {
+    const absoluteFile = projectPath ? resolveNodeFile(module.file, projectPath) : module.file;
+    const exists = await this._fileExists(absoluteFile);
     if (!exists) {
       return {
         id: module.id,
@@ -108,7 +110,7 @@ export class GraphFreshnessChecker {
       };
     }
 
-    const currentHash = await calculateFileHashAsync(module.file);
+    const currentHash = await calculateFileHashAsync(absoluteFile);
     if (currentHash === null) {
       return {
         id: module.id,

package/src/core/GuaranteeManager.ts

@@ -13,7 +13,7 @@
  */
 
 import { readFileSync, writeFileSync, existsSync } from 'fs';
-import { join } from 'path';
+import { join, isAbsolute, relative } from 'path';
 import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
 import { minimatch } from 'minimatch';
 
@@ -343,6 +343,72 @@ export class GuaranteeManager {
     };
   }
 
+  /**
+   * Extract type references from a Datalog rule.
+   * Matches node(X, "TYPE") and edge(X, Y, "TYPE") patterns.
+   * Returns unique types array. If nothing parseable, returns empty array.
+   */
+  extractRelevantTypes(rule: string): string[] {
+    const types = new Set<string>();
+
+    // Match node(X, "TYPE") patterns
+    const nodePattern = /node\(\s*\w+\s*,\s*"([^"]+)"\s*\)/g;
+    let match;
+    while ((match = nodePattern.exec(rule)) !== null) {
+      types.add(match[1]);
+    }
+
+    // Match edge(X, Y, "TYPE") patterns
+    const edgePattern = /edge\(\s*\w+\s*,\s*\w+\s*,\s*"([^"]+)"\s*\)/g;
+    while ((match = edgePattern.exec(rule)) !== null) {
+      types.add(match[1]);
+    }
+
+    return [...types];
+  }
+
+  /**
+   * Selectively check guarantees whose relevant types overlap with changedTypes.
+   * Guarantees with no parseable types are always checked (conservative).
+   * Returns CheckAllResult with total = all guarantees count,
+   * but results only for the checked subset.
+   */
+  async checkSelective(changedTypes: Set<string>): Promise<CheckAllResult> {
+    const guarantees = await this.list();
+    const results: GuaranteeCheckResult[] = [];
+    let passedCount = 0;
+    let failedCount = 0;
+    let errorCount = 0;
+
+    for (const g of guarantees) {
+      const relevantTypes = this.extractRelevantTypes(g.rule);
+      // If no types parseable, check conservatively; otherwise check only if overlap
+      const shouldCheck = relevantTypes.length === 0 ||
+        relevantTypes.some(t => changedTypes.has(t));
+
+      if (!shouldCheck) continue;
+
+      const result = await this.check(g.id);
+      results.push(result);
+
+      if (result.error) {
+        errorCount++;
+      } else if (result.passed) {
+        passedCount++;
+      } else {
+        failedCount++;
+      }
+    }
+
+    return {
+      total: guarantees.length,
+      passed: passedCount,
+      failed: failedCount,
+      errors: errorCount,
+      results
+    };
+  }
+
   /**
    * Удалить гарантию
    */
@@ -534,7 +600,9 @@ export class GuaranteeManager {
 
     // Матчим patterns
     for (const module of modules) {
-      const relativePath = module.file?.replace(this.projectPath, '').replace(/^\//, '') || '';
+      const relativePath = module.file
+        ? (isAbsolute(module.file) ? relative(this.projectPath, module.file) : module.file)
+        : '';
 
       for (const pattern of patterns) {
         if (minimatch(relativePath, pattern) || minimatch(module.file || '', pattern)) {

package/src/core/IncrementalReanalyzer.ts

@@ -10,10 +10,12 @@
 
 import { relative } from 'path';
 import { clearFileNodesIfNeeded } from './FileNodeManager.js';
+import { resolveNodeFile } from '../utils/resolveNodeFile.js';
 import { JSASTAnalyzer } from '../plugins/analysis/JSASTAnalyzer.js';
 import { InstanceOfResolver } from '../plugins/enrichment/InstanceOfResolver.js';
 import { ImportExportLinker } from '../plugins/enrichment/ImportExportLinker.js';
 import type { GraphBackend, PluginContext } from '@grafema/types';
+import { brandNodeInternal } from './brandNodeInternal.js';
 import type { StaleModule } from './GraphFreshnessChecker.js';
 
 export interface ReanalysisOptions {
@@ -90,7 +92,8 @@ export class IncrementalReanalyzer {
 
     for (let i = 0; i < modifiedModules.length; i++) {
       const module = modifiedModules[i];
-      const relativePath = relative(this.projectPath, module.file);
+      const absoluteFile = resolveNodeFile(module.file, this.projectPath);
+      const relativePath = relative(this.projectPath, absoluteFile);
 
       if (options.onProgress) {
         options.onProgress({
@@ -105,12 +108,12 @@ export class IncrementalReanalyzer {
         id: module.id,
         type: 'MODULE',
         name: relativePath,
-        file: module.file,
+        file: relativePath,
         contentHash: module.currentHash!,
         line: 0
       };
 
-      await this.graph.addNode(moduleNode);
+      await this.graph.addNode(brandNodeInternal(moduleNode));
       nodesCreated++;
       modulesToAnalyze.push(moduleNode);
     }