@bluefly/openstandardagents 0.5.1 → 0.5.3

package/dist/cli/commands/wizard-api-first.command.js

@@ -1,1073 +0,0 @@
-/**
- * OSSA Wizard - API-FIRST EDITION
- *
- * Schema-driven wizard that validates everything against OpenAPI specs.
- * TRUE API-FIRST APPROACH - Schema is the single source of truth.
- *
- * Features:
- * ✓ All prompts generated from schema
- * ✓ All inputs validated against schema
- * ✓ Type-safe with auto-complete
- * ✓ Enum values loaded from schema
- * ✓ Patterns and constraints from schema
- * ✓ Real-time validation as you go
- * ✓ Beautiful error messages
- */
-import chalk from 'chalk';
-import { Command } from 'commander';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as yaml from 'yaml';
-import { IdCardService } from '../../services/id-card.service.js';
-import { getVersion } from '../../utils/version.js';
-import { printBanner, printCompletion, printError, printInfo, printProgress, printStep, printSuccess, printWarning, printWizardBanner, } from '../banner.js';
-import { initializeAPIsFirst, inquirer, } from '../schema-driven/index.js';
-import { container } from '../../di-container.js';
-import { SkillsInstallService } from '../../services/skills-pipeline/index.js';
-import { marketplaceSkillsCatalog } from '../../data/marketplace-skills-catalog.js';
-// Initialize API-First infrastructure
-const apiFirst = initializeAPIsFirst();
-class APIFirstWizard {
-    schema;
-    ui;
-    agent;
-    currentStep = 0;
-    totalSteps = 12;
-    constructor() {
-        this.schema = apiFirst.schema;
-        this.ui = apiFirst.ui;
-        this.agent = {
-            apiVersion: 'ossa/v0.4',
-            kind: 'Agent',
-            metadata: {
-                name: '',
-            },
-            spec: {
-                role: '',
-            },
-        };
-    }
-    async run(options) {
-        try {
-            printBanner();
-            printWizardBanner();
-            printInfo('🎯 API-FIRST MODE: All inputs validated against OpenAPI schema');
-            console.log('');
-            // Step 1: Kind Selection (Agent, Task, Workflow, Flow)
-            await this.selectKind();
-            // Step 2: Basic Metadata (validated against schema)
-            await this.configureMetadata();
-            // Step 2b: Agent ID Card (v0.4.6+)
-            await this.configureIdCard();
-            // Step 3: LLM Configuration (schema-driven)
-            await this.configureLLM();
-            // Step 4: Tools (schema-validated types)
-            await this.configureTools();
-            // Step 5: Extensions (all 22+ frameworks from schema)
-            await this.configureExtensions();
-            // Step 6: Features (conditional based on selections)
-            await this.configureFeatures();
-            // Step 7: Safety & Constraints (schema-validated)
-            await this.configureSafety();
-            // Step 8: Observability (schema-validated)
-            await this.configureObservability();
-            // Step 9: Final Validation
-            await this.validateManifest();
-            // Step 10: Export Configuration
-            await this.configureExportTargets();
-            // Step 11: Testing & Validation Configuration
-            await this.configureTestingValidation();
-            // Step 12: Output Generation
-            await this.generateOutput(options);
-            printCompletion();
-            this.printNextSteps();
-        }
-        catch (error) {
-            printError(error instanceof Error ? error.message : String(error));
-            process.exit(1);
-        }
-    }
-    nextStep(stepName) {
-        this.currentStep++;
-        printProgress(this.currentStep, this.totalSteps, stepName);
-    }
-    async selectKind() {
-        this.nextStep('Select Resource Kind');
-        printStep(1, this.totalSteps, 'Select Resource Kind', 'Choose between Agent, Task, Workflow, or Flow');
-        // Get kind enum from schema
-        const kindDef = this.schema.getDefinition('kind');
-        const kindOptions = kindDef?.enum || ['Agent', 'Task', 'Workflow', 'Flow'];
-        const answers = await apiFirst.ui.generatePrompt('kind', 'kind');
-        if (answers) {
-            const result = await inquirer.prompt([answers]);
-            this.agent.kind = result.kind;
-            printSuccess(`Selected: ${this.agent.kind}`);
-            // Show description of selected kind
-            const descriptions = {
-                Agent: 'Agentic loops - autonomous decision-making with tools',
-                Task: 'Deterministic steps - predefined workflow execution',
-                Workflow: 'Composition - orchestrate multiple agents/tasks',
-                Flow: 'Visual flow - state machine with transitions',
-            };
-            if (descriptions[this.agent.kind || '']) {
-                printInfo(descriptions[this.agent.kind || '']);
-            }
-        }
-    }
-    async configureMetadata() {
-        this.nextStep('Basic Metadata');
-        printStep(2, this.totalSteps, 'Basic Metadata', 'Schema-validated agent information');
-        // Generate all metadata prompts from schema
-        const metadata = await this.ui.generateForObject('metadata');
-        this.agent.metadata = {
-            ...metadata,
-            labels: {
-                'ossa.io/created-by': 'wizard-api-first',
-                'ossa.io/schema-validated': 'true',
-            },
-        };
-        printSuccess('Metadata configured and validated against schema');
-    }
-    async configureIdCard() {
-        const { addIdCard } = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'addIdCard',
-                message: 'Add an Agent ID Card (nickname, provenance, audit trail)?',
-                default: true,
-            },
-        ]);
-        if (!addIdCard)
-            return;
-        this.nextStep('Agent ID Card');
-        printStep(this.currentStep, this.totalSteps, 'Agent ID Card', 'Human-friendly identity with immutable provenance (v0.4.6+)');
-        const answers = await inquirer.prompt([
-            {
-                type: 'input',
-                name: 'nickname',
-                message: 'Nickname (short callsign, e.g., Scout, Drupa):',
-                default: this.agent.metadata?.name
-                    ?.split('-')
-                    .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
-                    .join('') || 'Agent',
-                validate: (input) => {
-                    if (!input)
-                        return 'Required';
-                    if (input.length > 32)
-                        return 'Max 32 chars';
-                    if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(input))
-                        return 'Alphanumeric, start with letter';
-                    return true;
-                },
-            },
-            {
-                type: 'input',
-                name: 'displayName',
-                message: 'Display name (full name):',
-                default: (answers) => answers.nickname,
-            },
-            {
-                type: 'input',
-                name: 'avatar',
-                message: 'Avatar URL (optional):',
-                default: '',
-            },
-            {
-                type: 'input',
-                name: 'createdBy',
-                message: 'Created by:',
-                default: process.env.USER || 'unknown',
-            },
-        ]);
-        // Build ID card via IdCardService (DRY — single source of truth)
-        const registryId = this.agent.metadata?.name
-            ? IdCardService.buildRegistryId(process.env.OSSA_ORG || 'my-org', this.agent.metadata.name, getVersion())
-            : undefined;
-        const idCard = IdCardService.createIdCard({
-            nickname: answers.nickname,
-            displayName: answers.displayName,
-            avatar: answers.avatar || undefined,
-            registryId,
-            createdBy: answers.createdBy,
-            createdWith: `ossa-wizard-api-first/${getVersion()}`,
-        });
-        this.agent.metadata = {
-            ...this.agent.metadata,
-            idCard,
-        };
-        // Compute fingerprint + birthHash
-        const fingerprint = IdCardService.recomputeFingerprint(this.agent);
-        printSuccess(`ID Card: ${answers.nickname} (${answers.displayName})`);
-        printSuccess(`Fingerprint: ${fingerprint.substring(0, 24)}...`);
-        printSuccess('Audit trail initialized with genesis entry');
-    }
-    async configureLLM() {
-        this.nextStep('LLM Configuration');
-        printStep(3, this.totalSteps, 'LLM Configuration', 'Schema-driven LLM setup with all providers from spec');
-        printInfo('All LLM providers loaded from OpenAPI schema');
-        // Use schema-driven LLM configuration
-        const llmConfig = await this.ui.generateLLMConfig();
-        this.agent.spec = {
-            ...this.agent.spec,
-            llm: llmConfig,
-        };
-        printSuccess('LLM configuration complete and schema-validated');
-        // Validate immediately
-        const validation = this.schema.validate(this.agent);
-        if (!validation.valid) {
-            printWarning('Validation warnings detected - will fix at final validation');
-        }
-    }
-    async configureTools() {
-        this.nextStep('Tools & Capabilities');
-        printStep(4, this.totalSteps, 'Tools & Capabilities', 'All tool types from schema with validation');
-        printInfo(`Available tool types: ${this.schema.getToolTypes().length}`);
-        // Use schema-driven tool configuration
-        const tools = await this.ui.generateToolConfig();
-        if (tools.length > 0) {
-            this.agent.spec = {
-                ...this.agent.spec,
-                tools,
-            };
-            printSuccess(`${tools.length} tools configured and validated`);
-        }
-    }
-    async configureExtensions() {
-        this.nextStep('Framework Extensions');
-        printStep(5, this.totalSteps, 'Framework Extensions', 'All 22+ frameworks loaded from schema');
-        const availableExtensions = this.ui.getAvailableExtensions();
-        printInfo(`${availableExtensions.length} framework integrations available`);
-        const answers = await inquirer.prompt([
-            {
-                type: 'checkbox',
-                name: 'extensions',
-                message: 'Select framework integrations:',
-                choices: availableExtensions.map((ext) => ({
-                    name: this.formatExtensionName(ext),
-                    value: ext,
-                    checked: false,
-                })),
-                pageSize: 15,
-            },
-        ]);
-        if (answers.extensions.length > 0) {
-            this.agent.extensions = {};
-            for (const ext of answers.extensions) {
-                // For now, enable with basic config
-                // Could prompt for extension-specific config here
-                this.agent.extensions[ext] = { enabled: true };
-                printSuccess(`Enabled: ${this.formatExtensionName(ext)}`);
-            }
-        }
-    }
-    formatExtensionName(ext) {
-        const names = {
-            mcp: 'MCP - Model Context Protocol',
-            skills: 'Skills - Claude/Cursor/Kiro format',
-            langchain: 'LangChain',
-            langgraph: 'LangGraph',
-            crewai: 'CrewAI',
-            autogen: 'AutoGen (Microsoft)',
-            openai_assistants: 'OpenAI Assistants',
-            openai_swarm: 'OpenAI Swarm',
-            vercel_ai: 'Vercel AI SDK',
-            llamaindex: 'LlamaIndex',
-            dify: 'Dify',
-            bedrock: 'AWS Bedrock Agents',
-            semanticKernel: 'Semantic Kernel',
-            vertexai: 'Google Vertex AI',
-            haystack: 'Haystack',
-            pydantic_ai: 'Pydantic AI',
-            langflow: 'LangFlow',
-            agents_md: 'AGENTS.md generation',
-            llms_txt: 'llms.txt generation',
-        };
-        return names[ext] || ext;
-    }
-    async configureFeatures() {
-        this.nextStep('Advanced Features');
-        printStep(6, this.totalSteps, 'Advanced Features', 'Schema-validated advanced capabilities');
-        const answers = await inquirer.prompt([
-            {
-                type: 'checkbox',
-                name: 'features',
-                message: 'Select advanced features:',
-                choices: [
-                    { name: '🎯 Skills System', value: 'skills' },
-                    { name: '🧠 Knowledge Sources (RAG)', value: 'knowledge_sources' },
-                    { name: '📡 Messaging (A2A)', value: 'messaging' },
-                    { name: '💾 State Management', value: 'state' },
-                    { name: '💰 Cost Tracking', value: 'cost_tracking' },
-                    { name: '🔐 Safety Controls', value: 'safety' },
-                    { name: '🎯 Autonomy Configuration', value: 'autonomy' },
-                ],
-            },
-        ]);
-        // Configure each selected feature using schema
-        for (const feature of answers.features) {
-            if (feature === 'skills') {
-                await this.configureSkills();
-            }
-            else {
-                await this.configureFeature(feature);
-            }
-        }
-    }
-    async configureFeature(feature) {
-        printInfo(`Configuring: ${feature}`);
-        // Generate prompts from schema for this feature
-        const featurePath = `spec.${feature}`;
-        const featureConfig = await this.ui.generateForObject(featurePath);
-        if (Object.keys(featureConfig).length > 0) {
-            this.agent.spec = {
-                ...this.agent.spec,
-                [feature]: featureConfig,
-            };
-            printSuccess(`${feature} configured`);
-        }
-    }
-    async configureSkills() {
-        printInfo('Configuring: skills');
-        const { addSkills } = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'addSkills',
-                message: 'Would you like to add Claude Skills to this agent?',
-                default: true,
-            },
-        ]);
-        if (!addSkills) {
-            return;
-        }
-        const marketplacePath = process.env.OSSA_SKILLS_PATH ||
-            (process.env.HOME
-                ? `${process.env.HOME}/.ossa/skills`
-                : path.join(process.cwd(), 'skills'));
-        const { skillSource } = await inquirer.prompt([
-            {
-                type: 'list',
-                name: 'skillSource',
-                message: 'How do you want to add skills?',
-                choices: [
-                    { name: 'Install from GitHub (repo URL + skill name)', value: 'url' },
-                    {
-                        name: 'Install from Bluefly catalog (marketplace-skills-catalog)',
-                        value: 'catalog',
-                    },
-                    {
-                        name: 'Manual entry only (define skills in manifest)',
-                        value: 'manual',
-                    },
-                ],
-                default: 'manual',
-            },
-        ]);
-        if (skillSource === 'url') {
-            const { repoUrl, skillName, installPath } = await inquirer.prompt([
-                {
-                    type: 'input',
-                    name: 'repoUrl',
-                    message: 'GitHub repo URL:',
-                    validate: (s) => !!s?.trim() || 'URL required',
-                },
-                {
-                    type: 'input',
-                    name: 'skillName',
-                    message: 'Skill name:',
-                    validate: (s) => !!s?.trim() || 'Skill name required',
-                },
-                {
-                    type: 'input',
-                    name: 'installPath',
-                    message: 'Install to directory:',
-                    default: marketplacePath,
-                },
-            ]);
-            try {
-                const installService = container.get(SkillsInstallService);
-                const result = await installService.install({
-                    repoUrl: repoUrl.trim(),
-                    skill: skillName.trim(),
-                    path: installPath.trim(),
-                });
-                if (result.success)
-                    printSuccess(result.message);
-                else {
-                    printError(result.message);
-                    if (result.errors)
-                        result.errors.forEach((e) => printError(`  ${e}`));
-                }
-            }
-            catch (err) {
-                printError(err instanceof Error ? err.message : String(err));
-            }
-        }
-        else if (skillSource === 'catalog') {
-            const catalogDefault = process.env.BLUEFLY_SKILLS_CATALOG ||
-                (process.env.HOME
-                    ? `${process.env.HOME}/.ossa/marketplace-skills-catalog.json`
-                    : '');
-            const { catalogPath, targetPath } = await inquirer.prompt([
-                {
-                    type: 'input',
-                    name: 'catalogPath',
-                    message: 'Path to marketplace-skills-catalog.json:',
-                    default: catalogDefault,
-                },
-                {
-                    type: 'input',
-                    name: 'targetPath',
-                    message: 'Install skills to directory:',
-                    default: marketplacePath,
-                },
-            ]);
-            const resolvedCatalog = catalogPath.trim();
-            let catalog = {
-                skills: [],
-            };
-            if (resolvedCatalog && fs.existsSync(resolvedCatalog)) {
-                catalog = JSON.parse(fs.readFileSync(resolvedCatalog, 'utf-8'));
-            }
-            else {
-                printInfo('Using bundled Bluefly marketplace skills catalog.');
-                catalog = { skills: [...marketplaceSkillsCatalog.skills] };
-            }
-            const entries = catalog.skills || [];
-            if (entries.length > 0) {
-                const choices = entries.map((e) => ({
-                    name: `${e.skill} (${e.repo})`,
-                    value: e,
-                    short: e.skill,
-                }));
-                const { selected } = await inquirer.prompt([
-                    {
-                        type: 'checkbox',
-                        name: 'selected',
-                        message: 'Select skills to install:',
-                        choices,
-                    },
-                ]);
-                const target = targetPath.trim();
-                const installService = container.get(SkillsInstallService);
-                for (const e of selected) {
-                    const result = await installService.install({
-                        repoUrl: e.repo,
-                        skill: e.skill,
-                        path: target,
-                    });
-                    if (result.success)
-                        printSuccess(result.message);
-                    else
-                        printError(result.message);
-                }
-            }
-        }
-        const { doManual } = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'doManual',
-                message: 'Also define skills manually in the manifest?',
-                default: skillSource === 'manual',
-            },
-        ]);
-        if (!doManual) {
-            return;
-        }
-        const skills = [];
-        let addingSkills = true;
-        while (addingSkills) {
-            console.log('');
-            printInfo(`Adding skill ${skills.length + 1}`);
-            const skillAnswers = await inquirer.prompt([
-                {
-                    type: 'input',
-                    name: 'id',
-                    message: 'Skill ID (identifier):',
-                    validate: (input) => {
-                        const valid = /^[a-z0-9]([-a-z0-9]*[a-z0-9])?$/.test(input);
-                        return (valid ||
-                            'Must be lowercase alphanumeric with hyphens (e.g., research-skill)');
-                    },
-                },
-                {
-                    type: 'input',
-                    name: 'name',
-                    message: 'Skill name (display name):',
-                    default: (answers) => answers.id
-                        .split('-')
-                        .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
-                        .join(' '),
-                },
-                {
-                    type: 'input',
-                    name: 'description',
-                    message: 'Skill description:',
-                    validate: (input) => {
-                        return (input.length >= 10 || 'Description must be at least 10 characters');
-                    },
-                },
-                {
-                    type: 'editor',
-                    name: 'instructions',
-                    message: 'Skill instructions (detailed prompt):',
-                    default: 'You are a skilled assistant. When invoked, you should...\n\nCapabilities:\n- \n\nGuidelines:\n- ',
-                },
-                {
-                    type: 'list',
-                    name: 'type',
-                    message: 'Skill type:',
-                    choices: [
-                        { name: 'Task - Execute specific actions', value: 'task' },
-                        { name: 'Query - Retrieve information', value: 'query' },
-                        { name: 'Creative - Generate content', value: 'creative' },
-                        { name: 'Analysis - Analyze data', value: 'analysis' },
-                        { name: 'Other', value: 'other' },
-                    ],
-                    default: 'task',
-                },
-            ]);
-            // Ask for parameters
-            const { addParams } = await inquirer.prompt([
-                {
-                    type: 'confirm',
-                    name: 'addParams',
-                    message: 'Add parameters to this skill?',
-                    default: false,
-                },
-            ]);
-            const parameters = {};
-            if (addParams) {
-                let addingParams = true;
-                while (addingParams) {
-                    const paramAnswers = await inquirer.prompt([
-                        {
-                            type: 'input',
-                            name: 'paramName',
-                            message: 'Parameter name:',
-                        },
-                        {
-                            type: 'list',
-                            name: 'paramType',
-                            message: 'Parameter type:',
-                            choices: ['string', 'number', 'boolean', 'array', 'object'],
-                        },
-                        {
-                            type: 'input',
-                            name: 'paramDescription',
-                            message: 'Parameter description:',
-                        },
-                        {
-                            type: 'confirm',
-                            name: 'paramRequired',
-                            message: 'Is this parameter required?',
-                            default: false,
-                        },
-                    ]);
-                    parameters[paramAnswers.paramName] = {
-                        type: paramAnswers.paramType,
-                        description: paramAnswers.paramDescription,
-                    };
-                    if (paramAnswers.paramRequired) {
-                        if (!parameters._required) {
-                            parameters._required = [];
-                        }
-                        parameters._required.push(paramAnswers.paramName);
-                    }
-                    const { addAnother } = await inquirer.prompt([
-                        {
-                            type: 'confirm',
-                            name: 'addAnother',
-                            message: 'Add another parameter?',
-                            default: false,
-                        },
-                    ]);
-                    addingParams = addAnother;
-                }
-            }
-            // Build skill object (schema-validated structure)
-            const skill = {
-                id: skillAnswers.id,
-                name: skillAnswers.name,
-                description: skillAnswers.description,
-                instructions: skillAnswers.instructions,
-                type: skillAnswers.type,
-            };
-            if (Object.keys(parameters).length > 0) {
-                // Extract required array if exists
-                const required = parameters._required;
-                delete parameters._required;
-                skill.parameters = {
-                    type: 'object',
-                    properties: parameters,
-                };
-                if (required && required.length > 0) {
-                    skill.parameters.required = required;
-                }
-            }
-            skills.push(skill);
-            printSuccess(`Skill "${skill.name}" added (schema-validated)`);
-            const { addMore } = await inquirer.prompt([
-                {
-                    type: 'confirm',
-                    name: 'addMore',
-                    message: 'Add another skill?',
-                    default: false,
-                },
-            ]);
-            addingSkills = addMore;
-        }
-        if (skills.length > 0) {
-            this.agent.spec = {
-                ...this.agent.spec,
-                skills,
-            };
-            printSuccess(`${skills.length} skill(s) configured and validated`);
-        }
-    }
-    async configureSafety() {
-        this.nextStep('Safety & Constraints');
-        printStep(7, this.totalSteps, 'Safety & Constraints', 'Schema-validated safety controls');
-        const answers = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'enable_safety',
-                message: 'Configure safety controls?',
-                default: true,
-            },
-        ]);
-        if (answers.enable_safety) {
-            const safetyConfig = await this.ui.generateForObject('spec.safety');
-            if (Object.keys(safetyConfig).length > 0) {
-                this.agent.spec = {
-                    ...this.agent.spec,
-                    safety: safetyConfig,
-                };
-                printSuccess('Safety controls configured and validated');
-            }
-        }
-    }
-    async configureObservability() {
-        this.nextStep('Observability');
-        printStep(8, this.totalSteps, 'Observability & Monitoring', 'OpenTelemetry, metrics, and logging from schema');
-        const answers = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'enable_observability',
-                message: 'Configure observability?',
-                default: true,
-            },
-        ]);
-        if (answers.enable_observability) {
-            const obsConfig = await this.ui.generateForObject('spec.observability');
-            if (Object.keys(obsConfig).length > 0) {
-                this.agent.spec = {
-                    ...this.agent.spec,
-                    observability: obsConfig,
-                };
-                printSuccess('Observability configured and validated');
-            }
-        }
-    }
-    async validateManifest() {
-        this.nextStep('Final Validation');
-        printStep(9, this.totalSteps, 'Schema Validation', 'Validating complete manifest against OpenAPI schema');
-        const validation = this.schema.validate(this.agent);
-        if (validation.valid) {
-            printSuccess('✓ Manifest is valid according to OSSA schema');
-        }
-        else {
-            printError('Schema validation failed!');
-            console.log('');
-            console.log(chalk.yellow('Validation Errors:'));
-            validation.errors?.forEach((error, index) => {
-                console.log(chalk.red(`${index + 1}.`), chalk.white(error.instancePath || 'root'), chalk.gray('-'), error.message);
-            });
-            console.log('');
-            throw new Error('Manifest validation failed');
-        }
-    }
-    async configureExportTargets() {
-        this.nextStep('Export Configuration');
-        printStep(10, this.totalSteps, 'Export Targets', 'Schema-validated deployment configuration');
-        const { configureExport } = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'configureExport',
-                message: 'Configure export targets for deployment?',
-                default: true,
-            },
-        ]);
-        if (!configureExport) {
-            return;
-        }
-        const { platforms } = await inquirer.prompt([
-            {
-                type: 'checkbox',
-                name: 'platforms',
-                message: 'Select export platforms (schema-validated):',
-                choices: [
-                    {
-                        name: 'LangChain (Python) - Full framework with observability',
-                        value: 'langchain',
-                        checked: true,
-                    },
-                    {
-                        name: 'KAgent (Kubernetes) - Cloud-native deployment',
-                        value: 'kagent',
-                    },
-                    {
-                        name: 'Drupal Module - CMS integration',
-                        value: 'drupal',
-                    },
-                    {
-                        name: 'Symfony Bundle - PHP framework',
-                        value: 'symfony',
-                    },
-                ],
-                validate: (answer) => {
-                    if (answer.length < 1) {
-                        return 'You must select at least one export platform.';
-                    }
-                    return true;
-                },
-            },
-        ]);
-        const exportConfig = {
-            enabled: true,
-            platforms: platforms,
-        };
-        // Platform-specific configuration (schema-validated)
-        for (const platform of platforms) {
-            if (platform === 'langchain') {
-                const langchainConfig = await inquirer.prompt([
-                    {
-                        type: 'confirm',
-                        name: 'includeCallbacks',
-                        message: 'Include observability (LangSmith, LangFuse, OpenTelemetry)?',
-                        default: true,
-                    },
-                    {
-                        type: 'confirm',
-                        name: 'includeErrorHandling',
-                        message: 'Include production error handling (retry, circuit breaker)?',
-                        default: true,
-                    },
-                    {
-                        type: 'confirm',
-                        name: 'includeLangServe',
-                        message: 'Generate LangServe REST API deployment?',
-                        default: false,
-                    },
-                    {
-                        type: 'confirm',
-                        name: 'includeTests',
-                        message: 'Generate pytest test suite?',
-                        default: true,
-                    },
-                ]);
-                exportConfig.langchain = langchainConfig;
-            }
-            else if (platform === 'kagent') {
-                const kagentConfig = await inquirer.prompt([
-                    {
-                        type: 'confirm',
-                        name: 'includeRBAC',
-                        message: 'Include RBAC (ServiceAccount, Roles)?',
-                        default: true,
-                    },
-                    {
-                        type: 'confirm',
-                        name: 'includeTLS',
-                        message: 'Configure TLS for secure communication?',
-                        default: true,
-                    },
-                    {
-                        type: 'confirm',
-                        name: 'includeNetworkPolicy',
-                        message: 'Generate NetworkPolicy for isolation?',
-                        default: true,
-                    },
-                ]);
-                exportConfig.kagent = kagentConfig;
-            }
-            else if (platform === 'drupal') {
-                const drupalConfig = await inquirer.prompt([
-                    {
-                        type: 'input',
-                        name: 'moduleName',
-                        message: 'Drupal module name:',
-                        default: this.agent.metadata?.name?.replace(/-/g, '_') || 'ossa_agent',
-                        validate: (input) => {
-                            const valid = /^[a-z][a-z0-9_]*$/.test(input);
-                            return valid || 'Must be lowercase alphanumeric with underscores';
-                        },
-                    },
-                    {
-                        type: 'confirm',
-                        name: 'includeQueue',
-                        message: 'Include queue worker for async execution?',
-                        default: true,
-                    },
-                    {
-                        type: 'confirm',
-                        name: 'includeEntity',
-                        message: 'Generate entity storage with Views integration?',
-                        default: true,
-                    },
-                ]);
-                exportConfig.drupal = drupalConfig;
-            }
-            else if (platform === 'symfony') {
-                const symfonyConfig = await inquirer.prompt([
-                    {
-                        type: 'input',
-                        name: 'bundleName',
-                        message: 'Symfony bundle name:',
-                        default: (this.agent.metadata?.name
-                            ?.split('-')
-                            .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
-                            .join('') || 'Ossa') + 'Bundle',
-                    },
-                    {
-                        type: 'confirm',
-                        name: 'includeEvents',
-                        message: 'Include event system (start, complete, error)?',
-                        default: true,
-                    },
-                    {
-                        type: 'confirm',
-                        name: 'includeCaching',
-                        message: 'Include caching layer?',
-                        default: true,
-                    },
-                ]);
-                exportConfig.symfony = symfonyConfig;
-            }
-        }
-        // Store in annotations (buildkit-specific metadata, schema-compliant)
-        this.agent.metadata = {
-            ...this.agent.metadata,
-            annotations: {
-                ...this.agent.metadata?.annotations,
-                'buildkit.ossa.io/export-config': JSON.stringify(exportConfig),
-            },
-        };
-        printSuccess(`Export configured for ${platforms.length} platform(s) with schema validation`);
-    }
-    async configureTestingValidation() {
-        this.nextStep('Testing Configuration');
-        printStep(11, this.totalSteps, 'Testing & Validation', 'Schema-validated testing configuration');
-        const { enableTesting } = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'enableTesting',
-                message: 'Configure testing for this agent?',
-                default: true,
-            },
-        ]);
-        if (!enableTesting) {
-            return;
-        }
-        const testConfig = await inquirer.prompt([
-            {
-                type: 'checkbox',
-                name: 'types',
-                message: 'Which test types to generate (schema-validated)?',
-                choices: [
-                    { name: 'Unit tests (recommended)', value: 'unit', checked: true },
-                    { name: 'Integration tests', value: 'integration' },
-                    { name: 'Load tests', value: 'load' },
-                    { name: 'Security tests', value: 'security' },
-                    { name: 'Cost tests', value: 'cost' },
-                ],
-                validate: (answer) => {
-                    if (answer.length < 1) {
-                        return 'You must choose at least one test type.';
-                    }
-                    return true;
-                },
-            },
-            {
-                type: 'confirm',
-                name: 'mockLLM',
-                message: 'Mock LLM by default?',
-                default: true,
-            },
-            {
-                type: 'confirm',
-                name: 'generateFixtures',
-                message: 'Generate test fixtures?',
-                default: true,
-            },
-            {
-                type: 'confirm',
-                name: 'includeCICD',
-                message: 'Include CI/CD configurations?',
-                default: true,
-            },
-        ]);
-        let cicdPlatforms = [];
-        if (testConfig.includeCICD) {
-            const { platforms } = await inquirer.prompt([
-                {
-                    type: 'checkbox',
-                    name: 'platforms',
-                    message: 'Which CI/CD platforms?',
-                    choices: [
-                        { name: 'GitHub Actions', value: 'github-actions', checked: true },
-                        { name: 'GitLab CI', value: 'gitlab-ci' },
-                    ],
-                    validate: (answer) => {
-                        if (answer.length < 1) {
-                            return 'You must choose at least one CI/CD platform.';
-                        }
-                        return true;
-                    },
-                },
-            ]);
-            cicdPlatforms = platforms;
-        }
-        const validationConfig = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'manifest',
-                message: 'Enable manifest validation?',
-                default: true,
-            },
-            {
-                type: 'confirm',
-                name: 'safety',
-                message: 'Enable safety checks?',
-                default: true,
-            },
-            {
-                type: 'number',
-                name: 'costBudget',
-                message: 'Cost budget per test run? (USD)',
-                default: 0.1,
-                validate: (input) => {
-                    if (input < 0) {
-                        return 'Cost budget must be positive';
-                    }
-                    return true;
-                },
-            },
-        ]);
-        const testingConfig = {
-            enabled: true,
-            types: testConfig.types,
-            mockLLM: testConfig.mockLLM,
-            generateFixtures: testConfig.generateFixtures,
-            cicd: cicdPlatforms,
-            validation: validationConfig,
-        };
-        // Store in annotations (buildkit-specific metadata, schema-compliant)
-        this.agent.metadata = {
-            ...this.agent.metadata,
-            annotations: {
-                ...this.agent.metadata?.annotations,
-                'buildkit.ossa.io/testing-config': JSON.stringify(testingConfig),
-            },
-        };
-        printSuccess(`Testing configured: ${testConfig.types.join(', ')} with schema validation`);
-    }
-    async generateOutput(options) {
-        this.nextStep('Generate Output');
-        printStep(12, this.totalSteps, 'Generate Files', 'Create manifest and supporting files');
-        const outputPath = options.output || 'agent.ossa.yaml';
-        // Write manifest
-        const yamlContent = yaml.stringify(this.agent, {
-            indent: 2,
-            lineWidth: 0,
-        });
-        fs.writeFileSync(outputPath, yamlContent, 'utf-8');
-        printSuccess(`Agent manifest: ${outputPath}`);
-        // Generate supporting files if extensions enabled
-        const directory = path.dirname(outputPath);
-        if (this.agent.extensions?.agents_md) {
-            this.generateAgentsMd(directory);
-        }
-        if (this.agent.extensions?.llms_txt) {
-            this.generateLlmsTxt(directory);
-        }
-        printSuccess('All files generated successfully');
-        console.log('');
-        console.log('Next steps:');
-        console.log(`  1. Validate: ossa validate ${outputPath}`);
-        console.log(`  2. Score:    ossa lifecycle score ${outputPath}`);
-        console.log(`  3. Export:   ossa export ${outputPath} --platform docker`);
-        console.log(`  4. Register: ossa lifecycle duadp-register <name>`);
-    }
-    generateAgentsMd(directory) {
-        const agentsMdPath = path.join(directory, 'AGENTS.md');
-        const content = `# ${this.agent.metadata?.name}
-
-${this.agent.metadata?.description}
-
-## Schema Validation
-
-✓ Validated against OSSA v0.4 OpenAPI schema
-✓ All fields conform to specification
-✓ Type-safe and production-ready
-
-## Configuration
-
-See \`agent.ossa.yaml\` for complete manifest.
-
----
-
-*Generated by OSSA Wizard - API-First Edition*
-*Schema-validated: ${new Date().toISOString()}*
-`;
-        fs.writeFileSync(agentsMdPath, content, 'utf-8');
-        printSuccess(`AGENTS.md: ${agentsMdPath}`);
-    }
-    generateLlmsTxt(directory) {
-        const llmsTxtPath = path.join(directory, 'llms.txt');
-        const content = `# ${this.agent.metadata?.name}
-
-Schema: OSSA v0.4
-Validated: ${new Date().toISOString()}
-
-## Agent Type
-
-${this.agent.kind}
-
-## LLM Configuration
-
-Provider: ${this.agent.spec?.llm?.provider}
-Model: ${this.agent.spec?.llm?.model}
-
----
-
-For complete specification, see agent.ossa.yaml
-`;
-        fs.writeFileSync(llmsTxtPath, content, 'utf-8');
-        printSuccess(`llms.txt: ${llmsTxtPath}`);
-    }
-    printNextSteps() {
-        console.log(chalk.cyan('\nNext Steps:'));
-        console.log(chalk.white('\n1. Validate (already done!)'));
-        console.log(chalk.green('   ✓ Schema validation passed'));
-        console.log(chalk.white('\n2. Test your agent:'));
-        console.log(chalk.gray('   ossa run agent.ossa.yaml'));
-        console.log(chalk.white('\n3. Export to platform:'));
-        console.log(chalk.gray('   ossa export agent.ossa.yaml --platform langchain'));
-        console.log(chalk.white('\n4. Deploy:'));
-        console.log(chalk.gray('   # Follow platform-specific guide'));
-        console.log('');
-        console.log(chalk.green.bold('🎉 Schema-validated agent ready for production!'));
-        console.log('');
-    }
-}
-export const wizardAPIFirstCommand = new Command('wizard-api-first')
-    .alias('wizard')
-    .description('🧙 OSSA Wizard - API-FIRST EDITION (Schema-Driven)')
-    .option('-o, --output <path>', 'Output file path', 'agent.ossa.yaml')
-    .option('-t, --template <id>', 'Use specific template (future)')
-    .option('--validate', 'Extra validation (redundant - always validates)', true)
-    .action(async (options) => {
-    const wizard = new APIFirstWizard();
-    await wizard.run(options);
-});
-//# sourceMappingURL=wizard-api-first.command.js.map