@bluefly/openstandardagents 0.5.0 → 0.5.3

package/dist/cli/commands/build.command.js

@@ -1,296 +0,0 @@
-/**
- * Build Command
- * Builds OSSA agent for all configured platforms
- */
-import chalk from 'chalk';
-import { Command } from 'commander';
-import * as fs from 'fs';
-import * as path from 'path';
-import { stringify as yamlStringify } from 'yaml';
-import { container } from '../../di-container.js';
-import { ManifestRepository } from '../../repositories/manifest.repository.js';
-import { ValidationService } from '../../services/validation.service.js';
-import { KAgentCRDGenerator } from '../../sdks/kagent/crd-generator.js';
-import { getBuildDefaults } from '../../config/defaults.js';
-export const buildCommand = new Command('build')
-    .description('Build OSSA agent for configured platforms')
-    .argument('<manifest>', 'Path to OSSA agent manifest')
-    .option('-p, --platform <platform>', 'Build for specific platform (kagent, docker, kubernetes)', 'all')
-    .option('-o, --output <dir>', 'Output directory for build artifacts', getBuildDefaults().outputDir)
-    .option('--validate', 'Validate manifest before building', true)
-    .action(async (manifestPath, options) => {
-    try {
-        console.log(chalk.blue(`Building agent from: ${manifestPath}`));
-        console.log(chalk.blue(`Platform: ${options.platform}`));
-        console.log(chalk.blue(`Output: ${options.output}\n`));
-        // Load manifest
-        const manifestRepo = container.get(ManifestRepository);
-        const manifest = await manifestRepo.load(manifestPath);
-        if (options.validate) {
-            console.log(chalk.yellow('Validating manifest...'));
-            const svc = container.get(ValidationService);
-            const result = await svc.validate(manifest);
-            if (!result.valid) {
-                throw new Error(result.errors?.join('; ') ?? 'Validation failed');
-            }
-            console.log(chalk.green('✓ Manifest valid\n'));
-        }
-        // Create output directory
-        const outputDir = path.resolve(options.output);
-        if (!fs.existsSync(outputDir)) {
-            fs.mkdirSync(outputDir, { recursive: true });
-        }
-        const platforms = options.platform === 'all'
-            ? ['kagent', 'docker', 'kubernetes']
-            : [options.platform];
-        const results = [];
-        for (const platform of platforms) {
-            console.log(chalk.blue(`\nBuilding for ${platform}...`));
-            try {
-                const platformResults = await buildForPlatform(manifest, platform, outputDir);
-                results.push({ platform, success: true, files: platformResults });
-                console.log(chalk.green(`✓ ${platform} build complete (${platformResults.length} files)`));
-            }
-            catch (error) {
-                results.push({ platform, success: false, files: [] });
-                console.error(chalk.red(`✗ ${platform} build failed: ${error instanceof Error ? error.message : String(error)}`));
-            }
-        }
-        // Generate build manifest
-        const buildManifest = {
-            manifest: manifestPath,
-            timestamp: new Date().toISOString(),
-            platforms: results,
-        };
-        fs.writeFileSync(path.join(outputDir, 'build-manifest.json'), JSON.stringify(buildManifest, null, 2));
-        console.log(chalk.green(`\n✓ Build complete!`));
-        console.log(chalk.blue(`  Output: ${outputDir}`));
-        console.log(chalk.blue(`  Build manifest: ${path.join(outputDir, 'build-manifest.json')}`));
-        const successful = results.filter((r) => r.success).length;
-        const failed = results.filter((r) => !r.success).length;
-        if (failed > 0) {
-            console.log(chalk.yellow(`\n  ${successful} successful, ${failed} failed`));
-        }
-    }
-    catch (error) {
-        console.error(chalk.red(`Build failed: ${error instanceof Error ? error.message : String(error)}`));
-        process.exit(1);
-    }
-});
-async function buildForPlatform(manifest, platform, outputDir) {
-    const platformDir = path.join(outputDir, platform);
-    if (!fs.existsSync(platformDir)) {
-        fs.mkdirSync(platformDir, { recursive: true });
-    }
-    const files = [];
-    switch (platform) {
-        case 'kagent': {
-            const generator = new KAgentCRDGenerator();
-            const crd = generator.generate(manifest);
-            const crdPath = path.join(platformDir, `${manifest.metadata?.name || 'agent'}-crd.yaml`);
-            fs.writeFileSync(crdPath, JSON.stringify(crd, null, 2));
-            files.push(crdPath);
-            break;
-        }
-        case 'docker': {
-            try {
-                // Use manifest parameter directly (already loaded)
-                const spec = manifest.spec;
-                const dockerConfig = spec?.runtime?.bindings?.docker;
-                if (!dockerConfig) {
-                    throw new Error('Docker config not found in manifest. Add spec.runtime.bindings.docker');
-                }
-                const baseImage = dockerConfig.baseImage || getBuildDefaults().baseImage;
-                const agentName = manifest.metadata?.name || 'agent';
-                const workdir = dockerConfig.workdir || '/app';
-                let dockerfile = `# Dockerfile for ${agentName}
-# Generated from OSSA manifest
-# DO NOT EDIT MANUALLY - Regenerate from manifest
-
-FROM ${baseImage}
-
-WORKDIR ${workdir}
-
-`;
-                if (dockerConfig.buildDependencies) {
-                    dockerfile += '# Install build dependencies\n';
-                    if (baseImage.includes('node')) {
-                        dockerfile += 'RUN npm install -g pnpm typescript\n';
-                    }
-                    else if (baseImage.includes('python')) {
-                        dockerfile += 'RUN pip install --upgrade pip\n';
-                    }
-                    dockerfile += '\n';
-                }
-                dockerfile += '# Copy package files\n';
-                dockerfile += 'COPY package*.json ./\n';
-                dockerfile += 'COPY pnpm-lock.yaml* ./\n';
-                dockerfile += '\n';
-                dockerfile += '# Install dependencies\n';
-                if (baseImage.includes('node')) {
-                    dockerfile += 'RUN npm install || pnpm install\n';
-                }
-                else if (baseImage.includes('python')) {
-                    dockerfile += 'COPY requirements.txt .\n';
-                    dockerfile += 'RUN pip install -r requirements.txt\n';
-                }
-                dockerfile += '\n';
-                dockerfile += '# Copy source code\n';
-                dockerfile += 'COPY . .\n';
-                dockerfile += '\n';
-                if (dockerConfig.buildCommand) {
-                    dockerfile += `# Build\n`;
-                    dockerfile += `RUN ${dockerConfig.buildCommand}\n`;
-                    dockerfile += '\n';
-                }
-                if (dockerConfig.ports && dockerConfig.ports.length > 0) {
-                    dockerfile += '# Expose ports\n';
-                    for (const port of dockerConfig.ports) {
-                        dockerfile += `EXPOSE ${port}\n`;
-                    }
-                    dockerfile += '\n';
-                }
-                if (dockerConfig.healthCheck) {
-                    dockerfile += '# Health check\n';
-                    dockerfile += `HEALTHCHECK ${dockerConfig.healthCheck}\n`;
-                    dockerfile += '\n';
-                }
-                const startCommand = dockerConfig.startCommand || 'npm start';
-                dockerfile += `# Start command\n`;
-                dockerfile += `CMD ["${startCommand}"]\n`;
-                const outputPath = path.join(outputDir, 'Dockerfile');
-                fs.writeFileSync(outputPath, dockerfile);
-                console.log(chalk.green(`  ✅ Generated Dockerfile: ${outputPath}`));
-                files.push(outputPath);
-                // Always generate .dockerignore
-                {
-                    const dockerignore = `# .dockerignore for ${agentName}
-# Generated from OSSA manifest
-
-node_modules
-npm-debug.log
-.env
-.env.local
-.git
-.gitignore
-README.md
-*.md
-.vscode
-.idea
-dist
-build
-coverage
-.nyc_output
-*.log
-.DS_Store
-`;
-                    const dockerignorePath = path.join(outputDir, '.dockerignore');
-                    fs.writeFileSync(dockerignorePath, dockerignore);
-                    console.log(chalk.green(`  ✅ Generated .dockerignore: ${dockerignorePath}`));
-                    files.push(dockerignorePath);
-                }
-                files.push(outputPath);
-            }
-            catch (error) {
-                console.error(chalk.red(`  ❌ Failed to generate Dockerfile: ${error}`));
-                throw error;
-            }
-            break;
-        }
-        case 'kubernetes': {
-            try {
-                // Use manifest parameter directly (already loaded)
-                const spec = manifest.spec;
-                const k8sConfig = spec?.runtime?.bindings?.kubernetes;
-                if (!k8sConfig) {
-                    throw new Error('Kubernetes config not found in manifest. Add spec.runtime.bindings.kubernetes');
-                }
-                const namespace = k8sConfig.namespace || 'default';
-                const agentName = manifest.metadata?.name || 'agent';
-                const image = k8sConfig.image || `${agentName}:latest`;
-                const replicas = k8sConfig.replicas || 1;
-                const k8sDir = path.join(outputDir, 'k8s');
-                if (!fs.existsSync(k8sDir)) {
-                    fs.mkdirSync(k8sDir, { recursive: true });
-                }
-                const deployment = {
-                    apiVersion: 'apps/v1',
-                    kind: 'Deployment',
-                    metadata: {
-                        name: agentName,
-                        namespace: namespace,
-                        labels: {
-                            app: agentName,
-                            'agent-id': agentName,
-                            'managed-by': 'ossa',
-                        },
-                    },
-                    spec: {
-                        replicas: replicas,
-                        selector: {
-                            matchLabels: {
-                                app: agentName,
-                            },
-                        },
-                        template: {
-                            metadata: {
-                                labels: {
-                                    app: agentName,
-                                },
-                            },
-                            spec: {
-                                containers: [
-                                    {
-                                        name: agentName,
-                                        image: image,
-                                        ports: k8sConfig.ports || [],
-                                        resources: k8sConfig.resources || {
-                                            requests: { cpu: '100m', memory: '128Mi' },
-                                            limits: { cpu: '500m', memory: '512Mi' },
-                                        },
-                                        env: k8sConfig.env || [],
-                                    },
-                                ],
-                            },
-                        },
-                    },
-                };
-                const deploymentPath = path.join(k8sDir, 'deployment.yaml');
-                fs.writeFileSync(deploymentPath, yamlStringify(deployment));
-                console.log(chalk.green(`  ✅ Generated deployment: ${deploymentPath}`));
-                files.push(deploymentPath);
-                // Always generate service if ports are defined
-                if (k8sConfig.ports && k8sConfig.ports.length > 0) {
-                    const service = {
-                        apiVersion: 'v1',
-                        kind: 'Service',
-                        metadata: {
-                            name: agentName,
-                            namespace: namespace,
-                        },
-                        spec: {
-                            selector: {
-                                app: agentName,
-                            },
-                            ports: k8sConfig.servicePorts || [{ port: 80, targetPort: 3000 }],
-                            type: k8sConfig.serviceType || 'ClusterIP',
-                        },
-                    };
-                    const servicePath = path.join(k8sDir, 'service.yaml');
-                    fs.writeFileSync(servicePath, yamlStringify(service));
-                    console.log(chalk.green(`  ✅ Generated service: ${servicePath}`));
-                    files.push(servicePath);
-                }
-            }
-            catch (error) {
-                console.error(chalk.red(`  ❌ Failed to generate Kubernetes manifests: ${error}`));
-                throw error;
-            }
-            break;
-        }
-        default:
-            throw new Error(`Unknown platform: ${platform}`);
-    }
-    return files;
-}
-//# sourceMappingURL=build.command.js.map

