@grafema/core 0.1.0-alpha.1

package/src/plugins/validation/TypeScriptDeadCodeValidator.ts

@@ -0,0 +1,203 @@
+/**
+ * TypeScriptDeadCodeValidator - detects unused TypeScript constructs
+ *
+ * Checks:
+ * - Unused interfaces (no IMPLEMENTS edges)
+ * - Empty interfaces (no properties)
+ * - Interfaces with single implementation (possible over-engineering)
+ * - Unused enums (no references) - requires USES_TYPE edges
+ * - Unused type aliases (no references) - requires USES_TYPE edges
+ *
+ * NOTE: Full "unused type" detection requires USES_TYPE edges which track
+ * where types are used in function parameters, return types, and variables.
+ * Currently we can only detect interfaces without implementations.
+ */
+
+import { Plugin, createSuccessResult } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+
+/**
+ * Dead code issue
+ */
+interface DeadCodeIssue {
+  type: 'UNUSED_INTERFACE' | 'EMPTY_INTERFACE' | 'SINGLE_IMPLEMENTATION' | 'UNUSED_ENUM' | 'UNUSED_TYPE';
+  severity: 'WARNING' | 'INFO';
+  message: string;
+  nodeId: string;
+  name: string;
+  file?: string;
+  line?: number;
+}
+
+/**
+ * Validation summary
+ */
+interface ValidationSummary {
+  totalInterfaces: number;
+  unusedInterfaces: number;
+  emptyInterfaces: number;
+  singleImplInterfaces: number;
+  totalEnums: number;
+  totalTypes: number;
+  timeSeconds: string;
+}
+
+export class TypeScriptDeadCodeValidator extends Plugin {
+  get metadata(): PluginMetadata {
+    return {
+      name: 'TypeScriptDeadCodeValidator',
+      phase: 'VALIDATION',
+      priority: 50, // Lower priority - runs after other validators
+      creates: {
+        nodes: [],
+        edges: []
+      },
+      dependencies: ['JSASTAnalyzer'] // Requires TypeScript nodes to be created
+    };
+  }
+
+  async execute(context: PluginContext): Promise<PluginResult> {
+    const { graph } = context;
+
+    console.log('[TypeScriptDeadCodeValidator] Checking for dead TypeScript code...');
+    const startTime = Date.now();
+
+    const issues: DeadCodeIssue[] = [];
+
+    // Collect all interfaces
+    console.log('[TypeScriptDeadCodeValidator] Collecting interfaces...');
+    const interfaces: Map<string, { id: string; name: string; file?: string; line?: number; properties?: unknown[] }> = new Map();
+
+    for await (const node of graph.queryNodes({ nodeType: 'INTERFACE' })) {
+      // Skip external/reference interfaces
+      if ((node as { isExternal?: boolean }).isExternal) continue;
+
+      interfaces.set(node.id, {
+        id: node.id,
+        name: node.name as string,
+        file: node.file,
+        line: node.line as number | undefined,
+        properties: (node as { properties?: unknown[] }).properties
+      });
+    }
+    console.log(`[TypeScriptDeadCodeValidator] Found ${interfaces.size} interfaces`);
+
+    // Find interfaces with IMPLEMENTS or EXTENDS edges
+    console.log('[TypeScriptDeadCodeValidator] Checking implementations...');
+    const implementedInterfaces: Map<string, number> = new Map();
+
+    // Get all edges and filter by type (no queryEdges in GraphBackend yet)
+    const allEdges = await graph.getAllEdges?.() ?? [];
+    for (const edge of allEdges) {
+      if (edge.type === 'IMPLEMENTS' || edge.type === 'EXTENDS') {
+        const count = implementedInterfaces.get(edge.dst) || 0;
+        implementedInterfaces.set(edge.dst, count + 1);
+      }
+    }
+
+    // Analyze interfaces
+    let unusedCount = 0;
+    let emptyCount = 0;
+    let singleImplCount = 0;
+
+    for (const [id, iface] of interfaces) {
+      const implCount = implementedInterfaces.get(id) || 0;
+      const properties = iface.properties || [];
+
+      // Check for empty interface
+      if (properties.length === 0) {
+        emptyCount++;
+        issues.push({
+          type: 'EMPTY_INTERFACE',
+          severity: 'INFO',
+          message: `Empty interface '${iface.name}' at ${iface.file}:${iface.line || '?'} - consider using type alias or removing`,
+          nodeId: id,
+          name: iface.name,
+          file: iface.file,
+          line: iface.line
+        });
+      }
+
+      // Check for unused interface (no implementations)
+      if (implCount === 0) {
+        unusedCount++;
+        issues.push({
+          type: 'UNUSED_INTERFACE',
+          severity: 'WARNING',
+          message: `Interface '${iface.name}' at ${iface.file}:${iface.line || '?'} has no implementations`,
+          nodeId: id,
+          name: iface.name,
+          file: iface.file,
+          line: iface.line
+        });
+      }
+      // Check for single implementation (possible over-engineering)
+      else if (implCount === 1) {
+        singleImplCount++;
+        issues.push({
+          type: 'SINGLE_IMPLEMENTATION',
+          severity: 'INFO',
+          message: `Interface '${iface.name}' at ${iface.file}:${iface.line || '?'} has only one implementation - may be over-engineering`,
+          nodeId: id,
+          name: iface.name,
+          file: iface.file,
+          line: iface.line
+        });
+      }
+    }
+
+    // Count enums and types (for summary, full analysis requires USES_TYPE)
+    let enumCount = 0;
+    for await (const _node of graph.queryNodes({ nodeType: 'ENUM' })) {
+      enumCount++;
+    }
+
+    let typeCount = 0;
+    for await (const _node of graph.queryNodes({ nodeType: 'TYPE' })) {
+      typeCount++;
+    }
+
+    const totalTime = ((Date.now() - startTime) / 1000).toFixed(2);
+    const summary: ValidationSummary = {
+      totalInterfaces: interfaces.size,
+      unusedInterfaces: unusedCount,
+      emptyInterfaces: emptyCount,
+      singleImplInterfaces: singleImplCount,
+      totalEnums: enumCount,
+      totalTypes: typeCount,
+      timeSeconds: totalTime
+    };
+
+    console.log('[TypeScriptDeadCodeValidator] Summary:', summary);
+
+    // Report issues
+    const warnings = issues.filter(i => i.severity === 'WARNING');
+    const infos = issues.filter(i => i.severity === 'INFO');
+
+    if (warnings.length > 0) {
+      console.log(`[TypeScriptDeadCodeValidator] ⚠️  ${warnings.length} warning(s):`);
+      for (const issue of warnings) {
+        console.log(`  ⚠️  ${issue.message}`);
+      }
+    }
+
+    if (infos.length > 0) {
+      console.log(`[TypeScriptDeadCodeValidator] ℹ️  ${infos.length} info(s):`);
+      for (const issue of infos.slice(0, 5)) { // Limit to first 5
+        console.log(`  ℹ️  ${issue.message}`);
+      }
+      if (infos.length > 5) {
+        console.log(`  ... and ${infos.length - 5} more`);
+      }
+    }
+
+    if (issues.length === 0) {
+      console.log('[TypeScriptDeadCodeValidator] ✅ No dead TypeScript code detected');
+    }
+
+    return createSuccessResult(
+      { nodes: 0, edges: 0 },
+      { summary, issues }
+    );
+  }
+}

