@nu-art/build-and-install 0.400.14 → 0.401.1

package/exports/IndicesMcpServer.d.ts

@@ -0,0 +1,22 @@
+import { ProjectUnit } from '../units/base/ProjectUnit.js';
+import { Logger } from '@nu-art/ts-common';
+export declare class IndicesMcpServer extends Logger {
+    private server?;
+    private port;
+    private projectRoot;
+    private packages;
+    constructor(port: number, projectRoot: string, packages: ProjectUnit[]);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private handleRequest;
+    private handleHealth;
+    private handlePackages;
+    private handlePackageRoutes;
+    private handleGetAllExports;
+    private handleGetByName;
+    private handleGetByFile;
+    private handleGetByType;
+    private handleStale;
+    private sendJson;
+    private sendError;
+}

package/exports/IndicesMcpServer.js

@@ -0,0 +1,220 @@
+import { createServer } from 'http';
+import { URL } from 'url';
+import { ExportIndexCache } from './ExportIndexCache.js';
+import { Unit_TypescriptLib } from '../units/implementations/Unit_TypescriptLib.js';
+import { Logger } from '@nu-art/ts-common';
+export class IndicesMcpServer extends Logger {
+    server;
+    port;
+    projectRoot;
+    packages;
+    constructor(port, projectRoot, packages) {
+        super();
+        this.port = port;
+        this.projectRoot = projectRoot;
+        this.packages = packages;
+    }
+    async start() {
+        return new Promise((resolve, reject) => {
+            this.server = createServer((req, res) => this.handleRequest(req, res));
+            this.server.listen(this.port, () => {
+                this.logInfo(`Export Indices MCP Server started on port ${this.port}`);
+                this.logInfo(`Available packages: ${this.packages.map(p => p.config.key).join(', ')}`);
+                resolve();
+            });
+            this.server.on('error', (error) => {
+                if (error.code === 'EADDRINUSE') {
+                    this.logError(`Port ${this.port} is already in use`);
+                    reject(new Error(`Port ${this.port} is already in use`));
+                }
+                else {
+                    this.logError('Server error:', error);
+                    reject(error);
+                }
+            });
+        });
+    }
+    async stop() {
+        return new Promise((resolve) => {
+            if (!this.server) {
+                resolve();
+                return;
+            }
+            this.server.close(() => {
+                this.logInfo('Export Indices MCP Server stopped');
+                resolve();
+            });
+        });
+    }
+    async handleRequest(req, res) {
+        try {
+            const url = new URL(req.url || '/', `http://${req.headers.host}`);
+            const path = url.pathname;
+            const method = req.method;
+            // Set CORS headers
+            res.setHeader('Access-Control-Allow-Origin', '*');
+            res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
+            res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+            res.setHeader('Content-Type', 'application/json');
+            if (method === 'OPTIONS') {
+                res.writeHead(200);
+                res.end();
+                return;
+            }
+            if (method !== 'GET') {
+                this.sendError(res, 405, 'Method not allowed');
+                return;
+            }
+            // Route handling
+            if (path === '/health') {
+                this.handleHealth(res);
+            }
+            else if (path === '/packages') {
+                await this.handlePackages(res);
+            }
+            else if (path.startsWith('/packages/')) {
+                await this.handlePackageRoutes(path, res);
+            }
+            else {
+                this.sendError(res, 404, 'Not found');
+            }
+        }
+        catch (error) {
+            this.logError('Request handling error:', error);
+            this.sendError(res, 500, error.message || 'Internal server error');
+        }
+    }
+    handleHealth(res) {
+        this.sendJson(res, { status: 'ok', service: 'Export Indices MCP Server' });
+    }
+    async handlePackages(res) {
+        const packages = this.packages
+            .filter(unit => unit.isInstanceOf(Unit_TypescriptLib))
+            .map(unit => ({
+            name: unit.config.key,
+            root: unit.config.fullPath
+        }));
+        this.sendJson(res, { packages });
+    }
+    async handlePackageRoutes(path, res) {
+        // Extract package name and remaining path
+        // Path format: /packages/:packageName/...
+        const pathParts = path.split('/').filter(p => p);
+        if (pathParts.length < 2 || pathParts[0] !== 'packages') {
+            this.sendError(res, 404, 'Invalid path');
+            return;
+        }
+        const packageName = decodeURIComponent(pathParts[1]);
+        const packageUnit = this.packages.find(p => p.config.key === packageName);
+        if (!packageUnit || !packageUnit.isInstanceOf(Unit_TypescriptLib)) {
+            this.sendError(res, 404, `Package '${packageName}' not found`);
+            return;
+        }
+        const packageRoot = packageUnit.config.fullPath;
+        const remainingPath = pathParts.slice(2).join('/');
+        if (remainingPath === 'exports') {
+            await this.handleGetAllExports(packageName, packageRoot, res);
+        }
+        else if (remainingPath.startsWith('exports/by-name/')) {
+            const symbolName = decodeURIComponent(remainingPath.replace('exports/by-name/', ''));
+            await this.handleGetByName(packageName, packageRoot, symbolName, res);
+        }
+        else if (remainingPath.startsWith('exports/by-file/')) {
+            const filePath = decodeURIComponent(remainingPath.replace('exports/by-file/', ''));
+            await this.handleGetByFile(packageName, packageRoot, filePath, res);
+        }
+        else if (remainingPath.startsWith('exports/by-type/')) {
+            const symbolType = decodeURIComponent(remainingPath.replace('exports/by-type/', ''));
+            await this.handleGetByType(packageName, packageRoot, symbolType, res);
+        }
+        else if (remainingPath === 'stale') {
+            await this.handleStale(packageName, packageRoot, res);
+        }
+        else {
+            this.sendError(res, 404, 'Not found');
+        }
+    }
+    async handleGetAllExports(packageName, packageRoot, res) {
+        try {
+            const exports = await ExportIndexCache.getAll(this.projectRoot, packageRoot, packageName);
+            this.sendJson(res, { package: packageName, exports });
+        }
+        catch (error) {
+            if (error.message?.includes('Index file not found')) {
+                this.sendError(res, 404, `Indices not found for package '${packageName}'. Run 'bai --map-exports' to generate indices.`);
+            }
+            else {
+                this.sendError(res, 500, error.message || 'Failed to get exports');
+            }
+        }
+    }
+    async handleGetByName(packageName, packageRoot, symbolName, res) {
+        try {
+            const symbol = await ExportIndexCache.getByName(this.projectRoot, packageRoot, packageName, symbolName);
+            if (!symbol) {
+                this.sendError(res, 404, `Symbol '${symbolName}' not found in package '${packageName}'`);
+                return;
+            }
+            this.sendJson(res, { package: packageName, symbol });
+        }
+        catch (error) {
+            if (error.message?.includes('Index file not found')) {
+                this.sendError(res, 404, `Indices not found for package '${packageName}'. Run 'bai --map-exports' to generate indices.`);
+            }
+            else {
+                this.sendError(res, 500, error.message || 'Failed to get symbol');
+            }
+        }
+    }
+    async handleGetByFile(packageName, packageRoot, filePath, res) {
+        try {
+            const exports = await ExportIndexCache.getByFile(this.projectRoot, packageRoot, packageName, filePath);
+            this.sendJson(res, { package: packageName, filePath, exports });
+        }
+        catch (error) {
+            if (error.message?.includes('Index file not found')) {
+                this.sendError(res, 404, `Indices not found for package '${packageName}'. Run 'bai --map-exports' to generate indices.`);
+            }
+            else {
+                this.sendError(res, 500, error.message || 'Failed to get exports by file');
+            }
+        }
+    }
+    async handleGetByType(packageName, packageRoot, symbolType, res) {
+        try {
+            const exports = await ExportIndexCache.getByType(this.projectRoot, packageRoot, packageName, symbolType);
+            this.sendJson(res, { package: packageName, symbolType, exports });
+        }
+        catch (error) {
+            if (error.message?.includes('Index file not found')) {
+                this.sendError(res, 404, `Indices not found for package '${packageName}'. Run 'bai --map-exports' to generate indices.`);
+            }
+            else {
+                this.sendError(res, 500, error.message || 'Failed to get exports by type');
+            }
+        }
+    }
+    async handleStale(packageName, packageRoot, res) {
+        try {
+            const stale = await ExportIndexCache.isStale(this.projectRoot, packageRoot, packageName);
+            this.sendJson(res, {
+                package: packageName,
+                stale,
+                message: stale
+                    ? "Source files are newer than index files. Run 'bai --map-exports' to regenerate."
+                    : 'Indices are up to date.'
+            });
+        }
+        catch (error) {
+            this.sendError(res, 500, error.message || 'Failed to check stale status');
+        }
+    }
+    sendJson(res, data) {
+        res.writeHead(200);
+        res.end(JSON.stringify(data, null, 2));
+    }
+    sendError(res, statusCode, message) {
+        res.writeHead(statusCode);
+        res.end(JSON.stringify({ error: message }, null, 2));
+    }
+}