package/dist/cli/commands/capability/create.command.d.ts

@@ -1,7 +0,0 @@
-/**
- * OSSA Capability Create Command
- * Create capability definitions from OpenAPI specs or manual schemas
- */
-import { Command } from 'commander';
-export declare const capabilityCreateCommand: Command;
-//# sourceMappingURL=create.command.d.ts.map

package/dist/cli/commands/capability/create.command.js

@@ -1,225 +0,0 @@
-/**
- * OSSA Capability Create Command
- * Create capability definitions from OpenAPI specs or manual schemas
- */
-import chalk from 'chalk';
-import { Command } from 'commander';
-import * as fs from 'fs';
-import axios from 'axios';
-import inquirer from 'inquirer';
-export const capabilityCreateCommand = new Command('create')
-    .description('Create OSSA capability definition')
-    .option('--from-openapi <url>', 'Generate capabilities from OpenAPI spec URL')
-    .option('-n, --name <name>', 'Capability name')
-    .option('--input-schema <path>', 'Path to JSON Schema file for input parameters')
-    .option('--output-schema <path>', 'Path to JSON Schema file for output')
-    .option('-o, --output <path>', 'Output file path', 'capability.json')
-    .option('-i, --interactive', 'Interactive mode with prompts', false)
-    .action(async (options) => {
-    try {
-        let capability;
-        if (options.fromOpenapi) {
-            capability = await createFromOpenAPI(options.fromOpenapi);
-        }
-        else if (options.interactive) {
-            capability = await createCapabilityInteractive();
-        }
-        else {
-            capability = await createCapabilityFromOptions(options);
-        }
-        // Write to file
-        const outputPath = options.output || 'capability.json';
-        fs.writeFileSync(outputPath, JSON.stringify(capability, null, 2));
-        console.log(chalk.green(`✓ Created capability definition: ${outputPath}`));
-        console.log(chalk.gray(`  Name: ${capability.name}`));
-        if (Array.isArray(capability)) {
-            console.log(chalk.gray(`  Generated ${capability.length} capabilities from OpenAPI`));
-        }
-        else {
-            console.log(chalk.gray(`  Type: ${capability.type || 'custom'}`));
-        }
-        console.log(chalk.blue('\nUsage:'));
-        console.log(chalk.gray(`  Add this capability to your agent manifest in spec.capabilities`));
-    }
-    catch (error) {
-        console.error(chalk.red('Error:'), error instanceof Error ? error.message : String(error));
-        process.exit(1);
-    }
-});
-async function createFromOpenAPI(url) {
-    console.log(chalk.blue(`Fetching OpenAPI spec from: ${url}`));
-    let spec;
-    // Check if URL or local file
-    if (url.startsWith('http://') || url.startsWith('https://')) {
-        const response = await axios.get(url);
-        spec = response.data;
-    }
-    else {
-        const content = fs.readFileSync(url, 'utf-8');
-        spec = JSON.parse(content);
-    }
-    if (!spec.paths) {
-        throw new Error('Invalid OpenAPI spec: missing paths');
-    }
-    console.log(chalk.green(`✓ Loaded OpenAPI spec: ${spec.info?.title || 'Unknown'}`));
-    const capabilities = [];
-    // Generate capability for each operation
-    for (const [pathName, pathItem] of Object.entries(spec.paths)) {
-        for (const [method, operation] of Object.entries(pathItem)) {
-            if (['get', 'post', 'put', 'patch', 'delete'].includes(method)) {
-                const op = operation;
-                const capabilityName = op.operationId || `${method}_${pathName.replace(/\//g, '_')}`;
-                const capability = {
-                    name: capabilityName,
-                    description: op.summary ||
-                        op.description ||
-                        `${method.toUpperCase()} ${pathName}`,
-                    type: 'api',
-                    endpoint: pathName,
-                    method: method.toUpperCase(),
-                    input_schema: extractInputSchema(op),
-                    output_schema: extractOutputSchema(op),
-                    metadata: {
-                        openapi_operation_id: op.operationId,
-                        tags: op.tags || [],
-                    },
-                };
-                capabilities.push(capability);
-            }
-        }
-    }
-    console.log(chalk.green(`✓ Generated ${capabilities.length} capabilities`));
-    return capabilities;
-}
-async function createCapabilityInteractive() {
-    const answers = await inquirer.prompt([
-        {
-            type: 'input',
-            name: 'name',
-            message: 'Capability name:',
-            validate: (input) => (input ? true : 'Name is required'),
-        },
-        {
-            type: 'input',
-            name: 'description',
-            message: 'Description:',
-        },
-        {
-            type: 'list',
-            name: 'type',
-            message: 'Capability type:',
-            choices: ['api', 'function', 'tool', 'custom'],
-        },
-    ]);
-    const hasInput = await inquirer.prompt([
-        {
-            type: 'confirm',
-            name: 'value',
-            message: 'Does this capability accept input parameters?',
-            default: true,
-        },
-    ]);
-    let input_schema;
-    if (hasInput.value) {
-        const schemaInput = await inquirer.prompt([
-            {
-                type: 'input',
-                name: 'path',
-                message: 'Path to input JSON Schema file (or press enter to skip):',
-            },
-        ]);
-        if (schemaInput.path) {
-            input_schema = JSON.parse(fs.readFileSync(schemaInput.path, 'utf-8'));
-        }
-    }
-    const hasOutput = await inquirer.prompt([
-        {
-            type: 'confirm',
-            name: 'value',
-            message: 'Does this capability return output?',
-            default: true,
-        },
-    ]);
-    let output_schema;
-    if (hasOutput.value) {
-        const schemaOutput = await inquirer.prompt([
-            {
-                type: 'input',
-                name: 'path',
-                message: 'Path to output JSON Schema file (or press enter to skip):',
-            },
-        ]);
-        if (schemaOutput.path) {
-            output_schema = JSON.parse(fs.readFileSync(schemaOutput.path, 'utf-8'));
-        }
-    }
-    return {
-        name: answers.name,
-        description: answers.description,
-        type: answers.type,
-        input_schema,
-        output_schema,
-    };
-}
-async function createCapabilityFromOptions(options) {
-    if (!options.name) {
-        throw new Error('Capability name is required. Use --name <name>');
-    }
-    const capability = {
-        name: options.name,
-        type: 'custom',
-    };
-    if (options.inputSchema) {
-        if (!fs.existsSync(options.inputSchema)) {
-            throw new Error(`Input schema file not found: ${options.inputSchema}`);
-        }
-        capability.input_schema = JSON.parse(fs.readFileSync(options.inputSchema, 'utf-8'));
-    }
-    if (options.outputSchema) {
-        if (!fs.existsSync(options.outputSchema)) {
-            throw new Error(`Output schema file not found: ${options.outputSchema}`);
-        }
-        capability.output_schema = JSON.parse(fs.readFileSync(options.outputSchema, 'utf-8'));
-    }
-    return capability;
-}
-function extractInputSchema(operation) {
-    const schema = {
-        type: 'object',
-        properties: {},
-        required: [],
-    };
-    // Extract from parameters
-    if (operation.parameters) {
-        for (const param of operation.parameters) {
-            schema.properties[param.name] = param.schema || { type: 'string' };
-            if (param.required) {
-                schema.required.push(param.name);
-            }
-        }
-    }
-    // Extract from requestBody
-    if (operation.requestBody?.content) {
-        const contentType = Object.keys(operation.requestBody.content)[0];
-        const bodySchema = operation.requestBody.content[contentType]?.schema;
-        if (bodySchema) {
-            return bodySchema;
-        }
-    }
-    return schema;
-}
-function extractOutputSchema(operation) {
-    if (!operation.responses) {
-        return { type: 'object' };
-    }
-    // Look for 200/201 response
-    const successResponse = operation.responses['200'] ||
-        operation.responses['201'] ||
-        operation.responses['default'];
-    if (successResponse?.content) {
-        const contentType = Object.keys(successResponse.content)[0];
-        return successResponse.content[contentType]?.schema || { type: 'object' };
-    }
-    return { type: 'object' };
-}
-//# sourceMappingURL=create.command.js.map

