gen-testid 1.0.0

package/dist/cli/index.js

@@ -0,0 +1,87 @@
+#!/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) {
+    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, dryRun) {
+    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/dist/cli/init.d.ts

@@ -0,0 +1 @@
+export declare function initCommand(): Promise<void>;

package/dist/cli/init.js

@@ -0,0 +1,95 @@
+// 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) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    return new Promise(resolve => {
+        rl.question(question, answer => {
+            rl.close();
+            resolve(answer);
+        });
+    });
+}

package/dist/core/GenTestId.d.ts

@@ -0,0 +1,12 @@
+import { GenTestIdConfig, ElementContext, InjectionResult } from './types.js';
+export declare class GenTestId {
+    config: Required<GenTestIdConfig>;
+    private strategy;
+    private counter;
+    constructor(config?: GenTestIdConfig);
+    private initStrategy;
+    generateTestId(context: Omit<ElementContext, 'occurrence'>): string;
+    processFile(filePath: string): Promise<InjectionResult>;
+    private shouldExcludeFile;
+    processAllFiles(): Promise<InjectionResult[]>;
+}

package/dist/core/GenTestId.js

@@ -0,0 +1,127 @@
+// src/core/GenTestId.ts
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import fg from 'fast-glob';
+import { HierarchicalStrategy, StableUuidStrategy, MinimalStrategy, SemanticStrategy } from './strategies.js';
+import { ElementCounter } from '../shared/element-counter.js';
+import { parseVueFile } from '../shared/parser.js';
+export class GenTestId {
+    constructor(config = {}) {
+        this.config = {
+            prefix: 'test',
+            strategy: 'hierarchical',
+            semanticModel: '',
+            ollamaUrl: 'http://localhost:11434',
+            excludeFiles: ['**/*.test.*', '**/*.spec.*', '**/node_modules/**', '**/dist/**'],
+            includeFiles: ['src/**/*.vue'],
+            ...config
+        };
+        this.counter = new ElementCounter();
+        this.strategy = this.initStrategy();
+    }
+    initStrategy() {
+        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);
+        }
+    }
+    generateTestId(context) {
+        const key = `${context.filePath}:${context.componentName}:${context.lineNumber || 'unknown'}`;
+        const occurrence = this.counter.increment(key);
+        const fullContext = {
+            ...context,
+            occurrence,
+            lineNumber: context.lineNumber || 0
+        };
+        return this.strategy.generateId(fullContext);
+    }
+    async processFile(filePath) {
+        try {
+            if (this.shouldExcludeFile(filePath)) {
+                return { filePath, injectedCount: 0, elements: [] };
+            }
+            let content = await fs.readFile(filePath, 'utf-8');
+            //Добавляем testid
+            let parseResult = {
+                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: [] };
+        }
+    }
+    shouldExcludeFile(filePath) {
+        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;
+    }
+    async processAllFiles() {
+        console.log('🔍 Поиск файлов...');
+        const files = [];
+        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 = [];
+        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;
+    }
+}

package/dist/core/semantic-generator.d.ts

@@ -0,0 +1,18 @@
+import { ElementContext } from './types.js';
+export interface SemanticGeneratorConfig {
+    model?: string;
+    ollamaUrl?: string;
+}
+export declare class SemanticGenerator {
+    private model;
+    private ollamaUrl;
+    private cache;
+    private idCounter;
+    private isAvailableCache;
+    constructor(config?: SemanticGeneratorConfig);
+    private checkAvailability;
+    generateSemanticIdSync(context: ElementContext): string | null;
+    private buildPrompt;
+    private generateWithOllamaSync;
+    private cleanId;
+}

package/dist/core/semantic-generator.js

