@bluefly/openstandardagents 0.4.6 → 0.4.9

package/dist/services/governance/cedar-validator.service.js

@@ -0,0 +1,88 @@
+/**
+ * Cedar Policy Validator Service
+ *
+ * Uses @cedar-policy/cedar-wasm to validate Cedar policies embedded in OSSA manifests.
+ * This is OSSA's responsibility: schema definition + offline validation.
+ * Runtime enforcement belongs to DUADP.
+ */
+import { checkParsePolicySet, checkParseSchema, } from '@cedar-policy/cedar-wasm';
+function extractErrors(answer) {
+    if (answer.type === 'failure') {
+        return answer.errors.map((e) => e.message ?? JSON.stringify(e));
+    }
+    return [];
+}
+/**
+ * Validate a single Cedar policy text for syntax correctness.
+ */
+export function validatePolicyText(policyText, policyId) {
+    const errors = [];
+    const warnings = [];
+    try {
+        const result = checkParsePolicySet({
+            staticPolicies: policyText,
+        });
+        errors.push(...extractErrors(result));
+    }
+    catch (e) {
+        errors.push(`Cedar WASM error: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    return { valid: errors.length === 0, policyId, errors, warnings };
+}
+/**
+ * Validate a Cedar policy against a Cedar schema.
+ */
+export function validatePolicyWithSchema(policyText, schemaText, policyId) {
+    const errors = [];
+    const warnings = [];
+    // First validate schema itself
+    try {
+        const schemaResult = checkParseSchema(schemaText);
+        const schemaErrors = extractErrors(schemaResult);
+        if (schemaErrors.length > 0) {
+            errors.push(...schemaErrors.map((e) => `Schema error: ${e}`));
+            return { valid: false, policyId, errors, warnings };
+        }
+    }
+    catch (e) {
+        errors.push(`Cedar schema parse error: ${e instanceof Error ? e.message : String(e)}`);
+        return { valid: false, policyId, errors, warnings };
+    }
+    // Then validate policy syntax
+    try {
+        const result = checkParsePolicySet({
+            staticPolicies: policyText,
+        });
+        errors.push(...extractErrors(result));
+    }
+    catch (e) {
+        errors.push(`Cedar WASM error: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    return { valid: errors.length === 0, policyId, errors, warnings };
+}
+/**
+ * Extract and validate all Cedar policies from an OSSA manifest.
+ */
+export function validateManifestCedarPolicies(manifest) {
+    const extensions = manifest.extensions;
+    const security = extensions?.security;
+    const cedarExt = security?.cedar;
+    if (!cedarExt || !cedarExt.policies || cedarExt.policies.length === 0) {
+        return { valid: true, policyCount: 0, results: [], hasSchema: false };
+    }
+    const results = [];
+    const hasSchema = !!cedarExt.schema_text;
+    for (const policy of cedarExt.policies) {
+        const result = hasSchema
+            ? validatePolicyWithSchema(policy.policy_text, cedarExt.schema_text, policy.id)
+            : validatePolicyText(policy.policy_text, policy.id);
+        results.push(result);
+    }
+    return {
+        valid: results.every((r) => r.valid),
+        policyCount: cedarExt.policies.length,
+        results,
+        hasSchema,
+    };
+}
+//# sourceMappingURL=cedar-validator.service.js.map

package/dist/services/mcp/bridge.service.d.ts

@@ -34,6 +34,7 @@ export declare class McpBridgeService {
     private getRegistryPath;
     private loadRegistry;
     private saveRegistry;
+    private saveToolManifest;
     /**
      * Use @modelcontextprotocol/sdk Client to connect to a stdio server and list its tools.
      * Returns an empty array if connection fails (non-fatal — import still proceeds).

package/dist/services/mcp/bridge.service.js

@@ -58,6 +58,34 @@ let McpBridgeService = class McpBridgeService {
         fs.writeFileSync(registryPath, yaml.dump({ generatedBy: 'ossa-mcp-bridge', apiVersion: getApiVersion(), updatedAt: new Date().toISOString(), servers }, { lineWidth: 120 }), 'utf8');
         return registryPath;
     }
+    saveToolManifest(workspaceDir, server) {
+        const toolsDir = path.join(workspaceDir, '.agents-workspace', 'tools');
+        if (!fs.existsSync(toolsDir)) {
+            fs.mkdirSync(toolsDir, { recursive: true });
+        }
+        const manifest = {
+            apiVersion: 'ossa.dev/v0.5',
+            kind: 'Tool',
+            metadata: {
+                name: server.name,
+                description: `Imported MCP server from ${server.source}`,
+                trust_tier: 'experimental',
+                created: server.importedAt,
+            },
+            spec: {
+                protocol: 'mcp',
+                endpoint: {
+                    transport: server.transport,
+                    command: server.command,
+                    args: server.args,
+                    url: server.url,
+                },
+                capabilities: server.tools ?? [],
+            },
+        };
+        const filePath = path.join(toolsDir, `${server.name}.yaml`);
+        fs.writeFileSync(filePath, yaml.dump(manifest, { lineWidth: -1 }), 'utf8');
+    }
     /**
      * Use @modelcontextprotocol/sdk Client to connect to a stdio server and list its tools.
      * Returns an empty array if connection fails (non-fatal — import still proceeds).
@@ -128,6 +156,9 @@ let McpBridgeService = class McpBridgeService {
         }
         const merged = [...existing, ...newEntries];
         const registryPath = this.saveRegistry(dir, merged);
+        for (const entry of newEntries) {
+            this.saveToolManifest(dir, entry);
+        }
         return { action: 'sync', source, serversFound: parsed.length, serversImported: newEntries.length, registryPath, servers: newEntries };
     }
     async list(workspaceDir) {

package/dist/services/release-automation/base-crud.service.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Base CRUD Service
+ * DRY: Reusable CRUD operations for all release automation entities
+ */
+import { z } from 'zod';
+/**
+ * Generic CRUD operations interface
+ */
+export interface ICrudService<T, CreateInput, UpdateInput, FilterInput> {
+    /**
+     * Create a new entity
+     */
+    create(input: CreateInput): Promise<T>;
+    /**
+     * Read entity by ID
+     */
+    read(id: string | number): Promise<T | null>;
+    /**
+     * Update entity
+     */
+    update(id: string | number, input: UpdateInput): Promise<T>;
+    /**
+     * Delete entity
+     */
+    delete(id: string | number): Promise<void>;
+    /**
+     * List entities with filtering and pagination
+     */
+    list(filters?: FilterInput): Promise<{
+        items: T[];
+        pagination: {
+            page: number;
+            perPage: number;
+            total: number;
+            totalPages: number;
+        };
+    }>;
+}
+/**
+ * Base CRUD Service Implementation
+ * DRY: Provides common CRUD operations
+ */
+export declare abstract class BaseCrudService<T, CreateInput, UpdateInput, FilterInput> implements ICrudService<T, CreateInput, UpdateInput, FilterInput> {
+    protected abstract createSchema: z.ZodSchema<CreateInput>;
+    protected abstract updateSchema: z.ZodSchema<UpdateInput> | z.ZodNever;
+    protected abstract filterSchema: z.ZodSchema<FilterInput>;
+    protected abstract entitySchema: z.ZodSchema<T>;
+    /**
+     * Validate and parse input using Zod
+     */
+    protected validateCreate(input: unknown): CreateInput;
+    protected validateUpdate(input: unknown): UpdateInput;
+    protected validateFilter(input: unknown): FilterInput;
+    protected validateEntity(entity: unknown): T;
+    /**
+     * Abstract methods to be implemented by subclasses
+     */
+    abstract create(input: CreateInput): Promise<T>;
+    abstract read(id: string | number): Promise<T | null>;
+    abstract update(id: string | number, input: UpdateInput): Promise<T>;
+    abstract delete(id: string | number): Promise<void>;
+    abstract list(filters?: FilterInput): Promise<{
+        items: T[];
+        pagination: {
+            page: number;
+            perPage: number;
+            total: number;
+            totalPages: number;
+        };
+    }>;
+    /**
+     * Helper: Calculate pagination metadata
+     */
+    protected calculatePagination(total: number, page: number, perPage: number): {
+        page: number;
+        perPage: number;
+        total: number;
+        totalPages: number;
+    };
+    /**
+     * Helper: Validate ID format
+     */
+    protected validateId(id: string | number): void;
+    /**
+     * Helper: Handle not found errors
+     */
+    protected throwNotFound(resource: string, id: string | number): never;
+    /**
+     * Helper: Handle validation errors
+     */
+    protected handleValidationError(error: unknown): never;
+}
+//# sourceMappingURL=base-crud.service.d.ts.map

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