gen-testid 1.0.0

package/dist/shared/parser.js

@@ -0,0 +1,132 @@
+// src/shared/parser.ts
+import { parse, compileTemplate } from '@vue/compiler-sfc';
+const NODE_TYPES = {
+    ELEMENT: 1,
+    ATTRIBUTE: 6,
+    DIRECTIVE: 7
+};
+const IGNORED_TAGS = new Set([
+    'template', 'slot', 'component', 'keep-alive',
+    'transition', 'transition-group'
+]);
+/**
+ * Надёжно находит позицию для вставки атрибута в тег
+ */
+function findInsertPosition(tagSource, isSelfClosing) {
+    if (isSelfClosing) {
+        // Для <Comp ... /> — вставляем перед />
+        const closingIndex = tagSource.lastIndexOf('/>');
+        return { offset: closingIndex, prefix: '' };
+    }
+    else {
+        // Для <Comp ...> — вставляем сразу после имени тега
+        // Находим конец имени тега: <TagName[пробел|атрибут|>|\n]
+        const tagNameMatch = tagSource.match(/^<([a-zA-Z][a-zA-Z0-9-]*)/);
+        if (!tagNameMatch)
+            return { offset: 1, prefix: '' }; // fallback после <
+        const afterTagName = tagSource.slice(tagNameMatch[0].length);
+        // Если сразу после имени тега идёт > — вставляем перед ним
+        if (afterTagName.trimStart().startsWith('>')) {
+            const gtIndex = tagSource.indexOf('>', tagNameMatch[0].length);
+            return { offset: gtIndex, prefix: '' };
+        }
+        // Иначе вставляем после имени тега (до первого пробела/атрибута)
+        return { offset: tagNameMatch[0].length, prefix: ' ' };
+    }
+}
+export async function parseVueFile(content, filePath, genTestId) {
+    const result = {
+        modifiedContent: content,
+        injectedCount: 0,
+        elements: []
+    };
+    try {
+        const { descriptor, errors } = parse(content, { filename: filePath });
+        if (errors?.length > 0) {
+            console.warn(`⚠️ Ошибки парсинга SFC ${filePath}:`, errors.map(e => e.message || String(e)));
+            return result;
+        }
+        if (!descriptor.template) {
+            console.log(`   ⚪ Нет секции <template> в ${filePath}`);
+            return result;
+        }
+        const templateSource = descriptor.template.content;
+        const templateStartOffset = descriptor.template.loc.start.offset;
+        const { ast } = compileTemplate({
+            source: templateSource,
+            filename: filePath,
+            id: 'gen-testid-injector'
+        });
+        if (!ast?.children)
+            return result;
+        const injections = [];
+        function walk(node) {
+            if (node.type !== NODE_TYPES.ELEMENT)
+                return;
+            const tag = node.tag;
+            if (!tag || IGNORED_TAGS.has(tag.toLowerCase())) {
+                processChildren(node);
+                return;
+            }
+            const hasDataTestId = node.props?.some((prop) => {
+                if (prop.type === NODE_TYPES.ATTRIBUTE) {
+                    return prop.name === 'data-testid';
+                }
+                if (prop.type === NODE_TYPES.DIRECTIVE && prop.name === 'bind' && prop.arg) {
+                    return prop.arg?.content === 'data-testid';
+                }
+                return false;
+            });
+            if (!hasDataTestId) {
+                const startOffset = templateStartOffset + node.loc.start.offset;
+                const endOffset = templateStartOffset + node.loc.end.offset;
+                const lineNumber = content.slice(0, startOffset).split('\n').length;
+                const fullTagSource = content.slice(startOffset, endOffset);
+                const isSelfClosing = fullTagSource.trimEnd().endsWith('/>');
+                const testId = genTestId.generateTestId({
+                    componentName: tag,
+                    filePath,
+                    lineNumber,
+                    metadata: {
+                        elementType: `vue:${tag}`,
+                        textContent: tag,
+                        attributes: {}
+                    }
+                });
+                // 🔥 Надёжное определение позиции вставки
+                const { offset: relativeOffset, prefix } = findInsertPosition(fullTagSource, isSelfClosing);
+                const insertOffset = startOffset + relativeOffset;
+                const insertText = ` ${prefix}data-testid="${testId}"`;
+                injections.push({ offset: insertOffset, insertText, testId, tag, lineNumber });
+                result.elements.push({ testId, lineNumber, elementType: `vue:${tag}` });
+                result.injectedCount++;
+                console.log(`   ✅ ${tag} (строка ${lineNumber}): ${testId}`);
+            }
+            processChildren(node);
+        }
+        function processChildren(node) {
+            if (node.children && Array.isArray(node.children)) {
+                for (const child of node.children) {
+                    walk(child);
+                }
+            }
+        }
+        for (const child of ast.children) {
+            walk(child);
+        }
+        // Применяем инъекции от конца к началу
+        if (injections.length > 0) {
+            injections.sort((a, b) => b.offset - a.offset);
+            let modified = content;
+            for (const inj of injections) {
+                modified = modified.slice(0, inj.offset) + inj.insertText + modified.slice(inj.offset);
+            }
+            result.modifiedContent = modified;
+        }
+        console.log(`   📊 Всего добавлено testid: ${result.injectedCount}`);
+    }
+    catch (error) {
+        console.warn(`⚠️ Ошибка при парсинге Vue файла ${filePath}:`, error);
+    }
+    return result;
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "gen-testid",
+  "version": "1.0.0",
+  "description": "Автоматическая простановка data-testid в Vue проектах",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "gen-testid": "./bin/cli.js"
+  },
+  "dependencies": {
+    "@vue/compiler-sfc": "^3.5.32",
+    "commander": "^11.1.0",
+    "fast-glob": "^3.3.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.8.0",
+    "typescript": "^5.2.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  }
+}