@@ -0,0 +1,142 @@
+import { execSync } from 'child_process';
+export class SemanticGenerator {
+    constructor(config = {}) {
+        this.cache = new Map();
+        this.idCounter = new Map();
+        this.isAvailableCache = null;
+        this.model = config.model || 'llama3.2:3b';
+        this.ollamaUrl = config.ollamaUrl || 'http://localhost:11434';
+        this.checkAvailability();
+    }
+    checkAvailability() {
+        try {
+            const result = execSync(`curl -s -o /dev/null -w "%{http_code}" ${this.ollamaUrl}/api/tags`, {
+                encoding: 'utf-8',
+                timeout: 2000
+            });
+            this.isAvailableCache = result === '200';
+            if (this.isAvailableCache) {
+                console.log('✅ Ollama доступен');
+            }
+            else {
+                console.log('❌ Ollama не отвечает');
+            }
+        }
+        catch (error) {
+            this.isAvailableCache = false;
+            console.log('❌ Ollama не доступен');
+        }
+    }
+    generateSemanticIdSync(context) {
+        if (!this.isAvailableCache) {
+            return null;
+        }
+        const cacheKey = `${context.filePath}:${context.componentName}:${context.lineNumber}`;
+        if (this.cache.has(cacheKey)) {
+            return this.cache.get(cacheKey);
+        }
+        const prompt = this.buildPrompt(context);
+        try {
+            const semanticId = this.generateWithOllamaSync(prompt);
+            if (semanticId && semanticId.length > 0 && semanticId !== 'id') {
+                let cleanedId = this.cleanId(semanticId);
+                //Проверяем дубликаты внутри файла одного
+                const fileKey = context.filePath;
+                const duplicateKey = `${fileKey}:${cleanedId}`;
+                const count = this.idCounter.get(duplicateKey) || 0;
+                if (count > 0) {
+                    cleanedId = `${cleanedId}-${count + 1}`;
+                }
+                this.idCounter.set(duplicateKey, count + 1);
+                this.cache.set(cacheKey, cleanedId);
+                return cleanedId;
+            }
+        }
+        catch (error) {
+            //Ошибка - игнорируем
+        }
+        return null;
+    }
+    buildPrompt(context) {
+        const tagName = context.metadata?.elementType?.split(':')[1] || context.componentName;
+        const textContent = context.metadata?.textContent || '';
+        const placeholder = context.metadata?.attributes?.placeholder || '';
+        const inputType = context.metadata?.attributes?.type || '';
+        const labelText = context.metadata?.attributes?.label || '';
+        const isCustomComponent = context.metadata?.isCustomComponent || false;
+        let elementDescription = '';
+        if (isCustomComponent) {
+            // Для кастомных компонентов используем label или имя компонента
+            const componentName = tagName.replace(/Field$/, '').toLowerCase();
+            elementDescription = labelText ? `"${labelText}" ${componentName}` : `${componentName} component`;
+        }
+        else if (tagName === 'button') {
+            const buttonText = textContent || 'button';
+            elementDescription = `"${buttonText}" button`;
+        }
+        else if (tagName === 'input') {
+            if (inputType === 'email')
+                elementDescription = 'email input';
+            else if (inputType === 'password')
+                elementDescription = 'password input';
+            else if (inputType === 'checkbox')
+                elementDescription = 'checkbox';
+            else if (inputType === 'submit')
+                elementDescription = 'submit button';
+            else if (placeholder)
+                elementDescription = `"${placeholder}" input`;
+            else
+                elementDescription = 'input field';
+        }
+        else {
+            elementDescription = tagName;
+        }
+        return `Generate ONE short semantic test ID for: ${elementDescription}
+${textContent ? `Text: "${textContent}"` : ''}
+${placeholder ? `Placeholder: "${placeholder}"` : ''}
+${labelText ? `Label: "${labelText}"` : ''}
+
+Return ONLY the ID (lowercase, hyphens, max 25 chars).
+Examples: login-button, email-input, password-field, user-name-input, submit-form
+
+ID:`;
+    }
+    generateWithOllamaSync(prompt) {
+        try {
+            const escapedPrompt = JSON.stringify(prompt);
+            const command = `curl -s -X POST ${this.ollamaUrl}/api/generate \
+                -H "Content-Type: application/json" \
+                -d '{"model":"${this.model}","prompt":${escapedPrompt},"stream":false,"options":{"temperature":0.2,"max_tokens":25}}'`;
+            const result = execSync(command, {
+                encoding: 'utf-8',
+                timeout: 5000,
+                maxBuffer: 1024 * 1024
+            });
+            const data = JSON.parse(result);
+            let response = data.response?.trim() || null;
+            if (response) {
+                response = response.toLowerCase()
+                    .replace(/[^a-z0-9-]/g, '-')
+                    .replace(/-+/g, '-')
+                    .replace(/^-|-$/g, '');
+            }
+            return response;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    cleanId(id) {
+        if (!id)
+            return '';
+        let cleaned = id
+            .toLowerCase()
+            .replace(/[^a-z0-9-]/g, '-')
+            .replace(/-+/g, '-')
+            .replace(/^-|-$/g, '');
+        if (cleaned.length > 35) {
+            cleaned = cleaned.substring(0, 35);
+        }
+        return cleaned;
+    }
+}

package/dist/core/strategies.d.ts

@@ -0,0 +1,24 @@
+import { NamingStrategy, ElementContext } from './types.js';
+export declare class HierarchicalStrategy implements NamingStrategy {
+    private prefix;
+    constructor(prefix?: string);
+    generateId(context: ElementContext): string;
+}
+export declare class StableUuidStrategy implements NamingStrategy {
+    private prefix;
+    private cache;
+    constructor(prefix?: string);
+    generateId(context: ElementContext): string;
+}
+export declare class MinimalStrategy implements NamingStrategy {
+    private prefix;
+    private globalCounter;
+    constructor(prefix?: string);
+    generateId(): string;
+}
+export declare class SemanticStrategy implements NamingStrategy {
+    private generator;
+    private fallbackStrategy;
+    constructor(prefix?: string, model?: string, ollamaUrl?: string);
+    generateId(context: ElementContext): string;
+}

package/dist/core/strategies.js

@@ -0,0 +1,73 @@
+import { createHash } from 'crypto';
+import { SemanticGenerator } from './semantic-generator.js';
+export class HierarchicalStrategy {
+    constructor(prefix = 'test') {
+        this.prefix = prefix;
+    }
+    generateId(context) {
+        const { componentName, occurrence } = context;
+        const fileName = context.filePath
+            .split('/')
+            .pop()
+            ?.replace(/\.[^/.]+$/, '') || '';
+        const lineNumber = context.lineNumber || 0;
+        const tagType = context.metadata?.elementType?.split(':')[1] || componentName;
+        const parts = [
+            this.prefix,
+            fileName,
+            tagType,
+            `line-${lineNumber}`,
+            `elem-${occurrence}`
+        ].filter(Boolean);
+        return parts.join('__').toLowerCase();
+    }
+}
+export class StableUuidStrategy {
+    constructor(prefix = 'test') {
+        this.prefix = prefix;
+        this.cache = new Map();
+    }
+    generateId(context) {
+        const key = `${context.filePath}:${context.componentName}:${context.lineNumber}:${context.occurrence}`;
+        if (!this.cache.has(key)) {
+            const hash = createHash('md5').update(key).digest('hex');
+            const uuid = [
+                hash.substring(0, 8),
+                hash.substring(8, 12),
+                hash.substring(12, 16),
+                hash.substring(16, 20),
+                hash.substring(20, 32)
+            ].join('-');
+            this.cache.set(key, `${this.prefix}-${uuid}`);
+        }
+        return this.cache.get(key);
+    }
+}
+export class MinimalStrategy {
+    constructor(prefix = 'test') {
+        this.prefix = prefix;
+        this.globalCounter = 0;
+    }
+    generateId() {
+        return `${this.prefix}-${++this.globalCounter}`;
+    }
+}
+export class SemanticStrategy {
+    constructor(prefix = 'test', model, ollamaUrl) {
+        console.log('🤖 Инициализация семантической стратегии...');
+        this.generator = new SemanticGenerator({
+            model: model || 'llama3.2:3b',
+            ollamaUrl: ollamaUrl || 'http://localhost:11434'
+        });
+        this.fallbackStrategy = new HierarchicalStrategy(prefix);
+    }
+    generateId(context) {
+        // Пробуем получить семантический ID
+        const semanticId = this.generator.generateSemanticIdSync(context);
+        if (semanticId && semanticId.length > 0) {
+            return semanticId;
+        }
+        // Fallback
+        return this.fallbackStrategy.generateId(context);
+    }
+}

package/dist/core/types.d.ts

@@ -0,0 +1,28 @@
+export type Strategy = 'hierarchical' | 'stable-uuid' | 'minimal' | 'semantic';
+export interface GenTestIdConfig {
+    prefix?: string;
+    strategy?: Strategy;
+    semanticModel?: string;
+    ollamaUrl?: string;
+    excludeFiles?: string[];
+    includeFiles?: string[];
+}
+export interface ElementContext {
+    componentName: string;
+    filePath: string;
+    lineNumber?: number;
+    occurrence: number;
+    metadata?: Record<string, any>;
+}
+export interface NamingStrategy {
+    generateId(context: ElementContext): string;
+}
+export interface InjectionResult {
+    filePath: string;
+    injectedCount: number;
+    elements: Array<{
+        testId: string;
+        lineNumber: number;
+        elementType: string;
+    }>;
+}

package/dist/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { GenTestId } from './core/GenTestId.js';
+export type { GenTestIdConfig, ElementContext, InjectionResult } from './core/types.js';

package/dist/index.js

@@ -0,0 +1 @@
+export { GenTestId } from './core/GenTestId.js';

package/dist/shared/element-counter.d.ts

@@ -0,0 +1,4 @@
+export declare class ElementCounter {
+    private counters;
+    increment(key: string): number;
+}

package/dist/shared/element-counter.js

@@ -0,0 +1,11 @@
+export class ElementCounter {
+    constructor() {
+        this.counters = new Map();
+    }
+    increment(key) {
+        const current = this.counters.get(key) || 0;
+        const next = current + 1;
+        this.counters.set(key, next);
+        return next;
+    }
+}

package/dist/shared/parser.d.ts

@@ -0,0 +1,11 @@
+import { GenTestId } from '../core/GenTestId.js';
+export interface ParseResult {
+    modifiedContent: string;
+    injectedCount: number;
+    elements: Array<{
+        testId: string;
+        lineNumber: number;
+        elementType: string;
+    }>;
+}
+export declare function parseVueFile(content: string, filePath: string, genTestId: GenTestId): Promise<ParseResult>;