package/src/plugins/vcs/GitPlugin.ts

@@ -0,0 +1,344 @@
+/**
+ * Git VCS Plugin
+ *
+ * Плагин для работы с Git репозиториями
+ * Обнаруживает изменённые файлы и предоставляет их содержимое
+ */
+
+import { VCSPlugin, FileStatus } from './VCSPlugin.js';
+import type { VCSConfig, VCSPluginMetadata, ChangedFile, FileDiff, DiffHunk } from './VCSPlugin.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { readFile } from 'fs/promises';
+import { createHash } from 'crypto';
+
+const execAsync = promisify(exec);
+
+/**
+ * Commit info
+ */
+export interface CommitInfo {
+  hash: string;
+  author: string;
+  email: string;
+  timestamp: number;
+  message: string;
+}
+
+export class GitPlugin extends VCSPlugin {
+  private gitDir: string;
+
+  constructor(config: VCSConfig = {}) {
+    super(config);
+    this.gitDir = join(this.rootPath, '.git');
+  }
+
+  get metadata(): VCSPluginMetadata {
+    return {
+      name: 'git',
+      type: 'vcs',
+      supported: existsSync(this.gitDir)
+    };
+  }
+
+  /**
+   * Проверить доступность Git
+   */
+  async isAvailable(): Promise<boolean> {
+    try {
+      // Проверяем существование .git директории
+      if (!existsSync(this.gitDir)) {
+        return false;
+      }
+
+      // Проверяем работу git команды
+      const { stdout } = await this._exec('git rev-parse --git-dir');
+      return stdout.trim().length > 0;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Получить список изменённых файлов
+   */
+  async getChangedFiles(): Promise<ChangedFile[]> {
+    try {
+      // Получаем список файлов через git status --porcelain
+      const { stdout } = await this._exec('git status --porcelain');
+
+      if (!stdout.trim()) {
+        return []; // Нет изменений
+      }
+
+      const files: ChangedFile[] = [];
+      const lines = stdout.trim().split('\n');
+
+      for (const line of lines) {
+        // Git status format: XY filename
+        // X = index status, Y = working tree status
+        // После XY идёт пробел(ы), затем filename
+        const status = line.substring(0, 2);
+        // Убираем XY и все leading пробелы
+        const filePath = line.substring(2).trim();
+
+        // Пропускаем ignored и unmerged файлы
+        if (status === '!!' || status === 'UU') {
+          continue;
+        }
+
+        // Парсим статус
+        const parsedStatus = this._parseGitStatus(status);
+
+        // Получаем хеш содержимого для tracked файлов
+        let contentHash: string | null = null;
+        try {
+          const fullPath = join(this.rootPath, filePath);
+          if (existsSync(fullPath) && parsedStatus !== FileStatus.DELETED) {
+            const content = await readFile(fullPath, 'utf-8');
+            contentHash = this._hashContent(content);
+          }
+        } catch {
+          // Игнорируем ошибки чтения файла
+        }
+
+        files.push({
+          path: filePath,
+          status: parsedStatus,
+          contentHash
+        });
+      }
+
+      return files;
+    } catch (error) {
+      console.error('[GitPlugin] Failed to get changed files:', (error as Error).message);
+      return [];
+    }
+  }
+
+  /**
+   * Получить содержимое файла из HEAD
+   */
+  async getCommittedContent(filePath: string): Promise<string | null> {
+    try {
+      // Проверяем, отслеживается ли файл
+      const isTracked = await this.isTracked(filePath);
+      if (!isTracked) {
+        return null;
+      }
+
+      // Получаем содержимое из HEAD
+      const { stdout } = await this._exec(`git show HEAD:"${filePath}"`);
+      return stdout;
+    } catch {
+      // Файл может не существовать в HEAD (новый файл)
+      return null;
+    }
+  }
+
+  /**
+   * Получить diff для файла
+   */
+  async getFileDiff(filePath: string): Promise<FileDiff> {
+    try {
+      const { stdout } = await this._exec(`git diff HEAD -- "${filePath}"`);
+
+      if (!stdout.trim()) {
+        return { path: filePath, hunks: [] };
+      }
+
+      // Парсим unified diff
+      return this._parseUnifiedDiff(filePath, stdout);
+    } catch (error) {
+      console.error(`[GitPlugin] Failed to get diff for ${filePath}:`, (error as Error).message);
+      return { path: filePath, hunks: [] };
+    }
+  }
+
+  /**
+   * Получить текущую ветку
+   */
+  async getCurrentBranch(): Promise<string> {
+    try {
+      const { stdout } = await this._exec('git rev-parse --abbrev-ref HEAD');
+      return stdout.trim();
+    } catch {
+      return 'unknown';
+    }
+  }
+
+  /**
+   * Получить хеш последнего коммита
+   */
+  async getLastCommitHash(): Promise<string | null> {
+    try {
+      const { stdout } = await this._exec('git rev-parse HEAD');
+      return stdout.trim();
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Проверить, отслеживается ли файл
+   */
+  async isTracked(filePath: string): Promise<boolean> {
+    try {
+      await this._exec(`git ls-files --error-unmatch "${filePath}"`);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Вспомогательные методы
+   */
+
+  /**
+   * Выполнить git команду
+   */
+  private async _exec(command: string): Promise<{ stdout: string; stderr: string }> {
+    return await execAsync(command, {
+      cwd: this.rootPath,
+      maxBuffer: 10 * 1024 * 1024 // 10MB буфер для больших diff'ов
+    });
+  }
+
+  /**
+   * Парсить git status код в FileStatus
+   */
+  private _parseGitStatus(statusCode: string): string {
+    const index = statusCode[0];
+    const workingTree = statusCode[1];
+
+    // Приоритет: working tree > index
+    if (workingTree === 'M' || index === 'M') {
+      return FileStatus.MODIFIED;
+    }
+
+    if (workingTree === 'A' || index === 'A') {
+      return FileStatus.ADDED;
+    }
+
+    if (workingTree === 'D' || index === 'D') {
+      return FileStatus.DELETED;
+    }
+
+    if (workingTree === 'R' || index === 'R') {
+      return FileStatus.RENAMED;
+    }
+
+    if (workingTree === 'C' || index === 'C') {
+      return FileStatus.COPIED;
+    }
+
+    if (workingTree === '?') {
+      return FileStatus.UNTRACKED;
+    }
+
+    return FileStatus.MODIFIED; // По умолчанию
+  }
+
+  /**
+   * Парсить unified diff формат
+   */
+  private _parseUnifiedDiff(filePath: string, diffText: string): FileDiff {
+    const hunks: DiffHunk[] = [];
+    const lines = diffText.split('\n');
+
+    let currentHunk: DiffHunk | null = null;
+
+    for (const line of lines) {
+      // Начало нового hunk: @@ -oldStart,oldLines +newStart,newLines @@
+      if (line.startsWith('@@')) {
+        if (currentHunk) {
+          hunks.push(currentHunk);
+        }
+
+        const match = line.match(/@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@/);
+        if (match) {
+          currentHunk = {
+            oldStart: parseInt(match[1]),
+            oldLines: match[2] ? parseInt(match[2]) : 1,
+            newStart: parseInt(match[3]),
+            newLines: match[4] ? parseInt(match[4]) : 1,
+            lines: []
+          };
+        }
+        continue;
+      }
+
+      // Пропускаем заголовки diff
+      if (line.startsWith('diff --git') ||
+          line.startsWith('index ') ||
+          line.startsWith('---') ||
+          line.startsWith('+++')) {
+        continue;
+      }
+
+      // Добавляем строку в текущий hunk
+      if (currentHunk) {
+        currentHunk.lines.push(line);
+      }
+    }
+
+    // Добавляем последний hunk
+    if (currentHunk) {
+      hunks.push(currentHunk);
+    }
+
+    return { path: filePath, hunks };
+  }
+
+  /**
+   * Вычислить SHA256 хеш содержимого
+   */
+  private _hashContent(content: string): string {
+    return createHash('sha256').update(content, 'utf-8').digest('hex');
+  }
+
+  /**
+   * Получить список всех tracked файлов в репозитории
+   * (полезно для initial analysis)
+   */
+  async getAllTrackedFiles(): Promise<string[]> {
+    try {
+      const { stdout } = await this._exec('git ls-files');
+      return stdout.trim().split('\n').filter(line => line.length > 0);
+    } catch (error) {
+      console.error('[GitPlugin] Failed to get tracked files:', (error as Error).message);
+      return [];
+    }
+  }
+
+  /**
+   * Получить информацию о последнем коммите
+   */
+  async getLastCommitInfo(): Promise<CommitInfo | null> {
+    try {
+      const { stdout } = await this._exec('git log -1 --pretty=format:"%H%n%an%n%ae%n%at%n%s"');
+      const lines = stdout.split('\n');
+
+      return {
+        hash: lines[0],
+        author: lines[1],
+        email: lines[2],
+        timestamp: parseInt(lines[3]) * 1000,
+        message: lines[4]
+      };
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Проверить, есть ли uncommitted изменения
+   */
+  async hasUncommittedChanges(): Promise<boolean> {
+    const changedFiles = await this.getChangedFiles();
+    return changedFiles.length > 0;
+  }
+}