@boristype/bt-cli 0.1.0-alpha.0

package/build/core/building/compile-mode.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * Определение режима транспиляции для файла
+ *
+ * @module build/compile-mode
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCompileMode = resolveCompileMode;
+exports.collectExecutables = collectExecutables;
+exports.computeFileKey = computeFileKey;
+exports.computeCurrentFileJs = computeCurrentFileJs;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const EXECUTABLE_OBJECTS = new Set([
+    "remoteAction",
+    "remoteCollection",
+    "systemEventHandler",
+    "serverAgent",
+    "codeLibrary",
+    "statisticRec",
+]);
+const BT_MODE_DIRECTIVE = /\/\/\/\s*@bt-mode\s+(bare|script|module)/;
+/**
+ * Проверяет, содержит ли файл импорты executable objects из @boristype/types
+ */
+function hasExecutableObjectImports(sourceFile) {
+    let found = false;
+    function check(node) {
+        if (typescript_1.default.isImportDeclaration(node)) {
+            const spec = node.moduleSpecifier;
+            if (typescript_1.default.isStringLiteral(spec) && spec.text.startsWith("@boristype/types")) {
+                const bindings = node.importClause?.namedBindings;
+                if (bindings && typescript_1.default.isNamedImports(bindings)) {
+                    for (const el of bindings.elements) {
+                        if (EXECUTABLE_OBJECTS.has(el.name.text)) {
+                            found = true;
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+        typescript_1.default.forEachChild(node, check);
+    }
+    typescript_1.default.forEachChild(sourceFile, check);
+    return found;
+}
+/**
+ * Ищет директиву /// @bt-mode в начале файла
+ */
+function getDirectiveMode(sourceFile) {
+    const text = sourceFile.getFullText();
+    const firstLines = text.split("\n").slice(0, 30).join("\n");
+    const match = firstLines.match(BT_MODE_DIRECTIVE);
+    return match ? match[1] : null;
+}
+/**
+ * Вычисляет compileMode из usePolyfill/useRemodule (обратная совместимость)
+ */
+function getCompileModeFromOptions(options) {
+    if (options.compileMode) {
+        return options.compileMode;
+    }
+    if (options.usePolyfill === false && options.useRemodule === false) {
+        return "bare";
+    }
+    return "module";
+}
+/**
+ * Определяет режим транспиляции для конкретного файла
+ *
+ * Приоритет: директива > .test.ts/executable → script > options.compileMode
+ */
+function resolveCompileMode(sourceFile, options, executablePaths) {
+    const directive = getDirectiveMode(sourceFile);
+    if (directive) {
+        return directive;
+    }
+    if (sourceFile.fileName.endsWith(".test.ts")) {
+        return "script";
+    }
+    if (executablePaths?.has(sourceFile.fileName) ?? hasExecutableObjectImports(sourceFile)) {
+        return "script";
+    }
+    return getCompileModeFromOptions(options);
+}
+/**
+ * Собирает список executable objects из исходных файлов
+ */
+function collectExecutables(program, sourceFiles) {
+    const paths = new Set();
+    const executables = [];
+    const packageJson = getPackageJson(program);
+    if (!packageJson) {
+        return { executables, paths };
+    }
+    for (const sf of sourceFiles) {
+        if (hasExecutableObjectImports(sf)) {
+            paths.add(sf.fileName);
+            executables.push({
+                packageName: packageJson.name,
+                packageVersion: packageJson.version,
+                filePath: sf.fileName,
+            });
+        }
+    }
+    return { executables, paths };
+}
+function getPackageJson(program) {
+    let root = program.getCurrentDirectory();
+    while (root !== node_path_1.default.dirname(root)) {
+        const p = node_path_1.default.join(root, "package.json");
+        if (node_fs_1.default.existsSync(p)) {
+            const j = JSON.parse(node_fs_1.default.readFileSync(p, "utf-8"));
+            return {
+                name: j.name ?? "unknown",
+                version: j.version ?? "0.0.0",
+                root,
+            };
+        }
+        root = node_path_1.default.dirname(root);
+    }
+    return null;
+}
+/**
+ * Вычисляет fileKey для script mode: packageName+version+relativePath
+ * Используется для import.meta и bt.getFileUrl
+ */
+function computeFileKey(sourceFile, program) {
+    const pkg = getPackageJson(program);
+    if (!pkg)
+        return undefined;
+    const rel = node_path_1.default.relative(pkg.root, sourceFile.fileName).replace(/\\/g, "/");
+    return `${pkg.name}+${pkg.version}+${rel}`;
+}
+/**
+ * Вычисляет имя текущего .js файла для module mode (только basename).
+ * AbsoluteUrl уже знает директорию, нужен только filename.
+ */
+function computeCurrentFileJs(sourceFile) {
+    return node_path_1.default.basename(sourceFile.fileName).replace(/\.tsx?$/, ".js");
+}

package/build/core/building/compiler.js

@@ -0,0 +1,281 @@
+"use strict";
+/**
+ * TypeScript компилятор
+ *
+ * Отвечает за:
+ * - Создание TypeScript program (noEmit для диагностики)
+ * - Emit через bt-ir (compileSourceFile)
+ * - Пост-обработку через transformOutput
+ *
+ * @module build/compiler
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compile = compile;
+exports.createWatchProgram = createWatchProgram;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const bt_ir_1 = require("@boristype/bt-ir");
+const logger_js_1 = require("../logger.js");
+const output_js_1 = require("./output.js");
+const compile_mode_js_1 = require("./compile-mode.js");
+/**
+ * Фильтрует список файлов по заданному списку
+ * Если files пустой, возвращает все rawFileNames
+ */
+function selectFiles(rawFileNames, files) {
+    if (files.length === 0) {
+        return rawFileNames;
+    }
+    return rawFileNames.filter(x => files.includes(x));
+}
+/**
+ * Получает директорию вывода из конфигурации program
+ */
+function getOutputDirectory(program) {
+    const options = program.getCompilerOptions();
+    const outDir = options.outDir || '';
+    // Если outDir уже абсолютный путь, используем его напрямую
+    if (node_path_1.default.isAbsolute(outDir)) {
+        return node_path_1.default.normalize(outDir);
+    }
+    return node_path_1.default.normalize(node_path_1.default.join(program.getCurrentDirectory(), outDir));
+}
+/**
+ * Выводит диагностику TypeScript в лог
+ */
+function reportDiagnostics(diagnostics) {
+    diagnostics.forEach(diagnostic => {
+        if (diagnostic.file) {
+            const { line, character } = typescript_1.default.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
+            const message = typescript_1.default.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+            logger_js_1.logger.error(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
+        }
+        else {
+            logger_js_1.logger.error(typescript_1.default.flattenDiagnosticMessageText(diagnostic.messageText, '\n'));
+        }
+    });
+}
+/**
+ * Вычисляет путь выходного файла для sourceFile
+ */
+function getOutputPath(sourceFile, program) {
+    const opts = program.getCompilerOptions();
+    const cwd = program.getCurrentDirectory();
+    const outDir = node_path_1.default.resolve(cwd, opts.outDir || ".");
+    const rootDir = opts.rootDir ? node_path_1.default.resolve(cwd, opts.rootDir) : node_path_1.default.dirname(program.getRootFileNames()[0] || sourceFile.fileName);
+    const rel = node_path_1.default.relative(rootDir, sourceFile.fileName);
+    const outFile = rel.replace(/\.tsx?$/, ".js");
+    return node_path_1.default.join(outDir, outFile);
+}
+/**
+ * Компилирует TypeScript файлы через bt-ir
+ *
+ * Создаёт program с noEmit (диагностика), emit выполняет bt-ir.
+ */
+function compile(context) {
+    const startTime = Date.now();
+    const { tsConfig, options, files } = context;
+    const fileNames = selectFiles(tsConfig.fileNames, files);
+    const compilerOptions = {
+        ...tsConfig.options,
+        noEmit: true,
+    };
+    const program = typescript_1.default.createProgram(fileNames, compilerOptions);
+    const diagnostics = typescript_1.default.getPreEmitDiagnostics(program);
+    reportDiagnostics(diagnostics);
+    const allSourceFiles = program
+        .getSourceFiles()
+        .filter((sf) => !sf.isDeclarationFile && !sf.fileName.includes("node_modules"));
+    const sourceFiles = fileNames.length === 0
+        ? allSourceFiles
+        : fileNames
+            .map((fn) => program.getSourceFile(fn))
+            .filter((sf) => !!sf);
+    const { executables, paths: executablePaths } = (0, compile_mode_js_1.collectExecutables)(program, sourceFiles);
+    const emittedFiles = [];
+    const outputDir = getOutputDirectory(program);
+    for (const sourceFile of sourceFiles) {
+        const mode = (0, compile_mode_js_1.resolveCompileMode)(sourceFile, options, executablePaths);
+        const outputPath = getOutputPath(sourceFile, program);
+        const result = (0, bt_ir_1.compileSourceFile)(sourceFile, program, {
+            mode,
+            outputPath,
+            filename: sourceFile.fileName,
+            fileKey: mode === "script" ? (0, compile_mode_js_1.computeFileKey)(sourceFile, program) : undefined,
+            currentFileJs: mode === "module" ? (0, compile_mode_js_1.computeCurrentFileJs)(sourceFile) : undefined,
+        });
+        for (const output of result.outputs) {
+            const { fileName: finalFileName, content } = (0, output_js_1.transformOutput)(output.path, output.code, options);
+            const dir = node_path_1.default.dirname(finalFileName);
+            if (!node_fs_1.default.existsSync(dir)) {
+                node_fs_1.default.mkdirSync(dir, { recursive: true });
+            }
+            node_fs_1.default.writeFileSync(finalFileName, content, "utf-8");
+            emittedFiles.push(finalFileName);
+        }
+    }
+    node_fs_1.default.writeFileSync(node_path_1.default.join(outputDir, ".executables.json"), JSON.stringify(executables, null, 2), "utf-8");
+    const duration = Date.now() - startTime;
+    const hasErrors = diagnostics.filter((d) => d.category === typescript_1.default.DiagnosticCategory.Error).length > 0;
+    return {
+        success: !hasErrors,
+        emitResult: { emitSkipped: false, diagnostics: [] },
+        executables,
+        diagnostics,
+        duration,
+        emittedFiles,
+    };
+}
+/**
+ * Создаёт watch program для инкрементальной компиляции
+ *
+ * Использует TypeScript watch API для эффективной инкрементальной сборки.
+ * Применяет те же трансформеры и пост-обработку, что и обычная компиляция.
+ *
+ * @param context - Контекст сборки
+ * @param onRebuild - Callback при каждой пересборке
+ * @returns Контроллер для остановки watch
+ */
+function createWatchProgram(context, onRebuild) {
+    const { tsConfig, options, cwd } = context;
+    // Определяем путь к tsconfig.json
+    const configPath = typescript_1.default.findConfigFile(cwd || process.cwd(), typescript_1.default.sys.fileExists, 'tsconfig.json');
+    if (!configPath) {
+        throw new Error('Could not find tsconfig.json');
+    }
+    // Хранилище для executables (обновляется при каждой сборке)
+    let currentExecutables = [];
+    let currentEmittedFiles = [];
+    let buildStartTime = Date.now();
+    let hasErrors = false;
+    // Watch mode использует noEmit - мы сами делаем emit для affected файлов
+    const watchOptions = {
+        ...tsConfig.options,
+        noEmit: true,
+    };
+    // Создаём watch compiler host с кастомным sys
+    const host = typescript_1.default.createWatchCompilerHost(configPath, watchOptions, typescript_1.default.sys, // <-- используем кастомный sys
+    typescript_1.default.createEmitAndSemanticDiagnosticsBuilderProgram, 
+    // Обработчик диагностики (ошибок)
+    (diagnostic) => {
+        hasErrors = true;
+        const message = typescript_1.default.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+        if (diagnostic.file) {
+            const { line, character } = typescript_1.default.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
+            const fileName = diagnostic.file.fileName;
+            logger_js_1.logger.error(`${fileName}:${line + 1}:${character + 1} - ${message}`);
+        }
+        else {
+            logger_js_1.logger.error(message);
+        }
+    }, 
+    // Обработчик watch статуса
+    (diagnostic) => {
+        const message = typescript_1.default.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+        // Код 6031 = "Starting compilation in watch mode..."
+        // Код 6032 = "File change detected. Starting incremental compilation..."
+        // Код 6193 = "File change detected. Starting incremental compilation..."
+        // Код 6194 = "Found 0 errors. Watching for file changes."
+        if (diagnostic.code === 6031 || diagnostic.code === 6032 || diagnostic.code === 6193) {
+            buildStartTime = Date.now();
+            hasErrors = false;
+            currentEmittedFiles = []; // Сбрасываем список emitted файлов
+            logger_js_1.logger.info(`🔄 ${message}`);
+        }
+        else if (diagnostic.code === 6194) {
+            // Этот callback вызывается ПОСЛЕ afterProgramCreate, 
+            // поэтому emit уже выполнен там
+            const duration = Date.now() - buildStartTime;
+            // Сохраняем executables
+            const outputDir = tsConfig.options.outDir || cwd || process.cwd();
+            node_fs_1.default.writeFileSync(node_path_1.default.join(outputDir, '.executables.json'), JSON.stringify(currentExecutables, null, 2), 'utf-8');
+            // Вызываем callback
+            if (onRebuild) {
+                onRebuild({
+                    success: !hasErrors,
+                    emitResult: { emitSkipped: false, diagnostics: [] },
+                    executables: currentExecutables,
+                    diagnostics: [],
+                    duration,
+                    emittedFiles: currentEmittedFiles,
+                });
+            }
+            logger_js_1.logger.success(`✅ Build successful (${duration}ms)`);
+        }
+        else {
+            logger_js_1.logger.info(message);
+        }
+    });
+    // Сохраняем оригинальный afterProgramCreate
+    const originalAfterProgramCreate = host.afterProgramCreate;
+    let isFirstBuild = true;
+    // Перехватываем afterProgramCreate
+    host.afterProgramCreate = (builderProgram) => {
+        const program = builderProgram.getProgram();
+        // Собираем affected files ДО создания трансформеров
+        const affectedFiles = [];
+        let result;
+        while ((result = builderProgram.getSemanticDiagnosticsOfNextAffectedFile())) {
+            if (result.affected && typescript_1.default.isSourceFile(result.affected)) {
+                affectedFiles.push(result.affected);
+            }
+        }
+        // На первой сборке emit все файлы, потом только affected
+        // Фильтруем declaration files и файлы из node_modules
+        const filesToEmit = (isFirstBuild
+            ? program.getSourceFiles()
+            : affectedFiles).filter(sf => !sf.isDeclarationFile &&
+            !sf.fileName.includes('node_modules'));
+        isFirstBuild = false;
+        if (filesToEmit.length === 0) {
+            logger_js_1.logger.info('No files to emit');
+            if (originalAfterProgramCreate) {
+                originalAfterProgramCreate(builderProgram);
+            }
+            return;
+        }
+        logger_js_1.logger.info(`Emitting ${filesToEmit.length} file(s): ${filesToEmit.map((f) => node_path_1.default.basename(f.fileName)).join(", ")}`);
+        const { executables, paths: executablePaths } = (0, compile_mode_js_1.collectExecutables)(program, filesToEmit);
+        currentExecutables = executables;
+        const outputDir = getOutputDirectory(program);
+        for (const sourceFile of filesToEmit) {
+            const mode = (0, compile_mode_js_1.resolveCompileMode)(sourceFile, options, executablePaths);
+            const outputPath = getOutputPath(sourceFile, program);
+            const result = (0, bt_ir_1.compileSourceFile)(sourceFile, program, {
+                mode,
+                outputPath,
+                filename: sourceFile.fileName,
+                fileKey: mode === "script" ? (0, compile_mode_js_1.computeFileKey)(sourceFile, program) : undefined,
+                currentFileJs: mode === "module" ? (0, compile_mode_js_1.computeCurrentFileJs)(sourceFile) : undefined,
+            });
+            for (const output of result.outputs) {
+                const { fileName: finalFileName, content } = (0, output_js_1.transformOutput)(output.path, output.code, options);
+                const dir = node_path_1.default.dirname(finalFileName);
+                if (!node_fs_1.default.existsSync(dir)) {
+                    node_fs_1.default.mkdirSync(dir, { recursive: true });
+                }
+                node_fs_1.default.writeFileSync(finalFileName, content, "utf-8");
+                currentEmittedFiles.push(finalFileName);
+            }
+        }
+        // Переопределяем emit на пустышку
+        builderProgram.emit = () => ({
+            emitSkipped: true,
+            diagnostics: [],
+        });
+        if (originalAfterProgramCreate) {
+            originalAfterProgramCreate(builderProgram);
+        }
+    };
+    // Запускаем watch
+    const watchProgram = typescript_1.default.createWatchProgram(host);
+    return {
+        close: () => {
+            watchProgram.close();
+        },
+    };
+}

package/build/core/building/coordinator.js

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * Координатор dev mode для multi-package проектов
+ *
+ * @module building/coordinator
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevCoordinator = void 0;
+const logger_js_1 = require("../logger.js");
+const index_js_1 = require("../linking/index.js");
+/**
+ * Координатор dev mode для multi-package проектов
+ *
+ * Отслеживает initial build всех пакетов и координирует линковку:
+ * - Ждёт завершения initial build от всех пакетов
+ * - После этого выполняет одну полную линковку
+ * - Далее — инкрементальная линковка для каждого изменения
+ */
+class DevCoordinator {
+    pendingInitialBuilds;
+    initialLinkDone = false;
+    projectPath;
+    allPackages;
+    pushQueue;
+    constructor(projectPath, watchPackages, allPackages, pushQueue) {
+        this.projectPath = projectPath;
+        this.allPackages = allPackages;
+        this.pendingInitialBuilds = new Set(watchPackages.map(p => p.wsName));
+        this.pushQueue = pushQueue;
+    }
+    /**
+     * Вызывается при завершении build пакета
+     */
+    async onPackageBuild(pkg, emittedFiles) {
+        if (this.pendingInitialBuilds.has(pkg.wsName)) {
+            // Это initial build
+            this.pendingInitialBuilds.delete(pkg.wsName);
+            logger_js_1.logger.success(`  ✅ Initial build completed: ${pkg.wsName}`);
+            if (this.pendingInitialBuilds.size === 0) {
+                // Все пакеты собрались — полная линковка
+                logger_js_1.logger.info('🔗 All packages built. Running full link...');
+                await (0, index_js_1.processPackagesLinking)(this.projectPath, this.allPackages, {});
+                this.initialLinkDone = true;
+                logger_js_1.logger.success('✅ Dev mode ready. Watching for changes...');
+                this.pushQueue?.schedule();
+            }
+        }
+        else if (this.initialLinkDone) {
+            // Инкрементальная линковка
+            await (0, index_js_1.processPackagesLinking)(this.projectPath, [{ name: pkg.name }], {
+                devMode: true,
+                changedFiles: emittedFiles,
+            });
+            this.pushQueue?.schedule();
+        }
+        // Если !initialLinkDone и это не initial build — игнорируем (промежуточное состояние)
+    }
+    /**
+     * Вызывается при изменении non-TS файла
+     */
+    async onNonTsFileChange(pkg, filePath) {
+        if (this.initialLinkDone) {
+            await (0, index_js_1.processPackagesLinking)(this.projectPath, [{ name: pkg.name }], {
+                devMode: true,
+                changedFiles: [filePath],
+            });
+            this.pushQueue?.schedule();
+        }
+    }
+}
+exports.DevCoordinator = DevCoordinator;