@bluefly/openstandardagents 0.4.6 → 0.4.9

package/dist/services/release-automation/schemas/release.schema.js

@@ -0,0 +1,272 @@
+/**
+ * Release Automation - Zod Schemas
+ * DRY: Reusable validation schemas for release entities
+ */
+import { z } from 'zod';
+/**
+ * Version pattern: v0.2.5, 0.2.5-RC, 0.2.5-dev.1, etc.
+ */
+const VersionPattern = z
+    .string()
+    .regex(/^v?[0-9]+\.[0-9]+\.[0-9]+(-[A-Za-z0-9]+(\.[0-9]+)?)?$/, {
+    message: 'Invalid version format. Expected: v0.2.5, 0.2.5-RC, 0.2.5-dev.1',
+});
+/**
+ * Tag name pattern: v0.2.5-RC, v0.2.5-dev.1, etc.
+ */
+const TagNamePattern = z
+    .string()
+    .regex(/^v?[0-9]+\.[0-9]+\.[0-9]+(-[a-z]+\.?[0-9]+)?$/, {
+    message: 'Invalid tag format. Expected: v0.2.5-RC, v0.2.5-dev.1',
+});
+/**
+ * Git commit SHA pattern
+ */
+const CommitShaPattern = z.string().regex(/^[0-9a-f]{40}$/, {
+    message: 'Invalid commit SHA. Must be 40 character hex string',
+});
+/**
+ * Release State
+ */
+export const ReleaseStateSchema = z.enum([
+    'draft',
+    'dev',
+    'rc',
+    'released',
+    'deprecated',
+]);
+/**
+ * Tag Type
+ */
+export const TagTypeSchema = z.enum(['dev', 'rc', 'release']);
+/**
+ * Milestone State
+ */
+export const MilestoneStateSchema = z.enum(['active', 'closed']);
+/**
+ * Merge Request State
+ */
+export const MergeRequestStateSchema = z.enum([
+    'opened',
+    'closed',
+    'merged',
+    'locked',
+]);
+/**
+ * Merge Status
+ */
+export const MergeStatusSchema = z.enum([
+    'can_be_merged',
+    'cannot_be_merged',
+    'checking',
+    'unchecked',
+]);
+/**
+ * Base Pagination Schema
+ */
+export const PaginationSchema = z.object({
+    page: z.number().int().positive().default(1),
+    perPage: z.number().int().positive().min(1).max(100).default(20),
+});
+/**
+ * Release Schema
+ */
+export const ReleaseSchema = z.object({
+    id: z.string(),
+    version: VersionPattern,
+    state: ReleaseStateSchema,
+    milestoneId: z.number().int().positive().optional(),
+    tags: z.array(z.string()).default([]),
+    mergeRequestId: z.number().int().positive().optional(),
+    createdAt: z.string().datetime(),
+    updatedAt: z.string().datetime(),
+    releasedAt: z.string().datetime().nullable().optional(),
+    metadata: z.record(z.string(), z.unknown()).default({}),
+});
+/**
+ * Create Release Request
+ */
+export const CreateReleaseRequestSchema = z.object({
+    version: VersionPattern,
+    milestoneId: z.number().int().positive().optional(),
+    metadata: z.record(z.string(), z.unknown()).default({}),
+});
+/**
+ * Update Release Request
+ */
+export const UpdateReleaseRequestSchema = z.object({
+    state: ReleaseStateSchema.optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+});
+/**
+ * Milestone Schema
+ */
+export const MilestoneSchema = z.object({
+    id: z.number().int().positive(),
+    title: z.string(),
+    description: z.string().optional(),
+    state: MilestoneStateSchema,
+    dueDate: z.string().nullable().optional(),
+    startDate: z.string().nullable().optional(),
+    createdAt: z.string().datetime(),
+    updatedAt: z.string().datetime(),
+    statistics: z
+        .object({
+        totalIssues: z.number().int().nonnegative().default(0),
+        closedIssues: z.number().int().nonnegative().default(0),
+        openIssues: z.number().int().nonnegative().default(0),
+        completionPercentage: z.number().min(0).max(100).default(0),
+    })
+        .default({
+        totalIssues: 0,
+        closedIssues: 0,
+        openIssues: 0,
+        completionPercentage: 0,
+    }),
+});
+/**
+ * Create Milestone Request
+ */
+export const CreateMilestoneRequestSchema = z.object({
+    title: z.string().regex(/^v?[0-9]+\.[0-9]+\.[0-9]+/, {
+        message: 'Milestone title must contain version (e.g., v0.3.0)',
+    }),
+    description: z.string().optional(),
+    dueDate: z.string().optional(),
+    startDate: z.string().optional(),
+});
+/**
+ * Update Milestone Request
+ */
+export const UpdateMilestoneRequestSchema = z.object({
+    title: z.string().optional(),
+    description: z.string().optional(),
+    state: MilestoneStateSchema.optional(),
+    dueDate: z.string().nullable().optional(),
+    startDate: z.string().nullable().optional(),
+});
+/**
+ * Tag Schema
+ */
+export const TagSchema = z.object({
+    name: TagNamePattern,
+    type: TagTypeSchema,
+    version: VersionPattern,
+    commitSha: CommitShaPattern,
+    message: z.string().optional(),
+    createdAt: z.string().datetime(),
+    ref: z.string(),
+});
+/**
+ * Create Tag Request
+ */
+export const CreateTagRequestSchema = z.object({
+    name: TagNamePattern,
+    ref: z.string(),
+    message: z.string().optional(),
+});
+/**
+ * Merge Request Schema
+ */
+export const MergeRequestSchema = z.object({
+    id: z.number().int().positive(),
+    title: z.string(),
+    description: z.string().optional(),
+    sourceBranch: z.string(),
+    targetBranch: z.string(),
+    state: MergeRequestStateSchema,
+    mergeStatus: MergeStatusSchema.optional(),
+    createdAt: z.string().datetime(),
+    updatedAt: z.string().datetime(),
+    mergedAt: z.string().datetime().nullable().optional(),
+    labels: z.array(z.string()).default([]),
+    approvals: z
+        .object({
+        required: z.number().int().nonnegative().default(0),
+        received: z.number().int().nonnegative().default(0),
+    })
+        .default({ required: 0, received: 0 }),
+});
+/**
+ * Create Merge Request Request
+ */
+export const CreateMergeRequestRequestSchema = z.object({
+    sourceBranch: z.string().min(1),
+    targetBranch: z.string().min(1),
+    title: z.string().min(1),
+    description: z.string().optional(),
+    labels: z.array(z.string()).default([]),
+    milestoneId: z.number().int().positive().optional(),
+});
+/**
+ * Update Merge Request Request
+ */
+export const UpdateMergeRequestRequestSchema = z.object({
+    title: z.string().optional(),
+    description: z.string().optional(),
+    state: MergeRequestStateSchema.optional(),
+    labels: z.array(z.string()).optional(),
+});
+/**
+ * Webhook Payloads
+ */
+export const MilestoneWebhookPayloadSchema = z.object({
+    object_kind: z.literal('milestone'),
+    project: z.object({
+        id: z.number().int().positive(),
+        path_with_namespace: z.string(),
+    }),
+    object_attributes: z.object({
+        id: z.number().int().positive(),
+        title: z.string(),
+        state: MilestoneStateSchema,
+        created_at: z.string(),
+        updated_at: z.string(),
+    }),
+});
+export const PushWebhookPayloadSchema = z.object({
+    object_kind: z.literal('push'),
+    project: z.object({
+        id: z.number().int().positive(),
+    }),
+    ref: z.string(),
+    commits: z.array(z.record(z.string(), z.unknown())).default([]),
+});
+/**
+ * Webhook Response
+ */
+export const WebhookResponseSchema = z.object({
+    success: z.boolean(),
+    message: z.string(),
+    actions: z
+        .array(z.object({
+        type: z.string(),
+        status: z.string(),
+        details: z.record(z.string(), z.unknown()).optional(),
+    }))
+        .default([])
+        .optional(),
+});
+/**
+ * Error Response
+ */
+export const ErrorResponseSchema = z
+    .object({
+    message: z.string(),
+    code: z.string().optional(),
+    details: z.record(z.string(), z.unknown()).optional(),
+})
+    .passthrough();
+/**
+ * List Response (with pagination)
+ */
+export function createListResponseSchema(itemSchema) {
+    return z.object({
+        items: z.array(itemSchema),
+        pagination: PaginationSchema.extend({
+            total: z.number().int().nonnegative(),
+            totalPages: z.number().int().nonnegative(),
+        }),
+    });
+}
+//# sourceMappingURL=release.schema.js.map

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

