nexushub-commands 2.0.2 → 2.0.4

package/lib/shared-commands/ParserSharedCommands.service.d.ts

@@ -11,6 +11,24 @@ export declare class ParserSharedCommandsService {
      * @returns преобразованный код команды
      */
     static transformCommand(commandContent: string): string;
+    /**
+     * Проверяет, является ли импорт локальным (относительным путем)
+     * @param importPath - путь импорта
+     * @returns true, если импорт локальный
+     */
+    private static isLocalImport;
+    /**
+     * Удаляет только локальные импорты, сохраняя нелокальные
+     * @param content - исходный код
+     * @returns код с удаленными локальными импортами
+     */
+    private static removeLocalImports;
+    /**
+     * Удаляет все оставшиеся приватные методы с умным поиском
+     * @param content - код для очистки
+     * @returns код с удаленными приватными методами
+     */
+    private static removeRemainingPrivateMethods;
     /**
      * Создает API вызов для метода
      * @param methodName - название метода

package/lib/shared-commands/ParserSharedCommands.service.js

@@ -25,8 +25,8 @@ class ParserSharedCommandsService {
      * @returns преобразованный код команды
      */
     static transformCommand(commandContent) {
-        // Убираем все импорты
-        let transformedContent = commandContent.replace(/import\s+.*?from\s+['"][^'"]*['"];?\n?/g, '');
+        // Убираем только локальные импорты (относительные пути), сохраняем нелокальные (npm пакеты)
+        let transformedContent = this.removeLocalImports(commandContent);
         // Заменяем extends на SharedCommand
         transformedContent = transformedContent.replace(/extends\s+\w+/g, 'extends SharedCommand');
         // Находим все приватные методы (включая статические)
@@ -40,13 +40,7 @@ class ParserSharedCommandsService {
         const className = this.parseClassName(commandContent);
         // Заменяем вызовы приватных методов на API вызовы
         privateMethods.forEach((methodName) => {
-            // Паттерн для поиска вызовов this.methodName(...) и ClassName.methodName(...)
-            const thisMethodCallRegex = new RegExp(`this\\.${methodName}\\s*\\(([^)]*)\\)`, 'g');
             const staticMethodCallRegex = new RegExp(`${className}\\.${methodName}\\s*\\(([^)]*)\\)`, 'g');
-            // Заменяем вызовы this.methodName(...)
-            transformedContent = transformedContent.replace(thisMethodCallRegex, (match, args) => {
-                return this.createApiCall(methodName, args);
-            });
             // Заменяем вызовы ClassName.methodName(...)
             if (className) {
                 transformedContent = transformedContent.replace(staticMethodCallRegex, (match, args) => {
@@ -54,17 +48,94 @@ class ParserSharedCommandsService {
                 });
             }
         });
-        // Удаляем все приватные методы по одному
+        // Удаляем все приватные методы по одному - разбиваем на линии и ищем границы
         privateMethods.forEach((methodName) => {
-            const methodRegex = new RegExp(`private\\s+(?:static\\s+)?(?:async\\s+)?${methodName}\\s*\\([^)]*\\)\\s*\\{[\\s\\S]*?\\n\\s*\\}\\n?`, 'g');
-            transformedContent = transformedContent.replace(methodRegex, '');
+            const lines = transformedContent.split('\n');
+            let methodStartIndex = -1;
+            let methodEndIndex = -1;
+            // Ищем начало метода
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                if (line.includes(`private`) && line.includes(`${methodName}(`) && line.includes('{')) {
+                    methodStartIndex = i;
+                    break;
+                }
+            }
+            // Если нашли начало, ищем конец (строку с \t})
+            if (methodStartIndex !== -1) {
+                for (let i = methodStartIndex + 1; i < lines.length; i++) {
+                    const line = lines[i];
+                    if (line.trim() === '}') {
+                        methodEndIndex = i;
+                        break;
+                    }
+                }
+                // Если нашли конец, удаляем метод
+                if (methodEndIndex !== -1) {
+                    lines.splice(methodStartIndex, methodEndIndex - methodStartIndex + 1);
+                    transformedContent = lines.join('\n');
+                }
+            }
         });
-        // Убираем лишние скобки и пустые строки
-        transformedContent = transformedContent.replace(/\n\s*\}\s*\n\s*\}/g, '\n}');
-        // Убираем лишние пустые строки
-        transformedContent = transformedContent.replace(/\n\s*\n\s*\n/g, '\n\n');
+        // Дополнительная очистка - убираем все оставшиеся приватные методы с умным поиском
+        transformedContent = this.removeRemainingPrivateMethods(transformedContent);
         return transformedContent;
     }
