@bluefly/openstandardagents 0.4.6 → 0.4.8

package/dist/services/release-automation/base-crud.service.js

@@ -0,0 +1,68 @@
+/**
+ * Base CRUD Service
+ * DRY: Reusable CRUD operations for all release automation entities
+ */
+import { z } from 'zod';
+/**
+ * Base CRUD Service Implementation
+ * DRY: Provides common CRUD operations
+ */
+export class BaseCrudService {
+    /**
+     * Validate and parse input using Zod
+     */
+    validateCreate(input) {
+        return this.createSchema.parse(input);
+    }
+    validateUpdate(input) {
+        return this.updateSchema.parse(input);
+    }
+    validateFilter(input) {
+        return this.filterSchema.parse(input || {});
+    }
+    validateEntity(entity) {
+        return this.entitySchema.parse(entity);
+    }
+    /**
+     * Helper: Calculate pagination metadata
+     */
+    calculatePagination(total, page, perPage) {
+        return {
+            page,
+            perPage,
+            total,
+            totalPages: Math.ceil(total / perPage),
+        };
+    }
+    /**
+     * Helper: Validate ID format
+     */
+    validateId(id) {
+        if (typeof id === 'string' && id.length === 0) {
+            throw new Error('ID cannot be empty');
+        }
+        if (typeof id === 'number' && id <= 0) {
+            throw new Error('ID must be positive');
+        }
+    }
+    /**
+     * Helper: Handle not found errors
+     */
+    throwNotFound(resource, id) {
+        throw new Error(`${resource} with ID ${id} not found`);
+    }
+    /**
+     * Helper: Handle validation errors
+     */
+    handleValidationError(error) {
+        if (error instanceof z.ZodError) {
+            const details = error.issues.map((e) => ({
+                path: e.path.join('.'),
+                message: e.message,
+            }));
+            throw new Error(`Validation failed: ${details.map((d) => d.message).join(', ')}`);
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=base-crud.service.js.map

package/dist/services/release-automation/generate-changelog.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env tsx
+/**
+ * Automated Changelog Generator from Milestone Issues
+ * Generates changelog from closed issues in a milestone
+ */
+export {};
+//# sourceMappingURL=generate-changelog.d.ts.map

package/dist/services/release-automation/generate-changelog.js

@@ -0,0 +1,288 @@
+#!/usr/bin/env tsx
+/**
+ * Automated Changelog Generator from Milestone Issues
+ * Generates changelog from closed issues in a milestone
+ */
+import { Gitlab } from '@gitbeaker/rest';
+import { writeFileSync } from 'fs';
+import { execSync } from 'child_process';
+// CI_SERVER_HOST is just 'gitlab.com' without protocol - ensure we have the full URL
+const gitlabHost = process.env.CI_SERVER_HOST
+    ? process.env.CI_SERVER_HOST.startsWith('http')
+        ? process.env.CI_SERVER_HOST
+        : `https://${process.env.CI_SERVER_HOST}`
+    : 'https://gitlab.com';
+const gitlab = new Gitlab({
+    host: gitlabHost,
+    token: process.env.GITLAB_PUSH_TOKEN || process.env.CI_JOB_TOKEN,
+});
+const projectId = process.env.CI_PROJECT_ID;
+/**
+ * Categorize issues by type based on labels and title
+ */
+function categorizeIssue(issue) {
+    const title = issue.title.toLowerCase();
+    const labels = issue.labels.map((l) => l.toLowerCase());
+    // Check labels first
+    if (labels.some((l) => l.includes('breaking')))
+        return 'breaking';
+    if (labels.some((l) => l.includes('feature') || l.includes('enhancement')))
+        return 'features';
+    if (labels.some((l) => l.includes('bug') || l.includes('fix')))
+        return 'fixes';
+    if (labels.some((l) => l.includes('security')))
+        return 'security';
+    if (labels.some((l) => l.includes('performance')))
+        return 'performance';
+    if (labels.some((l) => l.includes('documentation') || l.includes('docs')))
+        return 'documentation';
+    if (labels.some((l) => l.includes('deprecation')))
+        return 'deprecations';
+    // Check title patterns
+    if (title.startsWith('feat:') || title.startsWith('feature:'))
+        return 'features';
+    if (title.startsWith('fix:'))
+        return 'fixes';
+    if (title.startsWith('docs:'))
+        return 'documentation';
+    if (title.startsWith('perf:'))
+        return 'performance';
+    if (title.startsWith('security:'))
+        return 'security';
+    return 'other';
+}
+/**
+ * Generate emoji for category
+ */
+function getCategoryEmoji(category) {
+    const emojiMap = {
+        breaking: '💥',
+        features: '✨',
+        fixes: '🐛',
+        security: '🔒',
+        performance: '⚡',
+        documentation: '📚',
+        deprecations: '⚠️',
+        other: '🔧',
+    };
+    return emojiMap[category] || '🔧';
+}
+/**
+ * Get category title
+ */
+function getCategoryTitle(category) {
+    const titleMap = {
+        breaking: 'Breaking Changes',
+        features: 'Features',
+        fixes: 'Bug Fixes',
+        security: 'Security',
+        performance: 'Performance',
+        documentation: 'Documentation',
+        deprecations: 'Deprecations',
+        other: 'Other Changes',
+    };
+    return titleMap[category] || 'Other Changes';
+}
+/**
+ * Fetch all issues for a milestone
+ */
+async function fetchMilestoneIssues(milestoneId) {
+    try {
+        const issues = (await gitlab.Issues.all({
+            projectId,
+            milestoneId: milestoneId.toString(),
+            state: 'closed',
+            perPage: 100,
+        }));
+        return issues.map((issue) => ({
+            iid: issue.iid,
+            title: issue.title,
+            labels: issue.labels || [],
+            web_url: issue.web_url,
+            author: issue.author,
+            closed_at: issue.closed_at,
+        }));
+    }
+    catch (error) {
+        console.error('Error fetching milestone issues:', error);
+        return [];
+    }
+}
+/**
+ * Fetch milestone data
+ */
+async function fetchMilestone(milestoneId) {
+    try {
+        const milestone = (await gitlab.ProjectMilestones.show(projectId, milestoneId));
+        return {
+            id: milestone.id,
+            title: milestone.title,
+            description: milestone.description || '',
+            state: milestone.state,
+            due_date: milestone.due_date,
+            web_url: milestone.web_url,
+        };
+    }
+    catch (error) {
+        console.error('Error fetching milestone:', error);
+        return null;
+    }
+}
+/**
+ * Generate changelog content
+ */
+function generateChangelog(milestone, issues, version) {
+    const releaseDate = new Date().toISOString().split('T')[0];
+    // Group issues by category
+    const categorized = {};
+    issues.forEach((issue) => {
+        const category = categorizeIssue(issue);
+        if (!categorized[category]) {
+            categorized[category] = [];
+        }
+        categorized[category].push(issue);
+    });
+    // Sort categories by importance
+    const categoryOrder = [
+        'breaking',
+        'security',
+        'features',
+        'fixes',
+        'performance',
+        'deprecations',
+        'documentation',
+        'other',
+    ];
+    let changelog = `# Changelog - v${version}\n\n`;
+    changelog += `**Release Date:** ${releaseDate}\n\n`;
+    changelog += `**Milestone:** [${milestone.title}](${milestone.web_url})\n\n`;
+    if (milestone.description) {
+        changelog += `## Overview\n\n${milestone.description}\n\n`;
+    }
+    changelog += `## What's Changed\n\n`;
+    // Generate sections for each category
+    categoryOrder.forEach((category) => {
+        if (categorized[category] && categorized[category].length > 0) {
+            const emoji = getCategoryEmoji(category);
+            const title = getCategoryTitle(category);
+            changelog += `### ${emoji} ${title}\n\n`;
+            categorized[category].forEach((issue) => {
+                const cleanTitle = issue.title
+                    .replace(/^(feat|fix|docs|perf|security|chore|refactor|test|build|ci):\s*/i, '')
+                    .trim();
+                changelog += `- ${cleanTitle} ([#${issue.iid}](${issue.web_url}))\n`;
+            });
+            changelog += `\n`;
+        }
+    });
+    // Add statistics
+    changelog += `## Statistics\n\n`;
+    changelog += `- **Total Issues Closed:** ${issues.length}\n`;
+    const contributors = new Set(issues.map((i) => i.author.username));
+    changelog += `- **Contributors:** ${contributors.size}\n`;
+    if (milestone.due_date) {
+        changelog += `- **Planned Release Date:** ${milestone.due_date}\n`;
+    }
+    changelog += `- **Actual Release Date:** ${releaseDate}\n\n`;
+    // Add contributors list
+    if (contributors.size > 0) {
+        changelog += `## Contributors\n\n`;
+        changelog += `Thanks to all contributors who made this release possible:\n\n`;
+        Array.from(contributors)
+            .sort()
+            .forEach((username) => {
+            changelog += `- @${username}\n`;
+        });
+        changelog += `\n`;
+    }
+    // Add links
+    changelog += `## Links\n\n`;
+    changelog += `- [Milestone](${milestone.web_url})\n`;
+    changelog += `- [Full Changelog](https://gitlab.com/${process.env.CI_PROJECT_PATH}/-/compare/v${getPreviousVersion(version)}...v${version})\n`;
+    changelog += `- [npm Package](https://www.npmjs.com/package/@bluefly/openstandardagents/v/${version})\n`;
+    changelog += `- [Documentation](https://openstandardagents.org/)\n`;
+    return changelog;
+}
+/**
+ * Get previous version (simple implementation)
+ */
+function getPreviousVersion(version) {
+    try {
+        const tags = execSync('git tag --sort=-version:refname')
+            .toString()
+            .trim()
+            .split('\n')
+            .filter((tag) => tag.startsWith('v') && tag !== `v${version}`);
+        return tags[0] || '0.0.0';
+    }
+    catch (error) {
+        return '0.0.0';
+    }
+}
+/**
+ * Main execution
+ */
+async function main() {
+    const milestoneId = process.env.MILESTONE_ID || process.env.CI_MILESTONE_ID;
+    const version = process.env.RELEASE_VERSION || process.env.CI_COMMIT_TAG?.replace(/^v/, '');
+    const outputPath = process.env.CHANGELOG_OUTPUT || './RELEASE_NOTES.md';
+    if (!milestoneId) {
+        console.error('❌ ERROR: MILESTONE_ID not set');
+        process.exit(1);
+    }
+    if (!version) {
+        console.error('❌ ERROR: RELEASE_VERSION not set');
+        process.exit(1);
+    }
+    console.log('📝 Generating Changelog');
+    console.log('======================');
+    console.log(`Milestone ID: ${milestoneId}`);
+    console.log(`Version: v${version}`);
+    console.log('');
+    // Fetch milestone data
+    console.log('Fetching milestone data...');
+    const milestone = await fetchMilestone(parseInt(milestoneId));
+    if (!milestone) {
+        console.error('❌ ERROR: Failed to fetch milestone');
+        process.exit(1);
+    }
+    console.log(`Milestone: ${milestone.title}`);
+    console.log(`State: ${milestone.state}`);
+    console.log('');
+    // Fetch issues
+    console.log('Fetching closed issues...');
+    const issues = await fetchMilestoneIssues(parseInt(milestoneId));
+    console.log(`Found ${issues.length} closed issues`);
+    console.log('');
+    if (issues.length === 0) {
+        console.warn('⚠️  WARNING: No closed issues found in milestone');
+    }
+    // Generate changelog
+    console.log('Generating changelog...');
+    const changelog = generateChangelog(milestone, issues, version);
+    // Write to file
+    writeFileSync(outputPath, changelog, 'utf-8');
+    console.log(`✅ Changelog written to: ${outputPath}`);
+    console.log('');
+    console.log('Preview:');
+    console.log('--------');
+    console.log(changelog);
+    // Also export to environment
+    console.log('');
+    console.log('Exported environment variables:');
+    console.log(`CHANGELOG_PATH=${outputPath}`);
+    console.log(`ISSUE_COUNT=${issues.length}`);
+    console.log(`MILESTONE_TITLE=${milestone.title}`);
+    // Write dotenv file for GitLab CI
+    const envContent = `CHANGELOG_PATH=${outputPath}
+ISSUE_COUNT=${issues.length}
+MILESTONE_TITLE=${milestone.title}
+MILESTONE_URL=${milestone.web_url}
+`;
+    writeFileSync('changelog.env', envContent, 'utf-8');
+}
+main().catch((error) => {
+    console.error('❌ Changelog generation failed:', error);
+    process.exit(1);
+});
+//# sourceMappingURL=generate-changelog.js.map

package/dist/services/release-automation/increment-dev-tag.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+/**
+ * Auto-increment dev tag on successful merge to development
+ * Runs in CI after merge
+ */
+export {};
+//# sourceMappingURL=increment-dev-tag.d.ts.map

package/dist/services/release-automation/increment-dev-tag.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+/**
+ * Auto-increment dev tag on successful merge to development
+ * Runs in CI after merge
+ */
+import { Gitlab } from '@gitbeaker/rest';
+import { execSync } from 'child_process';
+const gitlab = new Gitlab({
+    token: process.env.GITLAB_TOKEN || process.env.CI_JOB_TOKEN,
+});
+async function incrementDevTag() {
+    const projectId = process.env.CI_PROJECT_ID;
+    const commitSha = process.env.CI_COMMIT_SHA;
+    const commitMessage = process.env.CI_COMMIT_MESSAGE || '';
+    const commitAuthor = process.env.GITLAB_USER_NAME || 'GitLab CI';
+    const pipelineUrl = process.env.CI_PIPELINE_URL || '';
+    // Get current milestone from package.json
+    const packageJson = JSON.parse(execSync('cat package.json').toString());
+    const version = packageJson.version; // e.g., "0.2.6-dev.5"
+    if (!version.includes('-dev.')) {
+        console.log('Not a dev version, skipping');
+        return;
+    }
+    // Extract base version and increment
+    const [baseVersion, devPart] = version.split('-dev.');
+    const currentNum = parseInt(devPart);
+    const nextNum = currentNum + 1;
+    const nextVersion = `${baseVersion}-dev.${nextNum}`;
+    const tagName = `v${nextVersion}`;
+    // Get commit details for rich tag description
+    const commitDate = new Date().toISOString();
+    const shortSha = commitSha.substring(0, 8);
+    // Get recent commits since last tag
+    let recentCommits = '';
+    try {
+        const lastTag = `v${baseVersion}-dev.${currentNum}`;
+        recentCommits = execSync(`git log ${lastTag}..HEAD --oneline --no-merges`)
+            .toString()
+            .trim();
+    }
+    catch {
+        recentCommits = execSync('git log -5 --oneline --no-merges')
+            .toString()
+            .trim();
+    }
+    // Create rich tag description
+    const tagDescription = `# Development Release ${tagName}
+
+**Auto-generated development tag** - ${commitDate}
+
+## 📦 Version Information
+- **Version**: ${nextVersion}
+- **Base Version**: ${baseVersion}
+- **Dev Iteration**: ${nextNum}
+- **Commit**: ${shortSha}
+- **Author**: ${commitAuthor}
+
+## 🔗 Links
+- **Pipeline**: ${pipelineUrl}
+- **Commit**: https://gitlab.com/blueflyio/openstandardagents/-/commit/${commitSha}
+
+## 📝 Recent Changes
+\`\`\`
+${recentCommits}
+\`\`\`
+
+## ⚠️ Development Release
+This is a development release and should not be used in production.
+- Not published to npm
+- May contain breaking changes
+- For testing and development only
+
+## 🚀 Next Steps
+When milestone is complete and closed:
+1. RC tag will be created automatically
+2. MR to main will be created
+3. After approval, production release will be triggered
+`;
+    // Create new tag (correct API signature: projectId, tagName, ref, options)
+    await gitlab.Tags.create(projectId, tagName, commitSha, {
+        message: tagDescription,
+    });
+    console.log(`✅ Created tag: ${tagName}`);
+    // Update package.json version
+    execSync(`npm version ${nextVersion} --no-git-tag-version`);
+    // Commit version bump
+    execSync('git config user.name "GitLab CI"');
+    execSync('git config user.email "ci@gitlab.com"');
+    execSync('git add package.json package-lock.json');
+    execSync(`git commit -m "chore: bump version to ${nextVersion} [skip ci]"`);
+    execSync('git push origin development');
+    console.log(`✅ Bumped version to: ${nextVersion}`);
+    // Check if milestone is complete and create MR if needed
+    await checkMilestoneAndCreateMR(projectId, baseVersion);
+}
+async function checkMilestoneAndCreateMR(projectId, version) {
+    try {
+        // Find milestone for this version
+        const milestones = await gitlab.ProjectMilestones.all(projectId, {
+            state: 'closed',
+            search: version,
+        });
+        if (milestones.length === 0) {
+            console.log('ℹ️  No closed milestone found, skipping MR creation');
+            return;
+        }
+        const milestone = milestones[0];
+        // Check if MR already exists
+        const existingMRs = await gitlab.MergeRequests.all({
+            projectId,
+            sourceBranch: 'development',
+            targetBranch: 'main',
+            state: 'opened',
+        });
+        if (existingMRs.length > 0) {
+            console.log('ℹ️  MR already exists, skipping');
+            return;
+        }
+        // Create MR to main
+        const mr = await gitlab.MergeRequests.create(projectId, 'development', 'main', `Release ${version}`, {
+            description: `## 🚀 Release ${version}
+
+**Milestone**: ${milestone.title}
+**Status**: Ready for Release
+
+### ✅ Pre-Release Checklist
+- [x] All milestone issues closed
+- [x] All tests passing
+- [x] Security scans passed
+- [x] Documentation updated
+- [x] Changelog updated
+
+### 📋 Approval Required
+- [ ] Technical Lead approval
+- [ ] Security Lead approval
+- [ ] Product Owner approval
+- [ ] Release Manager approval
+
+### 🎯 Release Actions (Manual Triggers)
+After all approvals, use pipeline buttons to:
+1. 🚀 Release to npm
+2. 🐙 Release to GitHub
+3. 🌐 Deploy Website
+4. 📢 Announce Release
+
+**DO NOT MERGE MANUALLY** - This MR will auto-merge after successful release.
+`,
+            removeSourceBranch: false,
+            squash: false,
+            labels: 'release,automation',
+            milestoneId: milestone.id,
+        });
+        console.log(`✅ Created MR: !${mr.iid} - ${mr.web_url}`);
+    }
+    catch (error) {
+        console.log('ℹ️  Could not create MR:', error);
+    }
+}
+incrementDevTag().catch(console.error);
+//# sourceMappingURL=increment-dev-tag.js.map

package/dist/services/release-automation/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Release Automation - Main Export
+ * CRUD, DRY, OpenAPI, Zod-based release automation system
+ */
+export * from './schemas/release.schema.js';
+export * from './base-crud.service.js';
+export * from './release.service.js';
+export * from './milestone.service.js';
+export * from './tag.service.js';
+export * from './merge-request.service.js';
+export * from './webhook.service.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/release-automation/index.js

@@ -0,0 +1,12 @@
+/**
+ * Release Automation - Main Export
+ * CRUD, DRY, OpenAPI, Zod-based release automation system
+ */
+export * from './schemas/release.schema.js';
+export * from './base-crud.service.js';
+export * from './release.service.js';
+export * from './milestone.service.js';
+export * from './tag.service.js';
+export * from './merge-request.service.js';
+export * from './webhook.service.js';
+//# sourceMappingURL=index.js.map

package/dist/services/release-automation/merge-request.service.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Merge Request CRUD Service
+ * Implements full CRUD operations for merge requests
+ */
+import { type MergeRequest, type CreateMergeRequestRequest, type UpdateMergeRequestRequest } from './schemas/release.schema.js';
+import { BaseCrudService } from './base-crud.service.js';
+import { z } from 'zod';
+/**
+ * Merge Request Filter Input
+ */
+declare const MergeRequestFilterSchema: z.ZodObject<{
+    state: z.ZodOptional<z.ZodEnum<{
+        closed: "closed";
+        opened: "opened";
+        merged: "merged";
+        locked: "locked";
+    }>>;
+    page: z.ZodDefault<z.ZodNumber>;
+    perPage: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type MergeRequestFilter = z.infer<typeof MergeRequestFilterSchema>;
+/**
+ * Merge Request Service - CRUD operations
+ */
+export declare class MergeRequestService extends BaseCrudService<MergeRequest, CreateMergeRequestRequest, UpdateMergeRequestRequest, MergeRequestFilter> {
+    protected createSchema: z.ZodObject<{
+        sourceBranch: z.ZodString;
+        targetBranch: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        labels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        milestoneId: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    protected updateSchema: z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        state: z.ZodOptional<z.ZodEnum<{
+            closed: "closed";
+            opened: "opened";
+            merged: "merged";
+            locked: "locked";
+        }>>;
+        labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    protected filterSchema: z.ZodObject<{
+        state: z.ZodOptional<z.ZodEnum<{
+            closed: "closed";
+            opened: "opened";
+            merged: "merged";
+            locked: "locked";
+        }>>;
+        page: z.ZodDefault<z.ZodNumber>;
+        perPage: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    protected entitySchema: z.ZodObject<{
+        id: z.ZodNumber;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        sourceBranch: z.ZodString;
+        targetBranch: z.ZodString;
+        state: z.ZodEnum<{
+            closed: "closed";
+            opened: "opened";
+            merged: "merged";
+            locked: "locked";
+        }>;
+        mergeStatus: z.ZodOptional<z.ZodEnum<{
+            can_be_merged: "can_be_merged";
+            cannot_be_merged: "cannot_be_merged";
+            checking: "checking";
+            unchecked: "unchecked";
+        }>>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        mergedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        labels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        approvals: z.ZodDefault<z.ZodObject<{
+            required: z.ZodDefault<z.ZodNumber>;
+            received: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    private gitlab;
+    private projectId;
+    constructor(gitlabToken: string, projectId?: string | number);
+    /**
+     * Create a new merge request
+     */
+    create(input: CreateMergeRequestRequest): Promise<MergeRequest>;
+    /**
+     * Read merge request by ID
+     */
+    read(id: string | number): Promise<MergeRequest | null>;
+    /**
+     * Update merge request
+     */
+    update(id: string | number, input: UpdateMergeRequestRequest): Promise<MergeRequest>;
+    /**
+     * Delete merge request
+     */
+    delete(id: string | number): Promise<void>;
+    /**
+     * List merge requests with filtering and pagination
+     */
+    list(filters?: MergeRequestFilter): Promise<{
+        items: MergeRequest[];
+        pagination: {
+            page: number;
+            perPage: number;
+            total: number;
+            totalPages: number;
+        };
+    }>;
+    /**
+     * Helper: Get merge request approvals
+     */
+    private getApprovals;
+}
+export {};
+//# sourceMappingURL=merge-request.service.d.ts.map