@bluefly/openstandardagents 0.4.6 → 0.4.8

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

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

@@ -0,0 +1,187 @@
+/**
+ * Webhook Service
+ * Handles GitLab webhooks with Zod validation
+ */
+import { MilestoneWebhookPayloadSchema, PushWebhookPayloadSchema, WebhookResponseSchema, } from './schemas/release.schema.js';
+import { ReleaseService } from './release.service.js';
+import { MilestoneService } from './milestone.service.js';
+import { TagService } from './tag.service.js';
+import { MergeRequestService } from './merge-request.service.js';
+/**
+ * Webhook Service
+ * DRY: Centralized webhook handling
+ */
+export class WebhookService {
+    releaseService;
+    milestoneService;
+    tagService;
+    mergeRequestService;
+    constructor(gitlabToken, projectId = process.env.CI_PROJECT_ID || '') {
+        this.releaseService = new ReleaseService(gitlabToken, projectId);
+        this.milestoneService = new MilestoneService(gitlabToken, projectId);
+        this.tagService = new TagService(gitlabToken, projectId);
+        this.mergeRequestService = new MergeRequestService(gitlabToken, projectId);
+    }
+    /**
+     * Handle milestone webhook
+     */
+    async handleMilestoneWebhook(payload) {
+        try {
+            // Validate payload with Zod
+            const validated = MilestoneWebhookPayloadSchema.parse(payload);
+            const actions = [];
+            const { object_attributes: milestone } = validated;
+            // Determine if this is a create or close event
+            const isNewMilestone = milestone.state === 'active' &&
+                new Date(milestone.created_at).getTime() ===
+                    new Date(milestone.updated_at).getTime();
+            if (isNewMilestone) {
+                // Milestone created - create dev tag and branch
+                const action = await this.handleMilestoneCreate(validated);
+                if (action)
+                    actions.push(action);
+            }
+            else if (milestone.state === 'closed') {
+                // Milestone closed - create RC
+                const action = await this.handleMilestoneClose(validated);
+                if (action)
+                    actions.push(action);
+            }
+            return WebhookResponseSchema.parse({
+                success: true,
+                message: `Milestone ${milestone.title} processed`,
+                actions,
+            });
+        }
+        catch (error) {
+            return WebhookResponseSchema.parse({
+                success: false,
+                message: `Webhook processing failed: ${error}`,
+                actions: [],
+            });
+        }
+    }
+    /**
+     * Handle push webhook
+     */
+    async handlePushWebhook(payload) {
+        try {
+            // Validate payload with Zod
+            const validated = PushWebhookPayloadSchema.parse(payload);
+            const actions = [];
+            // Only process release branch pushes (release/v0.X.x)
+            if (validated.ref.match(/^refs\/heads\/release\/v\d+\.\d+\.x$/)) {
+                const action = await this.handleReleaseBranchPush(validated);
+                if (action)
+                    actions.push(action);
+            }
+            return WebhookResponseSchema.parse({
+                success: true,
+                message: 'Push webhook processed',
+                actions,
+            });
+        }
+        catch (error) {
+            return WebhookResponseSchema.parse({
+                success: false,
+                message: `Webhook processing failed: ${error}`,
+                actions: [],
+            });
+        }
+    }
+    /**
+     * Handle milestone creation
+     */
+    async handleMilestoneCreate(payload) {
+        const { object_attributes: milestone } = payload;
+        const version = milestone.title.replace(/^v/, '');
+        // Extract major.minor from version (e.g., 0.3.0 -> 0.3)
+        const versionMatch = version.match(/^(\d+\.\d+)/);
+        if (!versionMatch) {
+            throw new Error(`Invalid version format: ${version}`);
+        }
+        const releaseBranch = `release/v${versionMatch[1]}.x`;
+        // Create initial dev tag on the appropriate release branch
+        const devTag = `v${version}-dev.0`;
+        await this.tagService.create({
+            name: devTag,
+            ref: releaseBranch,
+            message: `Initial dev tag for ${milestone.title}`,
+        });
+        return {
+            type: 'milestone_created',
+            status: 'success',
+            details: {
+                milestoneId: milestone.id,
+                tag: devTag,
+                version,
+                releaseBranch,
+            },
+        };
+    }
+    /**
+     * Handle milestone closure
+     */
+    async handleMilestoneClose(payload) {
+        const { object_attributes: milestone } = payload;
+        const version = milestone.title.replace(/^v/, '');
+        // Get milestone statistics
+        const milestoneData = await this.milestoneService.read(milestone.id);
+        if (!milestoneData) {
+            throw new Error(`Milestone ${milestone.id} not found`);
+        }
+        // Check all issues are closed
+        if (milestoneData.statistics.openIssues > 0) {
+            throw new Error(`Cannot create RC: ${milestoneData.statistics.openIssues} issues still open`);
+        }
+        // Extract major.minor from version to determine release branch
+        const versionMatch = version.match(/^(\d+\.\d+)/);
+        if (!versionMatch) {
+            throw new Error(`Invalid version format: ${version}`);
+        }
+        const releaseBranch = `release/v${versionMatch[1]}.x`;
+        // Create RC tag on the release branch
+        const rcTag = `v${version}-rc.1`;
+        await this.tagService.create({
+            name: rcTag,
+            ref: releaseBranch,
+            message: `Release candidate for ${milestone.title}`,
+        });
+        // Create MR: release/v0.X.x → main
+        const mr = await this.mergeRequestService.create({
+            sourceBranch: releaseBranch,
+            targetBranch: 'main',
+            title: `Release ${milestone.title}`,
+            description: `Release candidate ${rcTag} for milestone ${milestone.title}`,
+            labels: ['release', 'automation'],
+            milestoneId: milestone.id,
+        });
+        return {
+            type: 'milestone_closed',
+            status: 'success',
+            details: {
+                milestoneId: milestone.id,
+                rcTag,
+                mergeRequestId: mr.id,
+                releaseBranch,
+            },
+        };
+    }
+    /**
+     * Handle release branch push
+     */
+    async handleReleaseBranchPush(payload) {
+        // Auto-increment dev tag on release branch
+        // This would be implemented based on current version detection
+        // For now, return success
+        return {
+            type: 'dev_tag_incremented',
+            status: 'success',
+            details: {
+                branch: payload.ref,
+                commits: payload.commits.length,
+            },
+        };
+    }
+}
+//# sourceMappingURL=webhook.service.js.map