+    /**
+     * Проверяет, является ли импорт локальным (относительным путем)
+     * @param importPath - путь импорта
+     * @returns true, если импорт локальный
+     */
+    static isLocalImport(importPath) {
+        return importPath.startsWith('./') || importPath.startsWith('../') || importPath.startsWith('/');
+    }
+    /**
+     * Удаляет только локальные импорты, сохраняя нелокальные
+     * @param content - исходный код
+     * @returns код с удаленными локальными импортами
+     */
+    static removeLocalImports(content) {
+        // Убираем импорты с относительными путями: './file', '../folder/file'
+        let result = content.replace(/import\s+.*?from\s+['"]\.\.?\/[^'"]*['"];?\n?/g, '');
+        // Убираем импорты с абсолютными путями к локальным файлам: '/path/to/file'
+        result = result.replace(/import\s+.*?from\s+['"]\/[^'"]*['"];?\n?/g, '');
+        return result;
+    }
+    /**
+     * Удаляет все оставшиеся приватные методы с умным поиском
+     * @param content - код для очистки
+     * @returns код с удаленными приватными методами
+     */
+    static removeRemainingPrivateMethods(content) {
+        let result = content;
+        const privateMethodRegex = /private\s+(?:static\s+)?(?:async\s+)?\w+\s*\([^)]*\)\s*\{/g;
+        let match;
+        while ((match = privateMethodRegex.exec(result)) !== null) {
+            const startIndex = match.index;
+            const startBraceIndex = result.indexOf('{', startIndex);
+            if (startBraceIndex !== -1) {
+                // Находим конец метода, подсчитывая скобки
+                let braceCount = 1;
+                let endIndex = startBraceIndex + 1;
+                while (braceCount > 0 && endIndex < result.length) {
+                    const char = result[endIndex];
+                    if (char === '{')
+                        braceCount++;
+                    else if (char === '}')
+                        braceCount--;
+                    endIndex++;
+                }
+                if (braceCount === 0) {
+                    // Удаляем весь метод от начала до конца
+                    const methodEndIndex = endIndex;
+                    result = result.substring(0, startIndex) + result.substring(methodEndIndex);
+                    // Сбрасываем регулярное выражение, так как индексы изменились
+                    privateMethodRegex.lastIndex = 0;
+                }
+            }
+        }
+        return result;
+    }
     /**
      * Создает API вызов для метода
      * @param methodName - название метода
@@ -183,3 +254,4 @@ class ParserSharedCommandsService {
     }
 }
 exports.ParserSharedCommandsService = ParserSharedCommandsService;
+fs.writeFileSync('test.ts', ParserSharedCommandsService.transformCommand(fs.readFileSync('../escort/src/commands/shared/models/CreateModel.srdcmd.ts', 'utf-8')));

package/lib/test-imports.d.ts

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

package/lib/test-imports.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ParserSharedCommands_service_1 = require("./src/shared-commands/ParserSharedCommands.service");
+// Тестовый код с разными типами импортов
+const testCode = `
+import * as fs from 'fs'
+import * as path from 'path'
+import { Injectable } from '@nestjs/common'
+import { Command } from './Command'
+import { BaseService } from '../services/BaseService'
+import { Utils } from '/src/utils/Utils'
+import { Config } from './config/Config'
+
+class TestCommand extends Command {
+    private async processData() {
+        return fs.readFileSync('test.txt', 'utf-8')
+    }
+    
+    private static validateInput(input: string) {
+        return path.isAbsolute(input)
+    }
+}
+`;
+console.log('Исходный код:');
+console.log(testCode);
+console.log('\n' + '='.repeat(50) + '\n');
+console.log('Преобразованный код:');
+const transformed = ParserSharedCommands_service_1.ParserSharedCommandsService.transformCommand(testCode);
+console.log(transformed);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "nexushub-commands",
-	"version": "2.0.2",
+	"version": "2.0.4",
 	"main": "./lib/index.js",
 	"license": "MIT",
 	"dependencies": {

package/src/shared-commands/ParserSharedCommands.service.ts

@@ -22,8 +22,8 @@ export class ParserSharedCommandsService {
 	 * @returns преобразованный код команды
 	 */
 	static transformCommand(commandContent: string): string {
-		// Убираем все импорты
-		let transformedContent = commandContent.replace(/import\s+.*?from\s+['"][^'"]*['"];?\n?/g, '')
+		// Убираем только локальные импорты (относительные пути), сохраняем нелокальные (npm пакеты)
+		let transformedContent = this.removeLocalImports(commandContent)
 
 		// Заменяем extends на SharedCommand
 		transformedContent = transformedContent.replace(/extends\s+\w+/g, 'extends SharedCommand')
@@ -42,38 +42,119 @@ export class ParserSharedCommandsService {
 
 		// Заменяем вызовы приватных методов на API вызовы
 		privateMethods.forEach((methodName) => {
-			// Паттерн для поиска вызовов this.methodName(...) и ClassName.methodName(...)
-			const thisMethodCallRegex = new RegExp(`this\\.${methodName}\\s*\\(([^)]*)\\)`, 'g')
 			const staticMethodCallRegex = new RegExp(`${className}\\.${methodName}\\s*\\(([^)]*)\\)`, 'g')
 
-			// Заменяем вызовы this.methodName(...)
-			transformedContent = transformedContent.replace(thisMethodCallRegex, (match, args) => {
-				return this.createApiCall(methodName, args)
-			})
-
 			// Заменяем вызовы ClassName.methodName(...)
 			if (className) {
-				transformedContent = transformedContent.replace(staticMethodCallRegex, (match, args) => {
+				transformedContent = transformedContent.replace(staticMethodCallRegex, (match: string, args: string) => {
 					return this.createApiCall(methodName, args)
 				})
 			}
 		})
 
-		// Удаляем все приватные методы по одному
+		// Удаляем все приватные методы по одному - разбиваем на линии и ищем границы
 		privateMethods.forEach((methodName) => {
-			const methodRegex = new RegExp(`private\\s+(?:static\\s+)?(?:async\\s+)?${methodName}\\s*\\([^)]*\\)\\s*\\{[\\s\\S]*?\\n\\s*\\}\\n?`, 'g')
-			transformedContent = transformedContent.replace(methodRegex, '')
-		})
+			const lines = transformedContent.split('\n')
+			let methodStartIndex = -1
+			let methodEndIndex = -1
 
-		// Убираем лишние скобки и пустые строки
-		transformedContent = transformedContent.replace(/\n\s*\}\s*\n\s*\}/g, '\n}')
+			// Ищем начало метода
+			for (let i = 0; i < lines.length; i++) {
+				const line = lines[i]
+				if (line.includes(`private`) && line.includes(`${methodName}(`) && line.includes('{')) {
+					methodStartIndex = i
+					break
+				}
+			}
 
-		// Убираем лишние пустые строки
-		transformedContent = transformedContent.replace(/\n\s*\n\s*\n/g, '\n\n')
+			// Если нашли начало, ищем конец (строку с \t})
+			if (methodStartIndex !== -1) {
+				for (let i = methodStartIndex + 1; i < lines.length; i++) {
+					const line = lines[i]
+					if (line.trim() === '}') {
+						methodEndIndex = i
+						break
+					}
+				}
+
+				// Если нашли конец, удаляем метод
+				if (methodEndIndex !== -1) {
+					lines.splice(methodStartIndex, methodEndIndex - methodStartIndex + 1)
+					transformedContent = lines.join('\n')
+				}
+			}
+		})
+
+		// Дополнительная очистка - убираем все оставшиеся приватные методы с умным поиском
+		transformedContent = this.removeRemainingPrivateMethods(transformedContent)
 
 		return transformedContent
 	}
 