package/exports/types.js

@@ -0,0 +1,3 @@
+// Export types will be defined here if needed
+// Currently using types from ExportMapper.ts
+export {};

package/package.json

@@ -1,24 +1,32 @@
 {
   "name": "@nu-art/build-and-install",
-  "version": "0.400.14",
-  "description": "",
+  "version": "0.401.1",
+  "description": "A build system for monorepos that orchestrates building, testing, and deploying units with dependency-aware phase execution",
   "type": "module",
   "keywords": [
-    "TacB0sS",
-    "infra",
+    "typescript",
+    "build-system",
+    "monorepo",
+    "dependency-management",
+    "phase-execution",
+    "workspace",
+    "units",
+    "automation",
     "nu-art",
-    "commando"
+    "thunderstorm",
+    "build-and-install"
   ],
   "homepage": "https://github.com/nu-art-js/thunderstorm",
   "bugs": {
-    "url": "https://github.com/nu-art-js/thunderstorm/issues"
+    "url": "https://github.com/nu-art-js/thunderstorm/issues?q=is%3Aissue+label%3Abuild-and-install"
   },
   "publishConfig": {
     "directory": "dist"
   },
   "repository": {
     "type": "git",
-    "url": "git+ssh://git@github.com:nu-art-js/thunderstorm.git"
+    "url": "git+ssh://git@github.com:nu-art-js/thunderstorm.git",
+    "directory": "_thunderstorm/build-and-install"
   },
   "license": "Apache-2.0",
   "author": "TacB0sS",
@@ -31,8 +39,11 @@
   },
   "dependencies": {
     "chokidar": "^3.6.0",
-    "@nu-art/ts-common": "0.400.14",
-    "@nu-art/commando": "0.400.14"
+    "@nu-art/ts-common": "0.401.1",
+    "@nu-art/commando": "0.401.1"
+  },
+  "devDependencies": {
+    "@nu-art/testalot": "0.401.1"
   },
   "unitConfig": {
     "type": "typescript-lib"

package/phases/PhaseManager.d.ts

@@ -0,0 +1,130 @@
+import { Logger } from '@nu-art/ts-common';
+import { RunningStatusHandler } from '../runtime/RunningStatusHandler.js';
+import { Phase } from './definitions/index.js';
+import { BaseUnit } from '../units/index.js';
+/**
+ * Scheduled execution step (before mapping to actual phases/units).
+ */
+export type ScheduledStep = {
+    phases: string[];
+    units: string[];
+};
+/**
+ * Mapped execution step with actual phase and unit instances.
+ */
+export type ExecutionStep = {
+    phases: Phase<any>[];
+    units: BaseUnit<any>[];
+};
+/**
+ * Manages phase execution across units in dependency order.
+ *
+ * **Execution Model**:
+ * - **Phase Groups**: Phases that can run in parallel (e.g., [prepare, compile])
+ * - **Unit Layers**: Units grouped by dependency level (dependencies first)
+ * - **Steps**: Combinations of phase groups × unit layers
+ *
+ * **Execution Flow**:
+ * 1. `calculateExecutionSteps()`: Plans which phases run on which units
+ * 2. `execute()`: Executes steps sequentially, phases in parallel within steps
+ * 3. Units in same layer run phases in parallel (Promise.all)
+ *
+ * **Eligibility Rules**:
+ * - Unit must implement the phase method (e.g., `compile()`, `test()`)
+ * - Unit must be in active/project units (based on phase.unitCategory)
+ * - Phase filter (if present) must pass runtime params
+ *
+ * **Error Handling**:
+ * - First failure stops execution (sets `killed = true`)
+ * - Aggregates all errors into `PhaseAggregatedException`
+ * - Tracks running units for graceful shutdown
+ *
+ * **Resume Support**:
+ * - Skips completed steps (via `runningStatus.startIndex`)
+ * - Skips completed units within steps (via `runningStatus.isCompleted()`)
+ *
+ * **Validation**:
+ * - Constructor validates no duplicate units or phases
+ * - Throws `BadImplementationException` on duplicates
+ */
+export declare class PhaseManager extends Logger {
+    private readonly phases;
+    private readonly units;
+    private runningUnits;
+    private killed;
+    private runningStatus;
+    private activeUnits;
+    private projectUnitKeys;
+    private readonly keyToPhaseMap;
+    constructor(runningStatus: RunningStatusHandler, phases: Phase<any>[][], units: BaseUnit[][], activeUnits: string[], projectUnitKeys: string[]);
+    /**
+     * Calculates the execution plan: which phases run on which units.
+     *
+     * **Algorithm**:
+     * 1. For each phase group (phases that can run together)
+     * 2. Filter phases by runtime params (if phase.filter exists)
+     * 3. For each unit layer (dependency level)
+     * 4. Find units eligible for at least one phase in the group
+     * 5. Group units by which phases they support
+     * 6. Create steps: phase combinations × unit groups
+     *
+     * **Phase Grouping**: Units that support the same set of phases are grouped
+     * together in a step (identified by phase keys joined with '|').
+     *
+     * **Unit Eligibility**:
+     * - Unit must implement phase method
+     * - Unit must be in active/project units (based on phase.unitCategory)
+     *
+     * @returns Array of scheduled steps (phases and unit keys)
+     */
+    calculateExecutionSteps(): Promise<ScheduledStep[]>;
+    /**
+     * Executes the planned steps sequentially.
+     *
+     * **Execution Model**:
+     * - Steps run sequentially (one after another)
+     * - Units within a step run phases in parallel (Promise.all)
+     * - Phases for a unit run sequentially (in phase group order)
+     *
+     * **Resume Support**:
+     * - Starts from `runningStatus.startIndex` (if --continue)
+     * - Skips units marked as completed
+     *
+     * **Dry Run**: If `--dry-run`, only logs phase/unit names without executing.
+     *
+     * **Error Handling**:
+     * - First error stops execution (sets `killed = true`)
+     * - All errors aggregated into `PhaseAggregatedException`
+     * - Running units tracked for graceful shutdown
+     *
+     * **Performance**: Logs operation duration if > 1.5 seconds.
+     *
+     * @param _steps - Scheduled steps to execute
+     * @throws PhaseAggregatedException if any phase fails
+     */
+    execute(_steps: ScheduledStep[]): Promise<void>;
+    /**
+     * Gracefully stops execution and kills all running units.
+     *
+     * Called on SIGINT (Ctrl+C). Sets `killed = true` to stop further execution,
+     * then calls `kill()` on all currently running units.
+     *
+     * @returns Promise that resolves when all units are killed
+     */
+    break(): Promise<void[]>;
+    /**
+     * Maps scheduled step (with string keys) to execution step (with actual instances).
+     *
+     * **Mapping Process**:
+     * - Maps phase keys to Phase instances using `keyToPhaseMap`
+     * - Maps unit keys to BaseUnit instances by searching through unit layers
+     *
+     * **Performance Note**: Unit lookup iterates through all layers (O(n) complexity).
+     * Consider using a lookup map for O(1) access in large workspaces.
+     *
+     * @param scheduledStep - Scheduled step with phase/unit keys
+     * @returns Execution step with phase/unit instances
+     * @throws Error if phase or unit not found
+     */
+    private mapStep;
+}