package/dist/skills/test-skill/README.md

@@ -0,0 +1,36 @@
+# test-skill
+
+A test skill for unit testing
+
+## Installation
+
+```bash
+npm install @claude-skills/test-skill
+```
+
+This will automatically install the skill to `~/.claude/skills/`.
+
+## Manual Installation
+
+```bash
+# Clone or copy SKILL.md to Claude skills directory
+cp node_modules/@claude-skills/test-skill/SKILL.md ~/.claude/skills/test-skill/
+```
+
+## Trigger Keywords
+
+- testing
+- validation
+- unit-test
+
+## Tags
+
+`test` 
+
+## About Claude Skills
+
+Claude Skills are reusable prompt templates that enhance Claude's capabilities for specific tasks.
+
+## Generated by OSSA
+
+This skill package was generated using [@bluefly/openstandardagents](https://www.npmjs.com/package/@bluefly/openstandardagents)

package/dist/skills/test-skill/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: test-skill
+description: A test skill for unit testing
+trigger_keywords:
+  - testing
+  - validation
+  - unit-test
+version: 1.0.0
+author: Test Author
+tags:
+  - test
+---
+
+# test-skill
+
+A test skill for unit testing
+
+## Instructions
+
+This is a test skill for validating the export functionality.
+
+## Capabilities
+
+- testing
+- validation
+
+## When to Use
+
+This skill activates when:
+- Task involves: testing
+- Task involves: validation

package/dist/skills/test-skill/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Claude Skill: test-skill
+ * A test skill for unit testing
+ *
+ * @generated by @bluefly/openstandardagents skills-export
+ */
+
+export type TriggerKeyword =
+  | 'testing'
+  | 'validation'
+  | 'unit-test';
+
+export type SkillTag =
+  | 'test';
+
+export interface ClaudeSkillMetadata {
+  name: 'test-skill';
+  description: string;
+  triggerKeywords: TriggerKeyword[];
+  version: '1.0.0';
+  author?: string;
+  tags?: SkillTag[];
+}
+
+export interface ClaudeSkill {
+  metadata: ClaudeSkillMetadata;
+  skillPath: string;
+}
+
+declare const skill: ClaudeSkill;
+export default skill;

package/dist/skills/test-skill/install.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+/**
+ * Post-install script to copy skill to ~/.claude/skills/
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const homeDir = os.homedir();
+const claudeSkillsDir = path.join(homeDir, '.claude', 'skills');
+const targetDir = path.join(claudeSkillsDir, 'test-skill');
+
+try {
+  // Create ~/.claude/skills/ if it doesn't exist
+  if (!fs.existsSync(claudeSkillsDir)) {
+    fs.mkdirSync(claudeSkillsDir, { recursive: true });
+  }
+
+  // Create target directory
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+
+  // Copy SKILL.md
+  const skillSource = path.join(__dirname, 'SKILL.md');
+  const skillTarget = path.join(targetDir, 'SKILL.md');
+  fs.copyFileSync(skillSource, skillTarget);
+
+  // Copy additional directories if they exist
+  const dirs = ['templates', 'knowledge', 'examples'];
+  for (const dir of dirs) {
+    const sourcePath = path.join(__dirname, dir);
+    if (fs.existsSync(sourcePath)) {
+      const targetPath = path.join(targetDir, dir);
+      fs.cpSync(sourcePath, targetPath, { recursive: true });
+    }
+  }
+
+  console.log('✓ Skill installed to: ' + targetDir);
+} catch (error) {
+  console.error('Failed to install skill:', error.message);
+  process.exit(1);
+}

package/dist/skills/test-skill/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@claude-skills/test-skill",
+  "version": "1.0.0",
+  "description": "A test skill for unit testing",
+  "main": "SKILL.md",
+  "types": "index.d.ts",
+  "scripts": {
+    "install": "node install.js"
+  },
+  "keywords": [
+    "claude",
+    "claude-skill",
+    "ossa",
+    "ai",
+    "agent",
+    "test",
+    "testing",
+    "validation",
+    "unit-test"
+  ],
+  "author": "Test Author",
+  "license": "MIT",
+  "files": [
+    "SKILL.md",
+    "README.md",
+    "index.d.ts",
+    "install.js",
+    "templates/**",
+    "knowledge/**",
+    "examples/**"
+  ],
+  "ossa": {
+    "type": "claude-skill",
+    "skillPath": "/var/folders/48/d86hncy50j93r_vzsv6knttr0000gn/T/ossa-export-test-1772826461079/test-skill"
+  }
+}

package/dist/spec/reference/reference-agents/compliance-auditor/manifest.ossa.yaml

@@ -1,4 +1,4 @@
-apiVersion: ossa/v0.4.6
+apiVersion: ossa/v0.4.7
 kind: Agent
 metadata:
   name: compliance-auditor

package/dist/spec/reference/reference-agents/doc-agent/manifest.ossa.yaml

@@ -1,4 +1,4 @@
-apiVersion: ossa/v0.4.6
+apiVersion: ossa/v0.4.7
 kind: Agent
 metadata:
   name: doc-agent

package/dist/spec/reference/reference-agents/mr-reviewer/manifest.ossa.yaml

@@ -1,4 +1,4 @@
-apiVersion: ossa/v0.4.6
+apiVersion: ossa/v0.4.7
 kind: Agent
 metadata:
   name: mr-reviewer

package/dist/spec/reference/reference-agents/ossa-validator-v0.3/manifest.ossa.yaml

@@ -1,4 +1,4 @@
-apiVersion: ossa/v0.4.6
+apiVersion: ossa/v0.4.7
 kind: Agent
 
 metadata:

package/dist/spec/reference/reference-agents/pipeline-fixer/manifest.ossa.yaml

@@ -9,7 +9,7 @@
 #
 # ============================================================================
 
-apiVersion: ossa/v0.4.6
+apiVersion: ossa/v0.4.7
 kind: Agent
 
 metadata:

package/dist/spec/reference/reference-agents/release-orchestrator/manifest.ossa.yaml

@@ -1,4 +1,4 @@
-apiVersion: ossa/v0.4.6
+apiVersion: ossa/v0.4.7
 kind: Agent
 metadata:
   name: release-orchestrator