gen-testid 1.0.0

package/src/core/semantic-generator.ts

@@ -0,0 +1,164 @@
+//src/core/semantic-generator.ts
+import { ElementContext } from './types.js';
+import { execSync } from 'child_process';
+
+export interface SemanticGeneratorConfig {
+    model?: string;
+    ollamaUrl?: string;
+}
+
+export class SemanticGenerator {
+    private model: string;
+    private ollamaUrl: string;
+    private cache: Map<string, string> = new Map();
+    private idCounter: Map<string, number> = new Map();
+    private isAvailableCache: boolean | null = null;
+
+    constructor(config: SemanticGeneratorConfig = {}) {
+        this.model = config.model || 'llama3.2:3b';
+        this.ollamaUrl = config.ollamaUrl || 'http://localhost:11434';
+        this.checkAvailability();
+    }
+
+    private checkAvailability(): void {
+        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: ElementContext): string | null {
+        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;
+    }
+
+    private buildPrompt(context: ElementContext): string {
+        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:`;
+    }
+
+    private generateWithOllamaSync(prompt: string): string | null {
+        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;
+        }
+    }
+
+    private cleanId(id: string): string {
+        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/src/core/strategies.ts

@@ -0,0 +1,91 @@
+// src/core/strategies.ts
+import { NamingStrategy, ElementContext } from './types.js';
+import { createHash } from 'crypto';
+import { SemanticGenerator } from './semantic-generator.js';
+
+export class HierarchicalStrategy implements NamingStrategy {
+    constructor(private prefix: string = 'test') {}
+
+    generateId(context: ElementContext): string {
+        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 implements NamingStrategy {
+    private cache = new Map<string, string>();
+
+    constructor(private prefix: string = 'test') {}
+
+    generateId(context: ElementContext): string {
+        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 implements NamingStrategy {
+    private globalCounter = 0;
+
+    constructor(private prefix: string = 'test') {}
+
+    generateId(): string {
+        return `${this.prefix}-${++this.globalCounter}`;
+    }
+}
+
+export class SemanticStrategy implements NamingStrategy {
+    private generator: SemanticGenerator;
+    private fallbackStrategy: NamingStrategy;
+
+    constructor(prefix: string = 'test', model?: string, ollamaUrl?: string) {
+        console.log('🤖 Инициализация семантической стратегии...');
+        this.generator = new SemanticGenerator({
+            model: model || 'llama3.2:3b',
+            ollamaUrl: ollamaUrl || 'http://localhost:11434'
+        });
+        this.fallbackStrategy = new HierarchicalStrategy(prefix);
+    }
+
+    generateId(context: ElementContext): string {
+        // Пробуем получить семантический ID
+        const semanticId = this.generator.generateSemanticIdSync(context);
+
+        if (semanticId && semanticId.length > 0) {
+            return semanticId;
+        }
+
+        // Fallback
+        return this.fallbackStrategy.generateId(context);
+    }
+}

package/src/core/types.ts

@@ -0,0 +1,33 @@
+//src/core/types.ts
+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/src/index.ts

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

package/src/shared/element-counter.ts

@@ -0,0 +1,10 @@
+export class ElementCounter {
+    private counters = new Map<string, number>();
+
+    increment(key: string): number {
+        const current = this.counters.get(key) || 0;
+        const next = current + 1;
+        this.counters.set(key, next);
+        return next;
+    }
+}

package/src/shared/parser.ts

@@ -0,0 +1,174 @@
+// src/shared/parser.ts
+import { parse, compileTemplate } from '@vue/compiler-sfc';
+import { GenTestId } from '../core/GenTestId.js';
+
+export interface ParseResult {
+    modifiedContent: string;
+    injectedCount: number;
+    elements: Array<{
+        testId: string;
+        lineNumber: number;
+        elementType: string;
+    }>;
+}
+
+const NODE_TYPES = {
+    ELEMENT: 1,
+    ATTRIBUTE: 6,
+    DIRECTIVE: 7
+} as const;
+
+const IGNORED_TAGS = new Set([
+    'template', 'slot', 'component', 'keep-alive',
+    'transition', 'transition-group'
+]);
+
+/**
+ * Надёжно находит позицию для вставки атрибута в тег
+ */
+function findInsertPosition(tagSource: string, isSelfClosing: boolean): { offset: number; prefix: string } {
+    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: string,
+    filePath: string,
+    genTestId: GenTestId
+): Promise<ParseResult> {
+    const result: ParseResult = {
+        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: Array<{
+            offset: number;
+            insertText: string;
+            testId: string;
+            tag: string;
+            lineNumber: number;
+        }> = [];
+
+        function walk(node: any) {
+            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: any) => {
+                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 as any)?.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: any) {
+            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/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2020", "DOM"],
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true,
+    "jsx": "react-jsx",
+    "types": ["node"],
+    "allowJs": true,
+    "checkJs": false
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"],
+  "files": ["src/cli/index.ts"]
+}