package/src/cli/index.ts

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { GenTestId } from '../core/GenTestId.js';
+import { initCommand } from './init.js';
+import * as path from 'path';
+import * as fs from 'fs';
+
+const program = new Command();
+
+program
+    .name('gen-testid')
+    .description('Автоматическая простановка data-testid в Vue проектах')
+    .version('1.0.1');
+
+program
+    .command('init')
+    .description('Инициализация конфигурации')
+    .action(initCommand);
+
+program
+    .command('inject [files...]')
+    .description('Проставить testid в указанные файлы')
+    .option('-c, --config <path>', 'путь к конфигурации')
+    .option('-s, --strategy <name>', 'стратегия именования')
+    .option('-p, --prefix <prefix>', 'префикс для testid')
+    .option('-d, --dry-run', 'пробный запуск без изменений')
+    .action(async (files, options) => {
+        console.log('🔍 Инжекция testid...\n');
+
+        try {
+            const config = loadConfig(options.config);
+
+            const genTestId = new GenTestId({
+                ...config,
+                strategy: options.strategy || config.strategy,
+                prefix: options.prefix || config.prefix
+            });
+
+            if (files.length === 0) {
+                console.log('📁 Сканирование всех Vue файлов...');
+                const results = await genTestId.processAllFiles();
+                printResults(results, options.dryRun);
+            } else {
+                console.log(`📁 Обработка ${files.length} файлов...`);
+                const results = [];
+                for (const file of files) {
+                    const fullPath = path.resolve(process.cwd(), file);
+                    const result = await genTestId.processFile(fullPath);
+                    results.push(result);
+                }
+                printResults(results, options.dryRun);
+            }
+
+        } catch (error) {
+            console.error('\n❌ Ошибка:', error);
+            process.exit(1);
+        }
+    });
+
+program.parse(process.argv);
+
+function loadConfig(configPath?: string): any {
+    if (configPath) {
+        const fullPath = path.resolve(process.cwd(), configPath);
+        if (fs.existsSync(fullPath)) {
+            return JSON.parse(fs.readFileSync(fullPath, 'utf-8'));
+        }
+    }
+
+    const rcPath = path.resolve(process.cwd(), '.gentestidrc');
+    if (fs.existsSync(rcPath)) {
+        return JSON.parse(fs.readFileSync(rcPath, 'utf-8'));
+    }
+
+    return {};
+}
+
+function printResults(results: any[], dryRun?: boolean) {
+    const total = results.reduce((sum, r) => sum + r.injectedCount, 0);
+    const filesWithChanges = results.filter(r => r.injectedCount > 0).length;
+
+    console.log(`\n${dryRun ? '📋' : '✅'} Результаты:`);
+    console.log(`   Всего файлов: ${results.length}`);
+    console.log(`   Файлов с изменениями: ${filesWithChanges}`);
+    console.log(`   ${dryRun ? 'Будет добавлено' : 'Добавлено'} testid: ${total}`);
+
+    if (total > 0) {
+        console.log('\n📝 Детали:');
+        results
+            .filter(r => r.injectedCount > 0)
+            .slice(0, 5)
+            .forEach(r => {
+                const relativePath = path.relative(process.cwd(), r.filePath);
+                console.log(`   📁 ${relativePath}: +${r.injectedCount} testid`);
+            });
+
+        if (results.filter(r => r.injectedCount > 0).length > 5) {
+            console.log(`   ... и ещё ${results.filter(r => r.injectedCount > 0).length - 5} файлов`);
+        }
+    }
+}

