@grafema/core 0.1.0-alpha.1

package/dist/plugins/validation/ShadowingDetector.js

@@ -0,0 +1,119 @@
+/**
+ * ShadowingDetector - detects variable shadowing issues
+ *
+ * Detects two types of shadowing:
+ *
+ * 1. Cross-file shadowing:
+ *    - CLASS `User` defined in models.js
+ *    - VARIABLE `User` in handlers.js shadows the class
+ *    - Method calls on the variable go to wrong target
+ *
+ * 2. Scope-aware shadowing:
+ *    - import { User } from './models'
+ *    - function handler() { const User = {...}; User.save(); }
+ *    - Local variable shadows the imported class
+ *
+ * Implementation notes:
+ * - Datalog doesn't support inequality (\=), so we use JS filtering
+ * - queryNodes is an async generator, use getAllNodes for arrays
+ */
+import { Plugin, createSuccessResult } from '../Plugin.js';
+export class ShadowingDetector extends Plugin {
+    get metadata() {
+        return {
+            name: 'ShadowingDetector',
+            phase: 'VALIDATION',
+            priority: 80, // After enrichment, before other validators
+            creates: {
+                nodes: [],
+                edges: []
+            }
+        };
+    }
+    async execute(context) {
+        const { graph } = context;
+        console.log('[ShadowingDetector] Checking for variable shadowing...');
+        const issues = [];
+        // Get all relevant nodes
+        const allClasses = await graph.getAllNodes({ type: 'CLASS' });
+        const allVariables = await graph.getAllNodes({ type: 'VARIABLE' });
+        const allConstants = await graph.getAllNodes({ type: 'CONSTANT' });
+        const allImports = await graph.getAllNodes({ type: 'IMPORT' });
+        // Build maps for efficient lookup
+        const classesByName = new Map();
+        for (const cls of allClasses) {
+            const name = cls.name;
+            if (!classesByName.has(name)) {
+                classesByName.set(name, []);
+            }
+            classesByName.get(name).push(cls);
+        }
+        const importsByFileAndLocal = new Map();
+        for (const imp of allImports) {
+            const key = `${imp.file}:${imp.local}`;
+            importsByFileAndLocal.set(key, imp);
+        }
+        // 1. Cross-file shadowing: VARIABLE shadows CLASS from another file
+        for (const variable of allVariables) {
+            const name = variable.name;
+            const classesWithSameName = classesByName.get(name);
+            if (classesWithSameName) {
+                // Find classes in different files
+                const shadowedClasses = classesWithSameName.filter(c => c.file !== variable.file);
+                for (const shadowedClass of shadowedClasses) {
+                    issues.push({
+                        type: 'CROSS_FILE_SHADOW',
+                        severity: 'WARNING',
+                        message: `Variable "${name}" at ${variable.file}:${variable.line || '?'} shadows class "${name}" from ${shadowedClass.file}`,
+                        shadowingNodeId: variable.id,
+                        shadowedName: name,
+                        shadowedNodeId: shadowedClass.id,
+                        shadowedFile: shadowedClass.file,
+                        file: variable.file,
+                        line: variable.line
+                    });
+                }
+            }
+        }
+        // 2. Scope-aware shadowing: local VARIABLE/CONSTANT shadows IMPORT
+        // Variables/constants with parentScopeId (inside functions) that shadow imports
+        const allLocalVars = [...allVariables, ...allConstants].filter(v => v.parentScopeId);
+        for (const localVar of allLocalVars) {
+            const name = localVar.name;
+            const importKey = `${localVar.file}:${name}`;
+            const shadowedImport = importsByFileAndLocal.get(importKey);
+            if (shadowedImport) {
+                const nodeType = localVar.type === 'CONSTANT' ? 'constant' : 'variable';
+                issues.push({
+                    type: 'SCOPE_SHADOW',
+                    severity: 'WARNING',
+                    message: `Local ${nodeType} "${name}" at ${localVar.file}:${localVar.line || '?'} shadows imported "${name}"`,
+                    shadowingNodeId: localVar.id,
+                    shadowedName: name,
+                    shadowedNodeId: shadowedImport.id,
+                    file: localVar.file,
+                    line: localVar.line,
+                    scope: localVar.parentScopeId
+                });
+            }
+        }
+        const crossFileCount = issues.filter(i => i.type === 'CROSS_FILE_SHADOW').length;
+        const scopeCount = issues.filter(i => i.type === 'SCOPE_SHADOW').length;
+        const summary = {
+            crossFileShadows: crossFileCount,
+            scopeShadows: scopeCount,
+            totalIssues: issues.length
+        };
+        console.log('[ShadowingDetector] Summary:', summary);
+        if (issues.length > 0) {
+            console.log('[ShadowingDetector] Shadowing issues found:');
+            for (const issue of issues) {
+                console.log(`  ${issue.type === 'CROSS_FILE_SHADOW' ? '📁' : '🔒'} ${issue.message}`);
+            }
+        }
+        else {
+            console.log('[ShadowingDetector] No shadowing issues detected');
+        }
+        return createSuccessResult({ nodes: 0, edges: 0 }, { summary, issues });
+    }
+}