+	/**
+	 * Проверяет, является ли импорт локальным (относительным путем)
+	 * @param importPath - путь импорта
+	 * @returns true, если импорт локальный
+	 */
+	private static isLocalImport(importPath: string) {
+		return importPath.startsWith('./') || importPath.startsWith('../') || importPath.startsWith('/')
+	}
+
+	/**
+	 * Удаляет только локальные импорты, сохраняя нелокальные
+	 * @param content - исходный код
+	 * @returns код с удаленными локальными импортами
+	 */
+	private static removeLocalImports(content: string): string {
+		// Убираем импорты с относительными путями: './file', '../folder/file'
+		let result = content.replace(/import\s+.*?from\s+['"]\.\.?\/[^'"]*['"];?\n?/g, '')
+
+		// Убираем импорты с абсолютными путями к локальным файлам: '/path/to/file'
+		result = result.replace(/import\s+.*?from\s+['"]\/[^'"]*['"];?\n?/g, '')
+
+		return result
+	}
+
+	/**
+	 * Удаляет все оставшиеся приватные методы с умным поиском
+	 * @param content - код для очистки
+	 * @returns код с удаленными приватными методами
+	 */
+	private static removeRemainingPrivateMethods(content: string): string {
+		let result = content
+		const privateMethodRegex = /private\s+(?:static\s+)?(?:async\s+)?\w+\s*\([^)]*\)\s*\{/g
+		let match
+
+		while ((match = privateMethodRegex.exec(result)) !== null) {
+			const startIndex = match.index
+			const startBraceIndex = result.indexOf('{', startIndex)
+
+			if (startBraceIndex !== -1) {
+				// Находим конец метода, подсчитывая скобки
+				let braceCount = 1
+				let endIndex = startBraceIndex + 1
+
+				while (braceCount > 0 && endIndex < result.length) {
+					const char = result[endIndex]
+					if (char === '{') braceCount++
+					else if (char === '}') braceCount--
+					endIndex++
+				}
+
+				if (braceCount === 0) {
+					// Удаляем весь метод от начала до конца
+					const methodEndIndex = endIndex
+					result = result.substring(0, startIndex) + result.substring(methodEndIndex)
+
+					// Сбрасываем регулярное выражение, так как индексы изменились
+					privateMethodRegex.lastIndex = 0
+				}
+			}
+		}
+
+		return result
+	}
+
 	/**
 	 * Создает API вызов для метода
 	 * @param methodName - название метода
@@ -198,3 +279,5 @@ export class ParserSharedCommandsService {
 		return results
 	}
 }
+
+fs.writeFileSync('test.ts', ParserSharedCommandsService.transformCommand(fs.readFileSync('../escort/src/commands/shared/models/CreateModel.srdcmd.ts', 'utf-8')))

package/test-imports.d.ts

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

package/test.d.ts

@@ -0,0 +1,5 @@
+import { InlineQueryContext } from 'evogram/lib/migrated';
+export declare class EscortCreateModelCommand extends SharedCommand {
+    execute(context: CommandContext, name: string, age: number, about: string, services: string[], rating: number, specifications: string[], _: true): Promise<any>;
+    inlineExecute(context: InlineQueryContext, ...args: any): Promise<void>;
+}