package/src/cli/init.ts

@@ -0,0 +1,114 @@
+// src/cli/init.ts
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as readline from 'readline';
+
+export async function initCommand() {
+    console.log('🚀 Инициализация gen-testid для Vue...\n');
+
+    try {
+        console.log('📋 Доступные стратегии:');
+        console.log('   1. hierarchical (default) - иерархические ID (test__Component__elem-1)');
+        console.log('   2. stable-uuid - стабильные UUID');
+        console.log('   3. minimal - простые номера');
+        console.log('   4. semantic - умные ID через Ollama (бесплатно, локально)\n');
+
+        const strategyChoice = await askQuestion('Выберите стратегию (1-4) [1]: ');
+
+        let strategy = 'hierarchical';
+        let semanticModel = '';
+        let ollamaUrl = '';
+
+        switch (strategyChoice) {
+            case '2':
+                strategy = 'stable-uuid';
+                break;
+            case '3':
+                strategy = 'minimal';
+                break;
+            case '4':
+                strategy = 'semantic';
+                console.log('\n🤖 Настройка семантической генерации через Ollama:');
+                console.log('   Требуется Ollama');
+                console.log('   Установка: brew install ollama && ollama pull llama3.2:3b');
+                console.log('   Запуск: ollama serve\n');
+
+                const model = await askQuestion('Модель (llama3.2:3b/mistral/gemma:2b) [llama3.2:3b]: ');
+                semanticModel = model || 'llama3.2:3b';
+
+                const url = await askQuestion('URL Ollama [http://localhost:11434]: ');
+                ollamaUrl = url || 'http://localhost:11434';
+
+                console.log('\n💡 Совет: Запустите "ollama serve" в отдельном терминале');
+                break;
+            default:
+                strategy = 'hierarchical';
+        }
+
+        const prefix = await askQuestion('Префикс для testid [default: test]: ');
+
+        const config = {
+            strategy,
+            prefix: prefix || 'test',
+            semanticModel: semanticModel,
+            ollamaUrl: ollamaUrl,
+            includeFiles: ['src/**/*.vue'],
+            excludeFiles: ['**/*.test.*', '**/node_modules/**', '**/dist/**']
+        };
+
+        const configPath = path.join(process.cwd(), '.gentestidrc');
+        await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+        console.log(`\n✅ Конфигурация сохранена в ${configPath}`);
+
+        if (strategy === 'semantic') {
+            console.log('\n🤖 Семантическая генерация активирована!');
+            console.log('   При первом запуске ID будут иерархическими,');
+            console.log('   а Ollama в фоне будет генерировать умные ID.');
+        }
+
+        await updatePackageJson();
+
+        console.log('\n📝 Следующие шаги:');
+        console.log('  1. Запустите Ollama: ollama serve');
+        console.log('  2. Запустите "npx gen-testid inject" для простановки testid');
+        console.log('  3. Готово! 🎉\n');
+
+    } catch (error) {
+        console.error('❌ Ошибка при инициализации:', error);
+        process.exit(1);
+    }
+}
+
+async function updatePackageJson() {
+    try {
+        const pkgPath = path.join(process.cwd(), 'package.json');
+        const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf-8'));
+
+        if (!pkg.scripts) {
+            pkg.scripts = {};
+        }
+
+        if (!pkg.scripts['testids']) {
+            pkg.scripts['testids'] = 'gen-testid inject';
+        }
+
+        await fs.writeFile(pkgPath, JSON.stringify(pkg, null, 2));
+        console.log('✅ Скрипты добавлены в package.json');
+    } catch (error) {
+        console.log('⚠️  Не удалось обновить package.json');
+    }
+}
+
+function askQuestion(question: string): Promise<string> {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+
+    return new Promise(resolve => {
+        rl.question(question, answer => {
+            rl.close();
+            resolve(answer);
+        });
+    });
+}

package/src/core/GenTestId.ts