package/dist/plugins/validation/TypeScriptDeadCodeValidator.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+export declare class TypeScriptDeadCodeValidator extends Plugin {
+    get metadata(): PluginMetadata;
+    execute(context: PluginContext): Promise<PluginResult>;
+}
+//# sourceMappingURL=TypeScriptDeadCodeValidator.d.ts.map

package/dist/plugins/validation/TypeScriptDeadCodeValidator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypeScriptDeadCodeValidator.d.ts","sourceRoot":"","sources":["../../../src/plugins/validation/TypeScriptDeadCodeValidator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AA4BhF,qBAAa,2BAA4B,SAAQ,MAAM;IACrD,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CAgJ7D"}

package/dist/plugins/validation/TypeScriptDeadCodeValidator.js

@@ -0,0 +1,151 @@
+/**
+ * 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';
+export class TypeScriptDeadCodeValidator extends Plugin {
+    get metadata() {
+        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) {
+        const { graph } = context;
+        console.log('[TypeScriptDeadCodeValidator] Checking for dead TypeScript code...');
+        const startTime = Date.now();
+        const issues = [];
+        // Collect all interfaces
+        console.log('[TypeScriptDeadCodeValidator] Collecting interfaces...');
+        const interfaces = new Map();
+        for await (const node of graph.queryNodes({ nodeType: 'INTERFACE' })) {
+            // Skip external/reference interfaces
+            if (node.isExternal)
+                continue;
+            interfaces.set(node.id, {
+                id: node.id,
+                name: node.name,
+                file: node.file,
+                line: node.line,
+                properties: node.properties
+            });
+        }
+        console.log(`[TypeScriptDeadCodeValidator] Found ${interfaces.size} interfaces`);
+        // Find interfaces with IMPLEMENTS or EXTENDS edges
+        console.log('[TypeScriptDeadCodeValidator] Checking implementations...');
+        const implementedInterfaces = 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 = {
+            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/dist/plugins/vcs/GitPlugin.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Git VCS Plugin
+ *
+ * Плагин для работы с Git репозиториями
+ * Обнаруживает изменённые файлы и предоставляет их содержимое
+ */
+import { VCSPlugin } from './VCSPlugin.js';
+import type { VCSConfig, VCSPluginMetadata, ChangedFile, FileDiff } from './VCSPlugin.js';
+/**
+ * Commit info
+ */
+export interface CommitInfo {
+    hash: string;
+    author: string;
+    email: string;
+    timestamp: number;
+    message: string;
+}
+export declare class GitPlugin extends VCSPlugin {
+    private gitDir;
+    constructor(config?: VCSConfig);
+    get metadata(): VCSPluginMetadata;
+    /**
+     * Проверить доступность Git
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Получить список изменённых файлов
+     */
+    getChangedFiles(): Promise<ChangedFile[]>;
+    /**
+     * Получить содержимое файла из HEAD
+     */
+    getCommittedContent(filePath: string): Promise<string | null>;
+    /**
+     * Получить diff для файла
+     */
+    getFileDiff(filePath: string): Promise<FileDiff>;
+    /**
+     * Получить текущую ветку
+     */
+    getCurrentBranch(): Promise<string>;
+    /**
+     * Получить хеш последнего коммита
+     */
+    getLastCommitHash(): Promise<string | null>;
+    /**
+     * Проверить, отслеживается ли файл
+     */
+    isTracked(filePath: string): Promise<boolean>;
+    /**
+     * Вспомогательные методы
+     */
+    /**
+     * Выполнить git команду
+     */
+    private _exec;
+    /**
+     * Парсить git status код в FileStatus
+     */
+    private _parseGitStatus;
+    /**
+     * Парсить unified diff формат
+     */
+    private _parseUnifiedDiff;
+    /**
+     * Вычислить SHA256 хеш содержимого
+     */
+    private _hashContent;
+    /**
+     * Получить список всех tracked файлов в репозитории
+     * (полезно для initial analysis)
+     */
+    getAllTrackedFiles(): Promise<string[]>;
+    /**
+     * Получить информацию о последнем коммите
+     */
+    getLastCommitInfo(): Promise<CommitInfo | null>;
+    /**
+     * Проверить, есть ли uncommitted изменения
+     */
+    hasUncommittedChanges(): Promise<boolean>;
+}
+//# sourceMappingURL=GitPlugin.d.ts.map

