@manojkmfsi/monodog 1.1.44 → 1.1.48

package/dist/routes/release-api.js

@@ -0,0 +1,353 @@
+"use strict";
+/**
+ * Release API Routes
+ * HTTP endpoints for the independent release system
+ * Exposes change detection, readiness checks, and publishing operations
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const publish_controller_1 = require("../services/publish-controller");
+const release_readiness_service_1 = require("../services/release-readiness-service");
+const change_tracker_service_1 = require("../services/change-tracker-service");
+const npm_publish_service_1 = require("../services/npm-publish-service");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const router = (0, express_1.Router)();
+/**
+ * GET /api/releases/packages
+ * Get list of packages available in workspace
+ */
+router.get('/packages', async (req, res) => {
+    try {
+        const packages = publish_controller_1.publishController.getAvailablePackages(process.cwd());
+        res.json({
+            success: true,
+            packages,
+            count: packages.length,
+        });
+    }
+    catch (error) {
+        res.status(500).json({
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        });
+    }
+});
+/**
+ * POST /api/releases/analyze
+ * Analyze changes for packages without publishing
+ */
+router.post('/analyze', async (req, res) => {
+    try {
+        const { packageNames, packagePaths } = req.body;
+        if (!packageNames || !packagePaths) {
+            return res.status(400).json({
+                success: false,
+                error: 'Missing packageNames or packagePaths',
+            });
+        }
+        const analysis = {};
+        for (const packageName of packageNames) {
+            try {
+                const packagePath = packagePaths[packageName];
+                const currentVersion = getCurrentVersion(packageName, packagePath);
+                const changes = await change_tracker_service_1.changeTrackerService.analyzeChanges(packageName, packagePath, currentVersion, '');
+                analysis[packageName] = changes;
+            }
+            catch (error) {
+                analysis[packageName] = {
+                    error: error instanceof Error ? error.message : 'Analysis failed',
+                };
+            }
+        }
+        res.json({
+            success: true,
+            analysis,
+        });
+    }
+    catch (error) {
+        res.status(500).json({
+            success: false,
+            error: error instanceof Error ? error.message : 'Analysis failed',
+        });
+    }
+});
+/**
+ * POST /api/releases/check-readiness
+ * Check if packages are ready for publishing
+ */
+router.post('/check-readiness', async (req, res) => {
+    try {
+        const { packageNames, packagePaths } = req.body;
+        if (!packageNames || !packagePaths) {
+            return res.status(400).json({
+                success: false,
+                error: 'Missing packageNames or packagePaths',
+            });
+        }
+        const packages = packageNames.map((name) => ({
+            name,
+            path: packagePaths[name],
+            currentVersion: getCurrentVersion(name, packagePaths[name]),
+        }));
+        const readiness = await release_readiness_service_1.releaseReadinessService.checkReleaseReadiness(packages);
+        res.json({
+            success: true,
+            canProceed: readiness.canProceed,
+            summary: readiness.summary,
+            checks: readiness.allChecks,
+            globalBlockers: readiness.globalBlockers,
+        });
+    }
+    catch (error) {
+        res.status(500).json({
+            success: false,
+            error: error instanceof Error ? error.message : 'Readiness check failed',
+        });
+    }
+});
+/**
+ * POST /api/releases/prepare
+ * Prepare packages for publishing (validate and analyze)
+ */
+router.post('/prepare', async (req, res) => {
+    try {
+        const { packageNames, packagePaths, dryRun = false } = req.body;
+        if (!packageNames || !packagePaths) {
+            return res.status(400).json({
+                success: false,
+                error: 'Missing packageNames or packagePaths',
+            });
+        }
+        const result = await publish_controller_1.publishController.preparePublish({
+            packageNames,
+            packagePaths,
+            dryRun,
+        });
+        res.json({
+            success: result.valid,
+            canProceed: result.valid,
+            readiness: result.readiness,
+            analysis: result.analysis,
+        });
+    }
+    catch (error) {
+        res.status(500).json({
+            success: false,
+            error: error instanceof Error ? error.message : 'Preparation failed',
+        });
+    }
+});
+/**
+ * GET /api/releases/status/:pipelineId
+ * Get status of a publish pipeline
+ */
+router.get('/status/:pipelineId', async (req, res) => {
+    try {
+        const { pipelineId } = req.params;
+        const status = publish_controller_1.publishController.getPipelineStatus(pipelineId);
+        if (!status) {
+            return res.status(404).json({
+                success: false,
+                error: `Pipeline not found: ${pipelineId}`,
+            });
+        }
+        res.json({
+            success: true,
+            pipeline: status,
+        });
+    }
+    catch (error) {
+        res.status(500).json({
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to get status',
+        });
+    }
+});
+/**
+ * GET /api/releases/details/:pipelineId
+ * Get detailed information about a pipeline
+ */
+router.get('/details/:pipelineId', async (req, res) => {
+    try {
+        const { pipelineId } = req.params;
+        const details = await publish_controller_1.publishController.getPipelineDetails(pipelineId);
+        res.json({
+            success: true,
+            details,
+        });
+    }
+    catch (error) {
+        res.status(404).json({
+            success: false,
+            error: error instanceof Error ? error.message : 'Pipeline not found',
+        });
+    }
+});
+/**
+ * GET /api/releases/pipelines
+ * Get all pipelines (with optional filtering)
+ */
+router.get('/pipelines', async (req, res) => {
+    try {
+        const { status, limit = 50 } = req.query;
+        let pipelines = publish_controller_1.publishController.getAllPipelines();
+        if (status) {
+            pipelines = pipelines.filter(p => p.status === status);
+        }
+        pipelines = pipelines.slice(0, Number(limit));
+        res.json({
+            success: true,
+            pipelines,
+            count: pipelines.length,
+        });
+    }
+    catch (error) {
+        res.status(500).json({
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to list pipelines',
+        });
+    }
+});
+/**
+ * POST /api/releases/start
+ * Start a new publish pipeline
+ */
+router.post('/start', async (req, res) => {
+    try {
+        const { packageNames, packagePaths, versionMap, method = 'auto', dryRun = false, autoTag = true, createReleases = false, } = req.body;
+        if (!packageNames || !packagePaths) {
+            return res.status(400).json({
+                success: false,
+                error: 'Missing packageNames or packagePaths',
+            });
+        }
+        console.info(`📦 Starting publish pipeline for: ${packageNames.join(', ')}`);
+        const pipeline = await publish_controller_1.publishController.publish({
+            packageNames,
+            packagePaths,
+            versionMap,
+            method,
+            dryRun,
+            autoTag,
+            createReleases,
+        });
+        res.status(201).json({
+            success: pipeline.status !== 'failed',
+            pipeline,
+            pipelineId: pipeline.pipelineId,
+        });
+    }
+    catch (error) {
+        res.status(500).json({
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to start publish',
+        });
+    }
+});
+/**
+ * POST /api/releases/cancel/:pipelineId
+ * Cancel a publishing pipeline
+ */
+router.post('/cancel/:pipelineId', async (req, res) => {
+    try {
+        const { pipelineId } = req.params;
+        await publish_controller_1.publishController.cancelPipeline(pipelineId);
+        res.json({
+            success: true,
+            message: `Pipeline ${pipelineId} cancelled`,
+        });
+    }
+    catch (error) {
+        res.status(400).json({
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to cancel pipeline',
+        });
+    }
+});
+/**
+ * GET /api/releases/npm/:packageName/versions
+ * Get published versions for a package
+ */
+router.get('/npm/:packageName/versions', async (req, res) => {
+    try {
+        const { packageName } = req.params;
+        const versions = await npm_publish_service_1.npmPublishService.getPublishedVersions(packageName);
+        res.json({
+            success: true,
+            packageName,
+            versions,
+            count: versions.length,
+            latest: versions[0] || null,
+        });
+    }
+    catch (error) {
+        res.status(500).json({
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to get versions',
+        });
+    }
+});
+/**
+ * GET /api/releases/npm/:packageName/:version/available
+ * Check if a version is available on npm
+ */
+router.get('/npm/:packageName/:version/available', async (req, res) => {
+    try {
+        const { packageName, version } = req.params;
+        const available = await npm_publish_service_1.npmPublishService.isVersionAvailable(packageName, version);
+        res.json({
+            success: true,
+            packageName,
+            version,
+            available,
+        });
+    }
+    catch (error) {
+        res.status(500).json({
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to check version',
+        });
+    }
+});
+/**
+ * GET /api/releases/health
+ * Health check for release system
+ */
+router.get('/health', async (req, res) => {
+    try {
+        const pipelines = publish_controller_1.publishController.getAllPipelines();
+        const activePipelines = pipelines.filter(p => p.status === 'publishing' || p.status === 'validating');
+        res.json({
+            success: true,
+            status: 'healthy',
+            activePipelines: activePipelines.length,
+            totalPipelines: pipelines.length,
+            timestamp: new Date().toISOString(),
+        });
+    }
+    catch (error) {
+        res.status(500).json({
+            success: false,
+            error: 'Release system health check failed',
+        });
+    }
+});
+/**
+ * Helper function to get current version
+ */
+function getCurrentVersion(packageName, packagePath) {
+    try {
+        const pkgJsonPath = path_1.default.join(packagePath, 'package.json');
+        const content = fs_1.default.readFileSync(pkgJsonPath, 'utf8');
+        const pkgJson = JSON.parse(content);
+        return pkgJson.version || '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+exports.default = router;

package/dist/services/change-tracker-service.js

@@ -0,0 +1,227 @@
+"use strict";
+/**
+ * Change Tracker Service
+ * Detects changes in packages using Conventional Commits and Git diffs
+ * Replaces dependency on .changeset/*.md files
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.changeTrackerService = exports.ChangeTrackerService = void 0;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+// NOTE: ChangeTrack and CommitChange types will be imported from @prisma/client after DB integration
+// Currently using inline types below for service implementation
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+class ChangeTrackerService {
+    /**
+     * Analyze changes for a package since last release
+     */
+    async analyzeChanges(packageName, packagePath, currentVersion, lastTagName = `${packageName}@${currentVersion}`) {
+        try {
+            // 1. Get commits since last tag
+            const commits = await this.getCommitsSinceTag(lastTagName, packagePath);
+            // 2. Get file diffs
+            const filesChanged = await this.getFileDiffsSinceTag(lastTagName, packagePath);
+            // 3. Determine change type from commits
+            const changeType = this.determineChangeType(commits);
+            // 4. Identify affected dependents
+            const affectedDependents = await this.identifyAffectedDependents(packageName);
+            return {
+                packageName,
+                currentVersion,
+                changeType,
+                commits,
+                filesChanged,
+                affectedDependents,
+                proposedVersion: this.calculateNextVersion(currentVersion, changeType),
+                isReleaseReady: changeType !== 'none',
+            };
+        }
+        catch (error) {
+            console.error(`Failed to analyze changes for ${packageName}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Parse commit message using Conventional Commits format
+     * https://www.conventionalcommits.org/
+     *
+     * Format: type(scope)!: subject
+     * BREAKING CHANGE: description
+     */
+    parseConventionalCommit(message, body) {
+        const conventionalRegex = /^(feat|fix|docs|style|refactor|test|chore|perf|ci|revert|build)(\(.+\))?(!)?:\s(.+)/;
+        const match = message.match(conventionalRegex);
+        if (!match) {
+            return {
+                type: 'chore',
+                scope: undefined,
+                isBreaking: false,
+            };
+        }
+        const [, type, scopeMatch, breakingIndicator, subject] = match;
+        const scope = scopeMatch ? scopeMatch.slice(1, -1) : undefined;
+        // Check for BREAKING CHANGE keyword in body
+        const isBreaking = !!breakingIndicator || (body ? /^BREAKING[\s-]CHANGE:/m.test(body) : false);
+        return {
+            type: type,
+            scope,
+            isBreaking,
+        };
+    }
+    /**
+     * Get commits since last tag
+     */
+    async getCommitsSinceTag(tagName, packagePath) {
+        try {
+            // Get commits since tag, limited to this package path
+            const { stdout } = await execAsync(`cd ${packagePath} && git log ${tagName}..HEAD --format='%H|||%ae|||%an|||%ai|||%s|||%b' --`, { shell: '/bin/bash' });
+            if (!stdout.trim()) {
+                return [];
+            }
+            const commits = stdout
+                .split('\n')
+                .filter(line => line.trim())
+                .map(line => {
+                const [hash, email, author, timestamp, subject, body] = line.split('|||');
+                const parsed = this.parseConventionalCommit(subject, body);
+                return {
+                    hash,
+                    message: subject,
+                    author: author || email,
+                    authorEmail: email,
+                    committedAt: new Date(timestamp),
+                    type: parsed.type,
+                    scope: parsed.scope,
+                    isBreaking: parsed.isBreaking,
+                    body: body?.trim() || undefined,
+                };
+            });
+            return commits;
+        }
+        catch (error) {
+            // If tag doesn't exist, get all commits (first release)
+            console.warn(`Tag ${tagName} not found, analyzing all commits`);
+            return this.getAllCommits(packagePath);
+        }
+    }
+    /**
+     * Get all commits for a package
+     */
+    async getAllCommits(packagePath) {
+        try {
+            const { stdout } = await execAsync(`cd ${packagePath} && git log --format='%H|||%ae|||%an|||%ai|||%s|||%b' --`, { shell: '/bin/bash' });
+            if (!stdout.trim()) {
+                return [];
+            }
+            return stdout
+                .split('\n')
+                .filter(line => line.trim())
+                .map(line => {
+                const [hash, email, author, timestamp, subject, body] = line.split('|||');
+                const parsed = this.parseConventionalCommit(subject, body);
+                return {
+                    hash,
+                    message: subject,
+                    author: author || email,
+                    authorEmail: email,
+                    committedAt: new Date(timestamp),
+                    type: parsed.type,
+                    scope: parsed.scope,
+                    isBreaking: parsed.isBreaking,
+                    body: body?.trim() || undefined,
+                };
+            });
+        }
+        catch (error) {
+            console.error(`Failed to get commits for ${packagePath}:`, error);
+            return [];
+        }
+    }
+    /**
+     * Get file diffs since last tag
+     */
+    async getFileDiffsSinceTag(tagName, packagePath) {
+        try {
+            // Get file stats in diff format
+            const { stdout } = await execAsync(`cd ${packagePath} && git diff --no-renames --numstat ${tagName}..HEAD --`, { shell: '/bin/bash' });
+            if (!stdout.trim()) {
+                return [];
+            }
+            return stdout
+                .split('\n')
+                .filter(line => line.trim())
+                .map(line => {
+                const [added, removed, filePath] = line.split('\t');
+                return {
+                    path: filePath,
+                    added: false,
+                    removed: false,
+                    modified: true,
+                    linesAdded: parseInt(added) || 0,
+                    linesRemoved: parseInt(removed) || 0,
+                };
+            });
+        }
+        catch (error) {
+            console.warn(`Failed to get diffs for ${packagePath}:`, error);
+            return [];
+        }
+    }
+    /**
+     * Determine change type based on commits
+     * Rules:
+     * - BREAKING CHANGE or ! → major
+     * - feat: → minor
+     * - fix:, refactor:, etc → patch
+     * - docs:, chore:, etc → none
+     */
+    determineChangeType(commits) {
+        if (commits.length === 0) {
+            return 'none';
+        }
+        // Check for breaking changes first
+        if (commits.some(c => c.isBreaking)) {
+            return 'major';
+        }
+        // Check for features
+        if (commits.some(c => c.type === 'feat')) {
+            return 'minor';
+        }
+        // Check for fixes and other meaningful changes
+        if (commits.some(c => ['fix', 'refactor', 'perf'].includes(c.type))) {
+            return 'patch';
+        }
+        // Everything else (docs, chore, style, test, etc) doesn't warrant a release
+        return 'none';
+    }
+    /**
+     * Calculate next semantic version
+     */
+    calculateNextVersion(currentVersion, changeType) {
+        if (changeType === 'none') {
+            return currentVersion;
+        }
+        const parts = currentVersion.split('.');
+        const [major, minor, patch] = parts.map(p => parseInt(p));
+        switch (changeType) {
+            case 'major':
+                return `${major + 1}.0.0`;
+            case 'minor':
+                return `${major}.${minor + 1}.0`;
+            case 'patch':
+                return `${major}.${minor}.${patch + 1}`;
+            default:
+                return currentVersion;
+        }
+    }
+    /**
+     * Identify packages that depend on this package
+     */
+    async identifyAffectedDependents(packageName) {
+        // TODO: Implement dependency graph analysis
+        // For now, return empty array - can be enhanced with dependency resolver
+        return [];
+    }
+}
+exports.ChangeTrackerService = ChangeTrackerService;
+exports.changeTrackerService = new ChangeTrackerService();