@bluefly/openstandardagents 0.4.6 → 0.4.9

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

package/dist/services/release-automation/merge-request.service.js

@@ -0,0 +1,212 @@
+/**
+ * Merge Request CRUD Service
+ * Implements full CRUD operations for merge requests
+ */
+import { Gitlab } from '@gitbeaker/rest';
+import { MergeRequestSchema, CreateMergeRequestRequestSchema, UpdateMergeRequestRequestSchema, } from './schemas/release.schema.js';
+import { BaseCrudService } from './base-crud.service.js';
+import { z } from 'zod';
+/**
+ * Merge Request Filter Input
+ */
+const MergeRequestFilterSchema = z.object({
+    state: z.enum(['opened', 'closed', 'merged', 'locked']).optional(),
+    page: z.number().int().positive().default(1),
+    perPage: z.number().int().positive().min(1).max(100).default(20),
+});
+/**
+ * Merge Request Service - CRUD operations
+ */
+export class MergeRequestService extends BaseCrudService {
+    createSchema = CreateMergeRequestRequestSchema;
+    updateSchema = UpdateMergeRequestRequestSchema;
+    filterSchema = MergeRequestFilterSchema;
+    entitySchema = MergeRequestSchema;
+    gitlab;
+    projectId;
+    constructor(gitlabToken, projectId = process.env.CI_PROJECT_ID || '') {
+        super();
+        this.gitlab = new Gitlab({ token: gitlabToken });
+        this.projectId = projectId;
+    }
+    /**
+     * Create a new merge request
+     */
+    async create(input) {
+        try {
+            const validated = this.validateCreate(input);
+            const mr = await this.gitlab.MergeRequests.create(this.projectId, validated.sourceBranch, validated.targetBranch, validated.title, {
+                description: validated.description,
+                labels: validated.labels.join(','),
+                milestoneId: validated.milestoneId,
+            });
+            const approvals = await this.getApprovals(mr.iid);
+            const result = {
+                id: mr.iid,
+                title: String(mr.title),
+                description: String(mr.description || ''),
+                sourceBranch: String(mr.sourceBranch),
+                targetBranch: String(mr.targetBranch),
+                state: mr.state,
+                mergeStatus: mr.mergeStatus,
+                createdAt: String(mr.createdAt),
+                updatedAt: String(mr.updatedAt),
+                mergedAt: mr.mergedAt ? String(mr.mergedAt) : null,
+                labels: Array.isArray(mr.labels)
+                    ? mr.labels.map((l) => typeof l === 'string' ? l : String(l))
+                    : [],
+                approvals,
+            };
+            return this.validateEntity(result);
+        }
+        catch (error) {
+            this.handleValidationError(error);
+            throw error;
+        }
+    }
+    /**
+     * Read merge request by ID
+     */
+    async read(id) {
+        this.validateId(id);
+        try {
+            const mr = await this.gitlab.MergeRequests.show(this.projectId, Number(id));
+            const approvals = await this.getApprovals(mr.iid);
+            const result = {
+                id: mr.iid,
+                title: String(mr.title),
+                description: String(mr.description || ''),
+                sourceBranch: String(mr.sourceBranch),
+                targetBranch: String(mr.targetBranch),
+                state: mr.state,
+                mergeStatus: mr.mergeStatus,
+                createdAt: String(mr.createdAt),
+                updatedAt: String(mr.updatedAt),
+                mergedAt: mr.mergedAt ? String(mr.mergedAt) : null,
+                labels: Array.isArray(mr.labels)
+                    ? mr.labels.map((l) => typeof l === 'string' ? l : String(l))
+                    : [],
+                approvals,
+            };
+            return this.validateEntity(result);
+        }
+        catch (error) {
+            if (error &&
+                typeof error === 'object' &&
+                'response' in error &&
+                error.response.status === 404) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Update merge request
+     */
+    async update(id, input) {
+        this.validateId(id);
+        const validated = this.validateUpdate(input);
+        const existing = await this.read(id);
+        if (!existing) {
+            this.throwNotFound('MergeRequest', id);
+        }
+        const updated = await this.gitlab.MergeRequests.edit(this.projectId, Number(id), {
+            title: validated.title,
+            description: validated.description,
+            stateEvent: validated.state,
+            labels: validated.labels?.join(','),
+        });
+        const approvals = await this.getApprovals(updated.iid);
+        const result = {
+            id: updated.iid,
+            title: String(updated.title),
+            description: String(updated.description || ''),
+            sourceBranch: String(updated.sourceBranch),
+            targetBranch: String(updated.targetBranch),
+            state: updated.state,
+            mergeStatus: updated.mergeStatus,
+            createdAt: String(updated.createdAt),
+            updatedAt: String(updated.updatedAt),
+            mergedAt: updated.mergedAt ? String(updated.mergedAt) : null,
+            labels: Array.isArray(updated.labels)
+                ? updated.labels.map((l) => typeof l === 'string' ? l : String(l))
+                : [],
+            approvals,
+        };
+        return this.validateEntity(result);
+    }
+    /**
+     * Delete merge request
+     */
+    async delete(id) {
+        this.validateId(id);
+        const existing = await this.read(id);
+        if (!existing) {
+            this.throwNotFound('MergeRequest', id);
+        }
+        await this.gitlab.MergeRequests.remove(this.projectId, Number(id));
+    }
+    /**
+     * List merge requests with filtering and pagination
+     */
+    async list(filters) {
+        const validatedFilters = this.validateFilter(filters || {});
+        try {
+            const mrs = await this.gitlab.MergeRequests.all({
+                projectId: this.projectId,
+                state: validatedFilters.state,
+                perPage: validatedFilters.perPage,
+                page: validatedFilters.page,
+            });
+            const items = await Promise.all(mrs.map(async (mr) => {
+                const approvals = await this.getApprovals(mr.iid);
+                return this.validateEntity({
+                    id: mr.iid,
+                    title: String(mr.title),
+                    description: String(mr.description || ''),
+                    sourceBranch: String(mr.sourceBranch),
+                    targetBranch: String(mr.targetBranch),
+                    state: mr.state,
+                    mergeStatus: mr.mergeStatus,
+                    createdAt: String(mr.createdAt),
+                    updatedAt: String(mr.updatedAt),
+                    mergedAt: mr.mergedAt ? String(mr.mergedAt) : null,
+                    labels: Array.isArray(mr.labels)
+                        ? mr.labels.map((l) => typeof l === 'string' ? l : String(l))
+                        : [],
+                    approvals,
+                });
+            }));
+            // Note: GitLab API doesn't always return total
+            const total = items.length >= validatedFilters.perPage
+                ? items.length + validatedFilters.perPage
+                : items.length;
+            return {
+                items,
+                pagination: this.calculatePagination(total, validatedFilters.page, validatedFilters.perPage),
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to list merge requests: ${error}`);
+        }
+    }
+    /**
+     * Helper: Get merge request approvals
+     */
+    async getApprovals(mrId) {
+        try {
+            const mr = await this.gitlab.MergeRequests.show(this.projectId, mrId);
+            // GitLab API may include approval info in MR object
+            const approvalsRequired = mr.approvalsRequired || 0;
+            const approvalsLeft = mr.approvalsLeft || 0;
+            return {
+                required: approvalsRequired,
+                received: approvalsRequired - approvalsLeft,
+            };
+        }
+        catch {
+            return { required: 0, received: 0 };
+        }
+    }
+}
+//# sourceMappingURL=merge-request.service.js.map

package/dist/services/release-automation/milestone.service.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Milestone CRUD Service
+ * Implements full CRUD operations for milestones
+ */
+import { type Milestone, type CreateMilestoneRequest, type UpdateMilestoneRequest } from './schemas/release.schema.js';
+import { BaseCrudService } from './base-crud.service.js';
+import { z } from 'zod';
+/**
+ * Milestone Filter Input
+ */
+declare const MilestoneFilterSchema: z.ZodObject<{
+    state: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        closed: "closed";
+    }>>;
+    page: z.ZodDefault<z.ZodNumber>;
+    perPage: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type MilestoneFilter = z.infer<typeof MilestoneFilterSchema>;
+/**
+ * Milestone Service - CRUD operations
+ */
+export declare class MilestoneService extends BaseCrudService<Milestone, CreateMilestoneRequest, UpdateMilestoneRequest, MilestoneFilter> {
+    protected createSchema: z.ZodObject<{
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        dueDate: z.ZodOptional<z.ZodString>;
+        startDate: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    protected updateSchema: z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        state: z.ZodOptional<z.ZodEnum<{
+            active: "active";
+            closed: "closed";
+        }>>;
+        dueDate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        startDate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+    protected filterSchema: z.ZodObject<{
+        state: z.ZodOptional<z.ZodEnum<{
+            active: "active";
+            closed: "closed";
+        }>>;
+        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>;
+        state: z.ZodEnum<{
+            active: "active";
+            closed: "closed";
+        }>;
+        dueDate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        startDate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        statistics: z.ZodDefault<z.ZodObject<{
+            totalIssues: z.ZodDefault<z.ZodNumber>;
+            closedIssues: z.ZodDefault<z.ZodNumber>;
+            openIssues: z.ZodDefault<z.ZodNumber>;
+            completionPercentage: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    private gitlab;
+    private projectId;
+    constructor(gitlabToken: string, projectId?: string | number);
+    /**
+     * Create a new milestone
+     */
+    create(input: CreateMilestoneRequest): Promise<Milestone>;
+    /**
+     * Read milestone by ID
+     */
+    read(id: string | number): Promise<Milestone | null>;
+    /**
+     * Update milestone
+     */
+    update(id: string | number, input: UpdateMilestoneRequest): Promise<Milestone>;
+    /**
+     * Delete milestone
+     */
+    delete(id: string | number): Promise<void>;
+    /**
+     * List milestones with filtering and pagination
+     */
+    list(filters?: MilestoneFilter): Promise<{
+        items: Milestone[];
+        pagination: {
+            page: number;
+            perPage: number;
+            total: number;
+            totalPages: number;
+        };
+    }>;
+    /**
+     * Helper: Get milestone statistics
+     */
+    private getMilestoneStatistics;
+}
+export {};
+//# sourceMappingURL=milestone.service.d.ts.map