package/dist/plugins/vcs/GitPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GitPlugin.d.ts","sourceRoot":"","sources":["../../../src/plugins/vcs/GitPlugin.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,SAAS,EAAc,MAAM,gBAAgB,CAAC;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,WAAW,EAAE,QAAQ,EAAY,MAAM,gBAAgB,CAAC;AAUpG;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,SAAU,SAAQ,SAAS;IACtC,OAAO,CAAC,MAAM,CAAS;gBAEX,MAAM,GAAE,SAAc;IAKlC,IAAI,QAAQ,IAAI,iBAAiB,CAMhC;IAED;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IAerC;;OAEG;IACG,eAAe,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IAsD/C;;OAEG;IACG,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAiBnE;;OAEG;IACG,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IAgBtD;;OAEG;IACG,gBAAgB,IAAI,OAAO,CAAC,MAAM,CAAC;IASzC;;OAEG;IACG,iBAAiB,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IASjD;;OAEG;IACG,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IASnD;;OAEG;IAEH;;OAEG;YACW,KAAK;IAOnB;;OAEG;IACH,OAAO,CAAC,eAAe;IAgCvB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAgDzB;;OAEG;IACH,OAAO,CAAC,YAAY;IAIpB;;;OAGG;IACG,kBAAkB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAU7C;;OAEG;IACG,iBAAiB,IAAI,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;IAiBrD;;OAEG;IACG,qBAAqB,IAAI,OAAO,CAAC,OAAO,CAAC;CAIhD"}

package/dist/plugins/vcs/GitPlugin.js

@@ -0,0 +1,295 @@
+/**
+ * Git VCS Plugin
+ *
+ * Плагин для работы с Git репозиториями
+ * Обнаруживает изменённые файлы и предоставляет их содержимое
+ */
+import { VCSPlugin, FileStatus } 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);
+export class GitPlugin extends VCSPlugin {
+    gitDir;
+    constructor(config = {}) {
+        super(config);
+        this.gitDir = join(this.rootPath, '.git');
+    }
+    get metadata() {
+        return {
+            name: 'git',
+            type: 'vcs',
+            supported: existsSync(this.gitDir)
+        };
+    }
+    /**
+     * Проверить доступность Git
+     */
+    async isAvailable() {
+        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() {
+        try {
+            // Получаем список файлов через git status --porcelain
+            const { stdout } = await this._exec('git status --porcelain');
+            if (!stdout.trim()) {
+                return []; // Нет изменений
+            }
+            const files = [];
+            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 = 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.message);
+            return [];
+        }
+    }
+    /**
+     * Получить содержимое файла из HEAD
+     */
+    async getCommittedContent(filePath) {
+        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) {
+        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.message);
+            return { path: filePath, hunks: [] };
+        }
+    }
+    /**
+     * Получить текущую ветку
+     */
+    async getCurrentBranch() {
+        try {
+            const { stdout } = await this._exec('git rev-parse --abbrev-ref HEAD');
+            return stdout.trim();
+        }
+        catch {
+            return 'unknown';
+        }
+    }
+    /**
+     * Получить хеш последнего коммита
+     */
+    async getLastCommitHash() {
+        try {
+            const { stdout } = await this._exec('git rev-parse HEAD');
+            return stdout.trim();
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Проверить, отслеживается ли файл
+     */
+    async isTracked(filePath) {
+        try {
+            await this._exec(`git ls-files --error-unmatch "${filePath}"`);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Вспомогательные методы
+     */
+    /**
+     * Выполнить git команду
+     */
+    async _exec(command) {
+        return await execAsync(command, {
+            cwd: this.rootPath,
+            maxBuffer: 10 * 1024 * 1024 // 10MB буфер для больших diff'ов
+        });
+    }
+    /**
+     * Парсить git status код в FileStatus
+     */
+    _parseGitStatus(statusCode) {
+        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 формат
+     */
+    _parseUnifiedDiff(filePath, diffText) {
+        const hunks = [];
+        const lines = diffText.split('\n');
+        let currentHunk = 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 хеш содержимого
+     */
+    _hashContent(content) {
+        return createHash('sha256').update(content, 'utf-8').digest('hex');
+    }
+    /**
+     * Получить список всех tracked файлов в репозитории
+     * (полезно для initial analysis)
+     */
+    async getAllTrackedFiles() {
+        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.message);
+            return [];
+        }
+    }
+    /**
+     * Получить информацию о последнем коммите
+     */
+    async getLastCommitInfo() {
+        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() {
+        const changedFiles = await this.getChangedFiles();
+        return changedFiles.length > 0;
+    }
+}