@manojkmfsi/monodog 1.0.1

package/dist/utils/ci-status.js

@@ -0,0 +1,446 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ciStatusManager = exports.CIStatusManager = void 0;
+exports.getPackageCIStatus = getPackageCIStatus;
+exports.getMonorepoCIStatus = getMonorepoCIStatus;
+exports.triggerPackageBuild = triggerPackageBuild;
+class CIStatusManager {
+    constructor() {
+        this.providers = new Map();
+        this.cache = new Map();
+        this.cacheExpiry = 2 * 60 * 1000; // 2 minutes
+        this.initializeDefaultProviders();
+    }
+    /**
+     * Initialize default CI providers
+     */
+    initializeDefaultProviders() {
+        // GitHub Actions
+        this.addProvider({
+            name: 'GitHub Actions',
+            type: 'github',
+            baseUrl: 'https://api.github.com',
+        });
+        // GitLab CI
+        this.addProvider({
+            name: 'GitLab CI',
+            type: 'gitlab',
+            baseUrl: 'https://gitlab.com/api/v4',
+        });
+        // CircleCI
+        this.addProvider({
+            name: 'CircleCI',
+            type: 'circleci',
+            baseUrl: 'https://circleci.com/api/v2',
+        });
+    }
+    /**
+     * Add a CI provider
+     */
+    addProvider(provider) {
+        this.providers.set(provider.name, provider);
+    }
+    /**
+     * Remove a CI provider
+     */
+    removeProvider(name) {
+        this.providers.delete(name);
+    }
+    /**
+     * Get all registered providers
+     */
+    getProviders() {
+        return Array.from(this.providers.values());
+    }
+    /**
+     * Fetch CI status for a specific package
+     */
+    async getPackageStatus(packageName, providerName) {
+        const cacheKey = `package-status-${packageName}-${providerName || 'all'}`;
+        const cached = this.getFromCache(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        try {
+            let builds = [];
+            if (providerName) {
+                const provider = this.providers.get(providerName);
+                if (provider) {
+                    builds = await this.fetchBuildsFromProvider(provider, packageName);
+                }
+            }
+            else {
+                // Fetch from all providers
+                for (const provider of this.providers.values()) {
+                    const providerBuilds = await this.fetchBuildsFromProvider(provider, packageName);
+                    builds.push(...providerBuilds);
+                }
+            }
+            if (builds.length === 0) {
+                return null;
+            }
+            // Sort builds by start time (newest first)
+            builds.sort((a, b) => b.startTime.getTime() - a.startTime.getTime());
+            const lastBuild = builds[0];
+            const buildHistory = builds.slice(0, 10); // Last 10 builds
+            const successRate = this.calculateSuccessRate(builds);
+            const averageDuration = this.calculateAverageDuration(builds);
+            const isHealthy = this.determinePackageHealth(builds);
+            const issues = this.identifyIssues(builds);
+            const status = {
+                packageName,
+                lastBuild,
+                buildHistory,
+                successRate,
+                averageDuration,
+                lastCommit: lastBuild.commit,
+                lastCommitDate: lastBuild.startTime,
+                branch: lastBuild.branch,
+                isHealthy,
+                issues,
+            };
+            this.setCache(cacheKey, status);
+            return status;
+        }
+        catch (error) {
+            console.error(`Error fetching CI status for ${packageName}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Get overall monorepo CI status
+     */
+    async getMonorepoStatus(packages) {
+        const cacheKey = 'monorepo-ci-status';
+        const cached = this.getFromCache(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        const packageStatuses = [];
+        const allBuilds = [];
+        let totalTests = 0;
+        let passedTests = 0;
+        let failedTests = 0;
+        const packageCoverage = {};
+        // Get status for each package
+        for (const pkg of packages) {
+            const status = await this.getPackageStatus(pkg.name);
+            if (status) {
+                packageStatuses.push(status);
+                allBuilds.push(...status.buildHistory);
+                // Aggregate test results
+                if (status.lastBuild?.tests) {
+                    totalTests += status.lastBuild.tests.total;
+                    passedTests += status.lastBuild.tests.passed;
+                    failedTests += status.lastBuild.tests.failed;
+                }
+                // Aggregate coverage
+                if (status.lastBuild?.coverage) {
+                    packageCoverage[pkg.name] = status.lastBuild.coverage.percentage;
+                }
+            }
+        }
+        // Calculate overall metrics
+        const totalPackages = packages.length;
+        const healthyPackages = packageStatuses.filter(s => s.isHealthy).length;
+        const warningPackages = packageStatuses.filter(s => !s.isHealthy && s.issues.length < 3).length;
+        const errorPackages = packageStatuses.filter(s => !s.isHealthy && s.issues.length >= 3).length;
+        const overallHealth = (healthyPackages / totalPackages) * 100;
+        // Sort builds by time
+        allBuilds.sort((a, b) => b.startTime.getTime() - a.startTime.getTime());
+        const recentBuilds = allBuilds.slice(0, 20);
+        const failedBuilds = allBuilds.filter(b => b.status === 'failed');
+        // Calculate overall coverage
+        const coverageValues = Object.values(packageCoverage);
+        const overallCoverage = coverageValues.length > 0
+            ? coverageValues.reduce((sum, val) => sum + val, 0) /
+                coverageValues.length
+            : 0;
+        const status = {
+            totalPackages,
+            healthyPackages,
+            warningPackages,
+            errorPackages,
+            overallHealth,
+            packages: packageStatuses,
+            recentBuilds,
+            failedBuilds,
+            coverage: {
+                overall: overallCoverage,
+                packages: packageCoverage,
+            },
+            tests: {
+                total: totalTests,
+                passed: passedTests,
+                failed: failedTests,
+                successRate: totalTests > 0 ? (passedTests / totalTests) * 100 : 0,
+            },
+        };
+        this.setCache(cacheKey, status);
+        return status;
+    }
+    /**
+     * Fetch builds from a specific CI provider
+     */
+    async fetchBuildsFromProvider(_provider, packageName) {
+        // This is a mock implementation
+        // In a real implementation, you would make API calls to the CI provider
+        const mockBuilds = [
+            {
+                id: `build-${Date.now()}-1`,
+                status: 'success',
+                branch: 'main',
+                commit: 'abc1234',
+                commitMessage: `feat: update ${packageName}`,
+                author: 'developer@example.com',
+                startTime: new Date(Date.now() - 1000 * 60 * 30), // 30 minutes ago
+                endTime: new Date(Date.now() - 1000 * 60 * 25), // 25 minutes ago
+                duration: 5 * 60 * 1000, // 5 minutes
+                url: `https://ci.example.com/builds/build-${Date.now()}-1`,
+                packageName,
+                workflowName: 'Build and Test',
+                jobName: 'test',
+                steps: [
+                    {
+                        name: 'Install dependencies',
+                        status: 'success',
+                        duration: 30000,
+                    },
+                    {
+                        name: 'Run tests',
+                        status: 'success',
+                        duration: 120000,
+                    },
+                    {
+                        name: 'Build package',
+                        status: 'success',
+                        duration: 60000,
+                    },
+                ],
+                coverage: {
+                    percentage: 85,
+                    lines: 1000,
+                    functions: 50,
+                    branches: 200,
+                    statements: 1200,
+                },
+                tests: {
+                    total: 150,
+                    passed: 145,
+                    failed: 0,
+                    skipped: 5,
+                    duration: 120000,
+                    suites: [
+                        {
+                            name: 'Unit Tests',
+                            status: 'pass',
+                            tests: [],
+                            duration: 80000,
+                        },
+                        {
+                            name: 'Integration Tests',
+                            status: 'pass',
+                            tests: [],
+                            duration: 40000,
+                        },
+                    ],
+                },
+            },
+            {
+                id: `build-${Date.now()}-2`,
+                status: 'failed',
+                branch: 'feature/new-feature',
+                commit: 'def5678',
+                commitMessage: `fix: resolve issue in ${packageName}`,
+                author: 'developer@example.com',
+                startTime: new Date(Date.now() - 1000 * 60 * 60 * 2), // 2 hours ago
+                endTime: new Date(Date.now() - 1000 * 60 * 60 * 1.5), // 1.5 hours ago
+                duration: 30 * 60 * 1000, // 30 minutes
+                url: `https://ci.example.com/builds/build-${Date.now()}-2`,
+                packageName,
+                workflowName: 'Build and Test',
+                jobName: 'test',
+                steps: [
+                    {
+                        name: 'Install dependencies',
+                        status: 'success',
+                        duration: 30000,
+                    },
+                    {
+                        name: 'Run tests',
+                        status: 'failed',
+                        duration: 120000,
+                        error: 'Test suite failed with 3 failing tests',
+                    },
+                ],
+                tests: {
+                    total: 150,
+                    passed: 147,
+                    failed: 3,
+                    skipped: 0,
+                    duration: 120000,
+                    suites: [
+                        {
+                            name: 'Unit Tests',
+                            status: 'pass',
+                            tests: [],
+                            duration: 80000,
+                        },
+                        {
+                            name: 'Integration Tests',
+                            status: 'fail',
+                            tests: [],
+                            duration: 40000,
+                        },
+                    ],
+                },
+            },
+        ];
+        return mockBuilds;
+    }
+    /**
+     * Calculate success rate from builds
+     */
+    calculateSuccessRate(builds) {
+        if (builds.length === 0)
+            return 0;
+        const successfulBuilds = builds.filter(b => b.status === 'success').length;
+        return (successfulBuilds / builds.length) * 100;
+    }
+    /**
+     * Calculate average build duration
+     */
+    calculateAverageDuration(builds) {
+        if (builds.length === 0)
+            return 0;
+        const completedBuilds = builds.filter(b => b.duration !== undefined);
+        if (completedBuilds.length === 0)
+            return 0;
+        const totalDuration = completedBuilds.reduce((sum, b) => sum + (b.duration || 0), 0);
+        return totalDuration / completedBuilds.length;
+    }
+    /**
+     * Determine if a package is healthy based on CI results
+     */
+    determinePackageHealth(builds) {
+        if (builds.length === 0)
+            return true;
+        const recentBuilds = builds.slice(0, 5); // Last 5 builds
+        const successRate = this.calculateSuccessRate(recentBuilds);
+        return successRate >= 80; // 80% success rate threshold
+    }
+    /**
+     * Identify issues from build results
+     */
+    identifyIssues(builds) {
+        const issues = [];
+        if (builds.length === 0)
+            return issues;
+        const recentBuilds = builds.slice(0, 3); // Last 3 builds
+        const successRate = this.calculateSuccessRate(recentBuilds);
+        if (successRate < 50) {
+            issues.push('High failure rate in recent builds');
+        }
+        const failedBuilds = recentBuilds.filter(b => b.status === 'failed');
+        for (const build of failedBuilds) {
+            const failedSteps = build.steps.filter(s => s.status === 'failed');
+            for (const step of failedSteps) {
+                if (step.error) {
+                    issues.push(`Build step '${step.name}' failed: ${step.error}`);
+                }
+            }
+        }
+        // Check for long build times
+        const avgDuration = this.calculateAverageDuration(recentBuilds);
+        if (avgDuration > 10 * 60 * 1000) {
+            // 10 minutes
+            issues.push('Builds are taking longer than expected');
+        }
+        return issues;
+    }
+    /**
+     * Get cache value if not expired
+     */
+    getFromCache(key) {
+        const cached = this.cache.get(key);
+        if (cached && Date.now() - cached.timestamp < this.cacheExpiry) {
+            return cached.data;
+        }
+        return null;
+    }
+    /**
+     * Set cache value with timestamp
+     */
+    setCache(key, data) {
+        this.cache.set(key, {
+            data,
+            timestamp: Date.now(),
+        });
+    }
+    /**
+     * Clear the cache
+     */
+    clearCache() {
+        this.cache.clear();
+    }
+    /**
+     * Get build logs for a specific build
+     */
+    async getBuildLogs(buildId, providerName) {
+        // Mock implementation
+        return `Build logs for ${buildId} from ${providerName}\n\nStep 1: Install dependencies\n✓ Dependencies installed successfully\n\nStep 2: Run tests\n✓ All tests passed\n\nStep 3: Build package\n✓ Package built successfully`;
+    }
+    /**
+     * Trigger a new build for a package
+     */
+    async triggerBuild(packageName, providerName, branch = 'main') {
+        try {
+            // Mock implementation
+            const buildId = `build-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+            console.log(`Triggering build for ${packageName} on ${branch} via ${providerName}`);
+            return {
+                success: true,
+                buildId,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    }
+    /**
+     * Get build artifacts
+     */
+    async getBuildArtifacts(buildId, _providerName) {
+        // Mock implementation
+        return [
+            {
+                name: 'coverage-report.html',
+                type: 'coverage',
+                size: 1024 * 50, // 50KB
+                url: `https://ci.example.com/artifacts/${buildId}/coverage-report.html`,
+            },
+            {
+                name: 'test-results.xml',
+                type: 'test',
+                size: 1024 * 10, // 10KB
+                url: `https://ci.example.com/artifacts/${buildId}/test-results.xml`,
+            },
+        ];
+    }
+}
+exports.CIStatusManager = CIStatusManager;
+// Export default instance
+exports.ciStatusManager = new CIStatusManager();
+// Export convenience functions
+async function getPackageCIStatus(packageName) {
+    return exports.ciStatusManager.getPackageStatus(packageName);
+}
+async function getMonorepoCIStatus(packages) {
+    return exports.ciStatusManager.getMonorepoStatus(packages);
+}
+async function triggerPackageBuild(packageName, providerName, branch) {
+    return exports.ciStatusManager.triggerBuild(packageName, providerName, branch);
+}