package/dist/cli/commands/capability/index.d.ts

@@ -1,7 +0,0 @@
-/**
- * OSSA Capability Commands
- * Commands for managing OSSA capability definitions
- */
-import { Command } from 'commander';
-export declare const capabilityCommandGroup: Command;
-//# sourceMappingURL=index.d.ts.map

package/dist/cli/commands/capability/index.js

@@ -1,10 +0,0 @@
-/**
- * OSSA Capability Commands
- * Commands for managing OSSA capability definitions
- */
-import { Command } from 'commander';
-import { capabilityCreateCommand } from './create.command.js';
-export const capabilityCommandGroup = new Command('capability')
-    .description('Manage OSSA capability definitions')
-    .addCommand(capabilityCreateCommand);
-//# sourceMappingURL=index.js.map

package/dist/cli/commands/capability/validate.d.ts

@@ -1,3 +0,0 @@
-import { Command } from 'commander';
-export declare const validateCapabilityCommand: Command;
-//# sourceMappingURL=validate.d.ts.map

package/dist/cli/commands/capability/validate.js

@@ -1,62 +0,0 @@
-// @ts-nocheck
-import { Command } from 'commander';
-import { promises as fs } from 'fs';
-import * as path from 'path';
-import Ajv from 'ajv';
-import addFormats from 'ajv-formats'; // Required for date-time, uri, email, etc.
-import { fileURLToPath } from 'url';
-// Resolve paths relative to the current module, assuming this script is part of the CLI package
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-// Adjust path to reach the schemas directory from the CLI command's location
-const SCHEMA_DIR = path.resolve(__dirname, '../../../schemas');
-export const validateCapabilityCommand = new Command('capability')
-    .description('Validate an OSSA Capability Contract file against the schema.')
-    .argument('<file>', 'Path to the capability contract JSON file.')
-    .action(async (filePath) => {
-    console.log(`Validating capability contract: ${filePath}`);
-    // @ts-expect-error - Ajv v8 API compatibility
-    const ajv = new Ajv({ allErrors: true });
-    addFormats(ajv); // Add common formats like date-time, uri, email
-    let contractSchema;
-    try {
-        // Load the capability contract schema from the defined schema directory
-        const schemaPath = path.join(SCHEMA_DIR, 'capability-contract.v0.json');
-        const schemaContent = await fs.readFile(schemaPath, 'utf-8');
-        contractSchema = JSON.parse(schemaContent);
-        console.log('Capability contract schema loaded successfully.');
-    }
-    catch (error) {
-        console.error(`Error loading capability contract schema from ${SCHEMA_DIR}/capability-contract.v0.json: ${error.message}`);
-        process.exit(1);
-    }
-    // Compile the schema for validation
-    const validate = ajv.compile(contractSchema);
-    let contractFileContent;
-    try {
-        const fullPath = path.resolve(process.cwd(), filePath);
-        const fileContent = await fs.readFile(fullPath, 'utf-8');
-        contractFileContent = JSON.parse(fileContent);
-        console.log(`Capability contract file ${filePath} read successfully.`);
-    }
-    catch (error) {
-        console.error(`Error reading or parsing capability contract file ${filePath}: ${error.message}`);
-        process.exit(1);
-    }
-    // Perform validation
-    const isValid = validate(contractFileContent);
-    if (isValid) {
-        console.log(`✅ Capability contract ${filePath} is valid according to schema v0.`);
-    }
-    else {
-        console.error(`❌ Capability contract ${filePath} is invalid.`);
-        if (validate.errors) {
-            // Log detailed errors for debugging
-            validate.errors.forEach((err) => {
-                console.error(`- ${err.instancePath || 'Root'}: ${err.message} (${err.keyword})`);
-            });
-        }
-        process.exit(1); // Exit with a non-zero code to indicate failure
-    }
-});
-//# sourceMappingURL=validate.js.map