@@ -0,0 +1,169 @@
+// src/core/GenTestId.ts
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import fg from 'fast-glob';
+import {
+    GenTestIdConfig,
+    ElementContext,
+    NamingStrategy,
+    InjectionResult
+} from './types.js';
+import {
+    HierarchicalStrategy,
+    StableUuidStrategy,
+    MinimalStrategy,
+    SemanticStrategy
+} from './strategies.js';
+import { ElementCounter } from '../shared/element-counter.js';
+import { parseVueFile } from '../shared/parser.js';
+
+export class GenTestId {
+    public config: Required<GenTestIdConfig>;
+    private strategy: NamingStrategy;
+    private counter: ElementCounter;
+
+    constructor(config: GenTestIdConfig = {}) {
+        this.config = {
+            prefix: 'test',
+            strategy: 'hierarchical',
+            semanticModel: '',
+            ollamaUrl: 'http://localhost:11434',
+            excludeFiles: ['**/*.test.*', '**/*.spec.*', '**/node_modules/**', '**/dist/**'],
+            includeFiles: ['src/**/*.vue'],
+            ...config
+        } as Required<GenTestIdConfig>;
+
+        this.counter = new ElementCounter();
+        this.strategy = this.initStrategy();
+    }
+
+    private initStrategy(): NamingStrategy {
+        switch (this.config.strategy) {
+            case 'hierarchical':
+                return new HierarchicalStrategy(this.config.prefix);
+            case 'stable-uuid':
+                return new StableUuidStrategy(this.config.prefix);
+            case 'minimal':
+                return new MinimalStrategy(this.config.prefix);
+            case 'semantic':
+                return new SemanticStrategy(
+                    this.config.prefix,
+                    this.config.semanticModel,
+                    this.config.ollamaUrl
+                );
+            default:
+                return new HierarchicalStrategy(this.config.prefix);
+        }
+    }
+
+    public generateTestId(context: Omit<ElementContext, 'occurrence'>): string {
+        const key = `${context.filePath}:${context.componentName}:${context.lineNumber || 'unknown'}`;
+        const occurrence = this.counter.increment(key);
+
+        const fullContext: ElementContext = {
+            ...context,
+            occurrence,
+            lineNumber: context.lineNumber || 0
+        };
+
+        return this.strategy.generateId(fullContext);
+    }
+
+    public async processFile(filePath: string): Promise<InjectionResult> {
+        try {
+            if (this.shouldExcludeFile(filePath)) {
+                return { filePath, injectedCount: 0, elements: [] };
+            }
+
+            let content = await fs.readFile(filePath, 'utf-8');
+
+            //Добавляем testid
+            let parseResult: { injectedCount: number; modifiedContent: string; elements: any[] } = {
+                injectedCount: 0,
+                modifiedContent: content,
+                elements: []
+            };
+
+            if (filePath.endsWith('.vue')) {
+                parseResult = await parseVueFile(content, filePath, this);
+                if (parseResult.injectedCount > 0) {
+                    content = parseResult.modifiedContent;
+                }
+            }
+
+            //Save
+            if (parseResult.injectedCount > 0) {
+                await fs.writeFile(filePath, content, 'utf-8');
+            }
+
+            return {
+                filePath,
+                injectedCount: parseResult.injectedCount,
+                elements: parseResult.elements
+            };
+
+        } catch (error) {
+            console.error(`❌ Error processing ${filePath}:`, error);
+            return { filePath, injectedCount: 0, elements: [] };
+        }
+    }
+
+    private shouldExcludeFile(filePath: string): boolean {
+        const relativePath = path.relative(process.cwd(), filePath);
+
+        for (const pattern of this.config.excludeFiles) {
+            if (pattern.includes('*')) {
+                const regex = new RegExp(pattern.replace(/\*/g, '.*'));
+                if (regex.test(relativePath)) {
+                    return true;
+                }
+            } else if (relativePath.includes(pattern)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public async processAllFiles(): Promise<InjectionResult[]> {
+        console.log('🔍 Поиск файлов...');
+
+        const files: string[] = [];
+
+        for (const pattern of this.config.includeFiles) {
+            try {
+                const matches = await fg(pattern, {
+                    ignore: this.config.excludeFiles,
+                    absolute: true,
+                    onlyFiles: true
+                });
+                files.push(...matches);
+            } catch (error) {
+                console.warn(`⚠️ Ошибка при поиске по паттерну ${pattern}:`, error);
+            }
+        }
+
+        console.log(`📁 Найдено файлов: ${files.length}\n`);
+
+        const results: InjectionResult[] = [];
+        let totalTestIds = 0;
+
+        for (const file of files) {
+            console.log(`📄 Обработка: ${path.basename(file)}`);
+            const result = await this.processFile(file);
+            results.push(result);
+
+            totalTestIds += result.injectedCount;
+
+            if (result.injectedCount > 0) {
+                console.log(`   ✅ Добавлено testid: ${result.injectedCount}\n`);
+            }
+        }
+
+        if (totalTestIds > 0) {
+            console.log(`\n🏷️  Всего добавлено testid: ${totalTestIds}`);
+        }
+
+        return results;
+    }
+}