package/dist/utils/helpers.js

@@ -0,0 +1,237 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCommits = getCommits;
+exports.storePackage = storePackage;
+exports.storeCommits = storeCommits;
+exports.getPackageDependenciesInfo = getPackageDependenciesInfo;
+exports.storeDependencies = storeDependencies;
+// dotenv.config({ path: path.resolve(__dirname, '../.env') });
+// Fallback import to handle environments where PrismaClient isn't a named export
+const PrismaPkg = __importStar(require("@prisma/client"));
+const PrismaClient = PrismaPkg.PrismaClient || PrismaPkg.default || PrismaPkg;
+// Provide a fallback reference to the Prisma namespace so errors like
+// Prisma.PrismaClientKnownRequestError can be referenced safely.
+const Prisma = PrismaPkg.Prisma || PrismaPkg.PrismaClient?.Prisma || PrismaPkg.default?.Prisma || PrismaPkg;
+const config_loader_1 = require("../config-loader");
+// Default settings
+const DEFAULT_PORT = 4000;
+const port = config_loader_1.appConfig.server.port ?? DEFAULT_PORT; //Default port
+const host = config_loader_1.appConfig.server.host ?? 'localhost'; //Default host
+const prisma = new PrismaClient();
+const API_BASE = `http://${host}:${port}/api`;
+async function getCommits(path) {
+    const res = await fetch(API_BASE + `/commits/` + encodeURIComponent(path));
+    if (!res.ok)
+        throw new Error('Failed to fetch commits');
+    return (await res.json());
+}
+async function storeCommits(packageName, commits) {
+    console.log('💾 Storing commits for:' + packageName);
+    // Create or update dependencies
+    for (const commit of commits) {
+        try {
+            await prisma.commit.upsert({
+                where: {
+                    hash: commit.hash,
+                },
+                update: {
+                    message: commit.message,
+                    author: commit.author,
+                    date: commit.date,
+                    type: commit.type,
+                },
+                create: {
+                    hash: commit.hash,
+                    message: commit.message,
+                    author: commit.author,
+                    date: commit.date,
+                    type: commit.type,
+                    packageName: packageName,
+                },
+            });
+        }
+        catch (e) {
+            const err = e;
+            if (err instanceof Prisma.PrismaClientKnownRequestError &&
+                err.code === 'P2002') {
+                // Handle unique constraint violation (e.g., commit already exists)
+                console.warn(`Skipping commit: ${commit.hash} (Depenndency already exists)`);
+            }
+            else {
+                // Handle any other unexpected errors
+                console.error(`Failed to store commit: ${commit.hash}`, err);
+            }
+        }
+    }
+}
+/**
+ * Store packages in database
+ */
+async function storePackage(pkg) {
+    try {
+        // Create or update package
+        await prisma.package.upsert({
+            where: { name: pkg.name },
+            update: {
+                version: pkg.version,
+                type: pkg.type,
+                path: pkg.path,
+                description: pkg.description,
+                license: pkg.license,
+                repository: JSON.stringify(pkg.repository),
+                scripts: JSON.stringify(pkg.scripts),
+                lastUpdated: new Date(),
+            },
+            create: {
+                // Timestamps
+                createdAt: new Date(),
+                lastUpdated: new Date(),
+                // Key Metrics and Relationships
+                dependencies: JSON.stringify(pkg.dependencies), // The total number of direct dependencies (12 in your example)
+                // Manual Serialization Required: Stores a JSON array string of maintainers, e.g., '["team-frontend"]'
+                maintainers: pkg.maintainers.join(','),
+                // Manual Serialization Required: Stores a JSON array string of tags, e.g., '["core", "ui"]'
+                // Manual Serialization Required: Stores the scripts object as a JSON string
+                // Example: '{"dev": "vite", "build": "tsc && vite build"}'
+                scripts: JSON.stringify(pkg.scripts),
+                // Dependency Lists (Manual Serialization Required)
+                // Stores a JSON array string of dependencies.
+                // dependenciesList: JSON.stringify(pkg.dependenciesList),
+                devDependencies: JSON.stringify(pkg.devDependencies),
+                peerDependencies: JSON.stringify(pkg.peerDependencies),
+                name: pkg.name,
+                version: pkg.version,
+                type: pkg.type,
+                path: pkg.path,
+                description: pkg.description ?? '',
+                license: pkg.license ?? '',
+                repository: JSON.stringify(pkg.repository),
+                status: '',
+            },
+        });
+        const commits = await getCommits(pkg.path ?? '');
+        if (commits.length) {
+            await storeCommits(pkg.name, commits);
+        }
+        const dependenciesInfo = getPackageDependenciesInfo(pkg);
+        if (dependenciesInfo.length) {
+            await storeDependencies(pkg.name, dependenciesInfo);
+        }
+    }
+    catch (error) {
+        console.warn(`⚠️  Failed to store report for ${pkg.name}:`, error);
+    }
+}
+/**
+ * Get package dependencies
+ */
+function getPackageDependenciesInfo(pkg) {
+    const allDeps = [];
+    Object.keys(pkg.dependencies || {}).forEach(depName => {
+        allDeps.push({
+            name: depName,
+            version: pkg.dependencies[depName],
+            type: 'dependency',
+            latest: '',
+            outdated: false,
+        });
+    });
+    Object.keys(pkg.devDependencies || {}).forEach(depName => {
+        allDeps.push({
+            name: depName,
+            version: pkg.devDependencies[depName],
+            type: 'devDependency',
+            latest: '',
+            outdated: false,
+        });
+    });
+    Object.keys(pkg.peerDependencies || {}).forEach(depName => {
+        allDeps.push({
+            name: depName,
+            version: pkg.peerDependencies[depName],
+            type: 'peerDependency',
+            latest: '',
+            outdated: false,
+        });
+    });
+    return allDeps;
+}
+/**
+ * Store dependencies in database
+ */
+async function storeDependencies(packageName, dependencies) {
+    console.log('💾 Storing Dependencies for:' + packageName);
+    // Create or update dependencies
+    for (const dep of dependencies) {
+        try {
+            await prisma.dependencyInfo.upsert({
+                where: {
+                    name_packageName: {
+                        // This refers to the composite unique constraint
+                        name: dep.name,
+                        packageName,
+                    },
+                },
+                update: {
+                    version: dep.version,
+                    type: dep.type,
+                    latest: dep.latest,
+                    outdated: dep.outdated,
+                },
+                create: {
+                    name: dep.name,
+                    version: dep.version,
+                    type: dep.type,
+                    latest: dep.latest,
+                    outdated: dep.outdated,
+                    packageName: packageName,
+                },
+            });
+        }
+        catch (e) {
+            const err = e;
+            if (err instanceof Prisma.PrismaClientKnownRequestError &&
+                err.code === 'P2002') {
+                // Handle unique constraint violation (e.g., depedency already exists)
+                console.warn(`Skipping dependency: ${dep.name} (Depenndency already exists)`);
+            }
+            else {
+                // Handle any other unexpected errors
+                console.error(`Failed to store dependency: ${dep.name}`, err);
+            }
+        }
+    }
+}