package/dist/cli/commands/catalog/config.d.ts

@@ -1,54 +0,0 @@
-/**
- * Catalog Configuration
- *
- * Centralized config for OSSA → GitLab Duo catalog operations.
- * Reads from environment variables with sensible defaults.
- */
-export interface AgentInfo {
-    id: string;
-    manifestPath: string;
-    duoOutputPath: string;
-    exists: boolean;
-}
-export declare class CatalogConfig {
-    readonly ossaPackagesPath: string;
-    readonly duoOutputPath: string;
-    readonly gitlabTokenPath: string;
-    readonly ossaNamespace: string;
-    readonly gitlabApiUrl: string;
-    constructor();
-    /**
-     * Get GitLab token from file or environment
-     */
-    getGitLabToken(): string;
-    /**
-     * Get manifest path for an agent
-     */
-    getManifestPath(agentId: string): string;
-    /**
-     * Get Duo output path for an agent
-     */
-    getDuoOutputPath(agentId: string): string;
-    /**
-     * List all agent IDs in the packages directory
-     */
-    listAgentIds(): string[];
-    /**
-     * Get detailed info for all agents
-     */
-    getAgentInfos(): AgentInfo[];
-    /**
-     * Validate agent ID exists
-     */
-    validateAgentId(agentId: string): boolean;
-    /**
-     * Get agent IDs based on options (single or all)
-     */
-    resolveAgentIds(agent?: string, all?: boolean): string[];
-    /**
-     * Ensure output directory exists
-     */
-    ensureOutputDir(): void;
-}
-export declare const catalogConfig: CatalogConfig;
-//# sourceMappingURL=config.d.ts.map