@@ -0,0 +1,99 @@
+/**
+ * Tag CRUD Service
+ * Implements full CRUD operations for Git tags
+ */
+import { type Tag, type CreateTagRequest } from './schemas/release.schema.js';
+import { BaseCrudService } from './base-crud.service.js';
+import { z } from 'zod';
+/**
+ * Tag Filter Input
+ */
+declare const TagFilterSchema: z.ZodObject<{
+    version: z.ZodOptional<z.ZodString>;
+    type: z.ZodDefault<z.ZodEnum<{
+        dev: "dev";
+        all: "all";
+        release: "release";
+        rc: "rc";
+    }>>;
+    page: z.ZodDefault<z.ZodNumber>;
+    perPage: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type TagFilter = z.infer<typeof TagFilterSchema>;
+/**
+ * Tag Service - CRUD operations
+ */
+export declare class TagService extends BaseCrudService<Tag, CreateTagRequest, never, // Tags are immutable - no update
+TagFilter> {
+    protected createSchema: z.ZodObject<{
+        name: z.ZodString;
+        ref: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    protected updateSchema: z.ZodNever;
+    protected filterSchema: z.ZodObject<{
+        version: z.ZodOptional<z.ZodString>;
+        type: z.ZodDefault<z.ZodEnum<{
+            dev: "dev";
+            all: "all";
+            release: "release";
+            rc: "rc";
+        }>>;
+        page: z.ZodDefault<z.ZodNumber>;
+        perPage: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    protected entitySchema: z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            dev: "dev";
+            release: "release";
+            rc: "rc";
+        }>;
+        version: z.ZodString;
+        commitSha: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodString;
+        ref: z.ZodString;
+    }, z.core.$strip>;
+    private gitlab;
+    private projectId;
+    constructor(gitlabToken: string, projectId?: string | number);
+    /**
+     * Create a new tag
+     */
+    create(input: CreateTagRequest): Promise<Tag>;
+    /**
+     * Read tag by name
+     */
+    read(id: string | number): Promise<Tag | null>;
+    /**
+     * Update tag - NOT SUPPORTED (tags are immutable)
+     */
+    update(): Promise<Tag>;
+    /**
+     * Delete tag
+     */
+    delete(id: string | number): Promise<void>;
+    /**
+     * List tags with filtering and pagination
+     */
+    list(filters?: TagFilter): Promise<{
+        items: Tag[];
+        pagination: {
+            page: number;
+            perPage: number;
+            total: number;
+            totalPages: number;
+        };
+    }>;
+    /**
+     * Helper: Determine tag type from name
+     */
+    private determineTagType;
+    /**
+     * Helper: Extract version from tag name
+     */
+    private extractVersion;
+}
+export {};
+//# sourceMappingURL=tag.service.d.ts.map

package/dist/services/release-automation/tag.service.js

@@ -0,0 +1,183 @@
+/**
+ * Tag CRUD Service
+ * Implements full CRUD operations for Git tags
+ */
+import { Gitlab } from '@gitbeaker/rest';
+import { TagSchema, CreateTagRequestSchema, } from './schemas/release.schema.js';
+import { BaseCrudService } from './base-crud.service.js';
+import { z } from 'zod';
+/**
+ * Tag Filter Input
+ */
+const TagFilterSchema = z.object({
+    version: z.string().optional(),
+    type: z.enum(['dev', 'rc', 'release', 'all']).default('all'),
+    page: z.number().int().positive().default(1),
+    perPage: z.number().int().positive().min(1).max(100).default(20),
+});
+/**
+ * Tag Service - CRUD operations
+ */
+export class TagService extends BaseCrudService {
+    createSchema = CreateTagRequestSchema;
+    updateSchema = z.never(); // Tags cannot be updated
+    filterSchema = TagFilterSchema;
+    entitySchema = TagSchema;
+    gitlab;
+    projectId;
+    constructor(gitlabToken, projectId = process.env.CI_PROJECT_ID || '') {
+        super();
+        this.gitlab = new Gitlab({ token: gitlabToken });
+        this.projectId = projectId;
+    }
+    /**
+     * Create a new tag
+     */
+    async create(input) {
+        try {
+            const validated = this.validateCreate(input);
+            // Check if tag already exists
+            const existing = await this.read(validated.name);
+            if (existing) {
+                throw new Error(`Tag ${validated.name} already exists`);
+            }
+            // Create tag via GitLab API
+            const tag = await this.gitlab.Tags.create(this.projectId, validated.name, validated.ref, {
+                message: validated.message || `Tag ${validated.name}`,
+            });
+            const result = {
+                name: tag.name,
+                type: this.determineTagType(tag.name),
+                version: this.extractVersion(tag.name),
+                commitSha: tag.commit?.id || '',
+                message: tag.message || '',
+                createdAt: new Date().toISOString(),
+                ref: validated.ref,
+            };
+            return this.validateEntity(result);
+        }
+        catch (error) {
+            this.handleValidationError(error);
+            throw error;
+        }
+    }
+    /**
+     * Read tag by name
+     */
+    async read(id) {
+        this.validateId(id);
+        try {
+            const tagName = String(id);
+            const tags = await this.gitlab.Tags.all(this.projectId, {
+                search: tagName,
+            });
+            const tag = tags.find((t) => t.name === tagName);
+            if (!tag) {
+                return null;
+            }
+            const result = {
+                name: tag.name,
+                type: this.determineTagType(tag.name),
+                version: this.extractVersion(tag.name),
+                commitSha: tag.commit?.id || '',
+                message: tag.message || '',
+                createdAt: tag.createdAt || new Date().toISOString(),
+                ref: tag.target || 'unknown',
+            };
+            return this.validateEntity(result);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Update tag - NOT SUPPORTED (tags are immutable)
+     */
+    async update() {
+        throw new Error('Tags are immutable and cannot be updated');
+    }
+    /**
+     * Delete tag
+     */
+    async delete(id) {
+        this.validateId(id);
+        const existing = await this.read(id);
+        if (!existing) {
+            this.throwNotFound('Tag', id);
+        }
+        await this.gitlab.Tags.remove(this.projectId, String(id));
+    }
+    /**
+     * List tags with filtering and pagination
+     */
+    async list(filters) {
+        const validatedFilters = this.validateFilter(filters || {});
+        try {
+            const tags = await this.gitlab.Tags.all(this.projectId, {
+                perPage: 100,
+                search: validatedFilters.version,
+            });
+            const items = tags
+                .map((tag) => ({
+                name: tag.name,
+                type: this.determineTagType(tag.name),
+                version: this.extractVersion(tag.name),
+                commitSha: tag.commit?.id || '',
+                message: tag.message || '',
+                createdAt: tag.createdAt || new Date().toISOString(),
+                ref: tag.target || 'unknown',
+            }))
+                .filter((tag) => {
+                if (validatedFilters.type !== 'all') {
+                    return tag.type === validatedFilters.type;
+                }
+                if (validatedFilters.version) {
+                    return tag.version.includes(validatedFilters.version);
+                }
+                return true;
+            })
+                .map((tag) => this.validateEntity(tag));
+            // Sort by version (newest first)
+            items.sort((a, b) => {
+                return b.version.localeCompare(a.version, undefined, {
+                    numeric: true,
+                    sensitivity: 'base',
+                });
+            });
+            // Paginate
+            const total = items.length;
+            const page = validatedFilters.page;
+            const perPage = validatedFilters.perPage;
+            const start = (page - 1) * perPage;
+            const end = start + perPage;
+            const paginated = items.slice(start, end);
+            return {
+                items: paginated,
+                pagination: this.calculatePagination(total, page, perPage),
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to list tags: ${error}`);
+        }
+    }
+    /**
+     * Helper: Determine tag type from name
+     */
+    determineTagType(tagName) {
+        if (tagName.includes('-dev.'))
+            return 'dev';
+        if (tagName.includes('-rc.'))
+            return 'rc';
+        return 'release';
+    }
+    /**
+     * Helper: Extract version from tag name
+     */
+    extractVersion(tagName) {
+        return tagName
+            .replace(/^v/, '')
+            .replace(/-dev\.[0-9]+$/, '')
+            .replace(/-rc\.[0-9]+$/, '');
+    }
+}
+//# sourceMappingURL=tag.service.js.map

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

@@ -0,0 +1,37 @@
+/**
+ * Webhook Service
+ * Handles GitLab webhooks with Zod validation
+ */
+import { type WebhookResponse } from './schemas/release.schema.js';
+/**
+ * Webhook Service
+ * DRY: Centralized webhook handling
+ */
+export declare class WebhookService {
+    private releaseService;
+    private milestoneService;
+    private tagService;
+    private mergeRequestService;
+    constructor(gitlabToken: string, projectId?: string | number);
+    /**
+     * Handle milestone webhook
+     */
+    handleMilestoneWebhook(payload: unknown): Promise<WebhookResponse>;
+    /**
+     * Handle push webhook
+     */
+    handlePushWebhook(payload: unknown): Promise<WebhookResponse>;
+    /**
+     * Handle milestone creation
+     */
+    private handleMilestoneCreate;
+    /**
+     * Handle milestone closure
+     */
+    private handleMilestoneClose;
+    /**
+     * Handle release branch push
+     */
+    private handleReleaseBranchPush;
+}
+//# sourceMappingURL=webhook.service.d.ts.map