@bluefly/openstandardagents 0.4.4 → 0.4.6

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

@@ -28,19 +28,156 @@ import { KubernetesManifestGenerator } from '../../adapters/kubernetes/generator
 import { KAgentCRDGenerator } from '../../sdks/kagent/crd-generator.js';
 import { registry } from '../../adapters/registry/platform-registry.js';
 import { DrupalManifestExporter } from '../../adapters/drupal/manifest-exporter.js';
-import { addGlobalOptions, addMutationOptions, shouldUseColor, } from '../utils/standard-options.js';
+import { OpenAIAgentsAdapter } from '../../adapters/openai-agents/adapter.js';
+import { generatePerfectAgentBundle } from '../../adapters/base/common-file-generator.js';
+import { getPlatformsForExport } from '../../data/platform-matrix.js';
+import { addGlobalOptions, addMutationOptions, addBackupOptions, shouldUseColor, } from '../utils/standard-options.js';
 export const exportCommand = new Command('export')
     .description('Export OSSA manifest to platform-specific format')
-    .argument('<manifest>', 'Path to OSSA agent manifest')
-    .requiredOption('-p, --platform <platform>', 'Target platform (kagent, langchain, crewai, temporal, n8n, gitlab, gitlab-agent, docker, kubernetes, npm, drupal, agent-skills)')
+    .argument('[manifest]', 'Path to OSSA agent manifest')
+    .option('-p, --platform <platform>', 'Target platform (kagent, langchain, langflow, crewai, symfony, temporal, n8n, gitlab, gitlab-agent, docker, kubernetes, npm, drupal, orchestration, agent-skills)')
     .option('-o, --output <file>', 'Output file path')
     .option('--format <format>', 'Output format (yaml, json, python)', 'yaml')
-    .option('--skill', 'Include Claude Skill (SKILL.md) - NPM platform only');
+    .option('--crd-version <version>', 'Kagent CRD version (v1alpha1 | v1alpha2). v1alpha2 = Declarative Agent for native kagent installs', 'v1alpha1')
+    .option('--namespace <ns>', 'Kubernetes/kagent namespace (kagent platform)', 'kagent')
+    .option('--skill', 'Include Claude Skill (SKILL.md) - NPM platform only')
+    .option('--perfect-agent', 'Enable full "perfect agent" export (AGENTS.md, team scaffolding, evals, governance, observability)')
+    .option('--include-agent-card', 'Generate .well-known/agent-card.json')
+    .option('--include-agents-md', 'Include AGENTS.md team documentation')
+    .option('--include-team', 'Include multi-agent team scaffolding')
+    .option('--include-evals', 'Include CLEAR framework eval stubs')
+    .option('--include-governance', 'Include compliance/policy config')
+    .option('--include-observability', 'Include OTel observability config')
+    .option('--list-platforms', 'Show all supported export platforms and their status')
+    .option('--save-to-gitlab', 'Trigger openstandard-generated-agents GitLab pipeline to build and persist this agent')
+    .option('--gitlab-project <path>', 'GitLab project path or ID for generated agents (env: EXPORT_GITLAB_PROJECT_PATH)');
 // Add production-grade standard options
 addGlobalOptions(exportCommand);
 addMutationOptions(exportCommand);
+addBackupOptions(exportCommand);
+// Add validation skip option
+exportCommand.option('--no-validate', 'Skip manifest validation before export');
 exportCommand.action(async (manifestPath, options) => {
     const useColor = shouldUseColor(options);
+    // Handle --save-to-gitlab (trigger openstandard-generated-agents pipeline)
+    if (options.saveToGitlab) {
+        if (!manifestPath) {
+            console.error(useColor
+                ? chalk.red('Error: manifest path is required for --save-to-gitlab')
+                : 'Error: manifest path is required for --save-to-gitlab');
+            process.exit(1);
+        }
+        const token = process.env.EXPORT_TRIGGER_TOKEN ||
+            process.env.GITLAB_TOKEN ||
+            process.env.GITLAB_TOKEN_PAT;
+        const projectParam = options.gitlabProject ||
+            process.env.EXPORT_GITLAB_PROJECT_PATH ||
+            process.env.EXPORT_GITLAB_PROJECT_ID ||
+            process.env.EXPORT_GITLAB_PROJECT_PATH || 'my-org%2Fossa%2Fgenerated-agents';
+        const ref = process.env.EXPORT_REF || 'main';
+        const platform = options.platform || 'docker';
+        const platforms = process.env.EXPORT_PLATFORMS;
+        if (!token) {
+            console.error(useColor
+                ? chalk.red('Error: Set EXPORT_TRIGGER_TOKEN or GITLAB_TOKEN for --save-to-gitlab')
+                : 'Error: Set EXPORT_TRIGGER_TOKEN or GITLAB_TOKEN for --save-to-gitlab');
+            process.exit(1);
+        }
+        try {
+            const raw = fs.readFileSync(path.resolve(process.cwd(), manifestPath), 'utf-8');
+            const base64 = Buffer.from(raw.trim(), 'utf-8').toString('base64');
+            const agentName = (raw.match(/name\s*:\s*["']?([a-zA-Z0-9_-]+)/m) || [])[1] ||
+                'incoming';
+            const safeName = agentName.replace(/[^a-zA-Z0-9_-]/g, '-').slice(0, 64);
+            const form = new URLSearchParams();
+            form.set('token', token);
+            form.set('ref', ref);
+            form.set('variables[EXPORT_MANIFEST_BASE64]', base64);
+            form.set('variables[EXPORT_PLATFORM]', platform);
+            form.set('variables[EXPORT_AGENT_NAME]', safeName);
+            if (platforms && platforms.length > 0) {
+                form.set('variables[EXPORT_PLATFORMS]', platforms);
+            }
+            const projectId = /^\d+$/.test(String(projectParam).trim())
+                ? String(projectParam).trim()
+                : projectParam;
+            const res = await fetch(`https://gitlab.com/api/v4/projects/${projectId}/trigger/pipeline`, { method: 'POST', body: form });
+            if (!res.ok) {
+                const text = await res.text();
+                console.error(useColor
+                    ? chalk.red(`GitLab trigger failed: ${res.status}`)
+                    : `GitLab trigger failed: ${res.status}`, text);
+                process.exit(1);
+            }
+            const pipeline = (await res.json());
+            if (!options.quiet) {
+                console.log(useColor
+                    ? chalk.green(`Triggered openstandard-generated-agents pipeline: ${pipeline.web_url ?? pipeline.id ?? 'started'}`)
+                    : `Triggered openstandard-generated-agents pipeline: ${pipeline.web_url ?? pipeline.id ?? 'started'}`);
+            }
+            if (options.json) {
+                console.log(JSON.stringify({
+                    success: true,
+                    saveToGitlab: true,
+                    pipelineId: pipeline.id,
+                    webUrl: pipeline.web_url,
+                }, null, options.quiet ? 0 : 2));
+            }
+            if (!options.platform) {
+                return;
+            }
+        }
+        catch (err) {
+            console.error(chalk.red(`Save to GitLab failed: ${err instanceof Error ? err.message : String(err)}`));
+            process.exit(1);
+        }
+    }
+    // Handle --list-platforms (single source of truth: platform-matrix)
+    if (options.listPlatforms) {
+        const platforms = getPlatformsForExport();
+        console.log(useColor
+            ? chalk.bold('\nOSSA Export Platforms\n')
+            : '\nOSSA Export Platforms\n');
+        for (const p of platforms) {
+            const statusColor = p.status === 'production'
+                ? chalk.green
+                : p.status === 'beta'
+                    ? chalk.yellow
+                    : p.status === 'alpha'
+                        ? chalk.magenta
+                        : chalk.gray;
+            const statusLabel = useColor
+                ? statusColor(`[${p.status}]`)
+                : `[${p.status}]`;
+            const nameLabel = useColor
+                ? chalk.cyan(p.id.padEnd(20))
+                : p.id.padEnd(20);
+            console.log(`  ${nameLabel} ${statusLabel.padEnd(useColor ? 30 : 14)} ${p.description}`);
+        }
+        console.log('');
+        return;
+    }
+    // Validate required args when not listing platforms
+    if (!manifestPath) {
+        console.error(useColor
+            ? chalk.red('Error: manifest path is required')
+            : 'Error: manifest path is required');
+        process.exit(1);
+    }
+    const hasPerfectAgentOnly = !options.platform &&
+        (options.perfectAgent ||
+            options.includeAgentCard ||
+            options.includeAgentsMd ||
+            options.includeEvals ||
+            options.includeGovernance ||
+            options.includeObservability ||
+            options.includeTeam);
+    if (!options.platform && !hasPerfectAgentOnly) {
+        console.error(useColor
+            ? chalk.red('Error: --platform is required. Use --list-platforms to see available platforms.')
+            : 'Error: --platform is required');
+        process.exit(1);
+    }
     try {
         // Logging helpers
         const log = (msg) => {
@@ -70,15 +207,87 @@ exportCommand.action(async (manifestPath, options) => {
         // Load manifest
         const manifestRepo = container.get(ManifestRepository);
         const manifest = await manifestRepo.load(manifestPath);
+        // Perfect Agent generation (standalone or appended to platform export)
+        const hasPerfectAgentFlags = options.perfectAgent ||
+            options.includeAgentCard ||
+            options.includeAgentsMd ||
+            options.includeEvals ||
+            options.includeGovernance ||
+            options.includeObservability ||
+            options.includeTeam;
+        if (hasPerfectAgentFlags) {
+            const { generatePerfectAgentFiles } = await import('../../adapters/base/common-file-generator.js');
+            const perfectOpts = {
+                includeAgentCard: options.perfectAgent || options.includeAgentCard,
+                includeAgentsMd: options.perfectAgent || options.includeAgentsMd,
+                includeEvals: options.perfectAgent || options.includeEvals,
+                includeGovernance: options.perfectAgent || options.includeGovernance,
+                includeObservability: options.perfectAgent || options.includeObservability,
+                includeSkill: options.perfectAgent || options.skill,
+                includeTeam: options.perfectAgent || options.includeTeam,
+                platform: options.platform,
+            };
+            log(options.perfectAgent
+                ? 'Generating Perfect Agent structure...'
+                : 'Generating selected agent artifacts...');
+            const perfectFiles = await generatePerfectAgentFiles(manifest, perfectOpts);
+            if (perfectFiles.length > 0) {
+                const agentName = manifest.metadata?.name || 'agent';
+                const outputDir = options.output || `./${agentName}`;
+                if (!options.dryRun) {
+                    for (const file of perfectFiles) {
+                        const filePath = path.join(outputDir, file.path);
+                        const fileDir = path.dirname(filePath);
+                        fs.mkdirSync(fileDir, { recursive: true });
+                        fs.writeFileSync(filePath, file.content);
+                        logVerbose(`  Created: ${file.path}`);
+                    }
+                    logSuccess(`\nPerfect Agent artifacts: ${perfectFiles.length} files`);
+                }
+                else {
+                    log(`\nDRY RUN: Would generate ${perfectFiles.length} Perfect Agent files:`);
+                    for (const file of perfectFiles) {
+                        logVerbose(`  - ${file.path} (${file.content.length} bytes)`);
+                    }
+                }
+                // If no platform specified, we're done
+                if (!options.platform || options.platform === 'perfect-agent') {
+                    return;
+                }
+            }
+        }
         let output;
         let defaultExtension;
         switch (options.platform) {
             case 'kagent': {
-                log('Generating kagent.dev Kubernetes manifest bundle...');
-                const kagentGenerator = new KAgentCRDGenerator();
-                const bundle = kagentGenerator.generateBundle(manifest);
                 const agentName = manifest.metadata?.name || 'agent';
                 const outputDir = options.output || `./${agentName}-kagent`;
+                const useV1Alpha2 = (options.crdVersion ?? 'v1alpha1') === 'v1alpha2';
+                const kagentOpts = {
+                    namespace: options.namespace || 'kagent',
+                };
+                if (useV1Alpha2) {
+                    log('Generating kagent.dev v1alpha2 Declarative Agent...');
+                    const kagentGenerator = new KAgentCRDGenerator();
+                    const { agent, modelConfig } = kagentGenerator.generateV1Alpha2(manifest, kagentOpts);
+                    if (!options.dryRun) {
+                        fs.mkdirSync(outputDir, { recursive: true });
+                        fs.writeFileSync(path.join(outputDir, 'agent.yaml'), yaml.stringify(agent));
+                        if (modelConfig) {
+                            fs.writeFileSync(path.join(outputDir, 'model-config.yaml'), yaml.stringify(modelConfig));
+                        }
+                        fs.writeFileSync(path.join(outputDir, 'agent.ossa.yaml'), yaml.stringify(manifest));
+                        logSuccess(`\nkagent.dev v1alpha2 bundle exported to: ${outputDir}`);
+                        log(`  agent.yaml${modelConfig ? ', model-config.yaml' : ''}, agent.ossa.yaml`);
+                    }
+                    else {
+                        log(`\nDRY RUN: Would write agent.yaml (v1alpha2) to ${outputDir}`);
+                    }
+                    return;
+                }
+                log('Generating kagent.dev Kubernetes manifest bundle (v1alpha1)...');
+                const kagentGenerator = new KAgentCRDGenerator();
+                const bundle = kagentGenerator.generateBundle(manifest, kagentOpts);
                 if (!options.dryRun) {
                     fs.mkdirSync(outputDir, { recursive: true });
                     // Write CRD
@@ -137,6 +346,30 @@ exportCommand.action(async (manifestPath, options) => {
                     }
                     logSuccess(`\nLangChain package exported to: ${langchainOutputDir}`);
                     log(`  ${langchainResult.files.length} files generated`);
+                    // Perfect agent supplementary files
+                    if (options.perfectAgent ||
+                        options.includeTeam ||
+                        options.includeAgentsMd ||
+                        options.includeEvals) {
+                        const perfectFiles = generatePerfectAgentBundle(manifest, {
+                            perfectAgent: options.perfectAgent,
+                            includeTeam: options.includeTeam,
+                            includeEvals: options.includeEvals,
+                            includeAgentsMd: options.includeAgentsMd,
+                            includeGovernance: options.includeGovernance,
+                            includeObservability: options.includeObservability,
+                        }, 'langchain');
+                        for (const file of perfectFiles) {
+                            const filePath = path.join(langchainOutputDir, file.path);
+                            const fileDir = path.dirname(filePath);
+                            fs.mkdirSync(fileDir, { recursive: true });
+                            fs.writeFileSync(filePath, file.content);
+                            logVerbose(`  Created: ${file.path}`);
+                        }
+                        if (perfectFiles.length > 0) {
+                            logSuccess(`  + ${perfectFiles.length} perfect agent files`);
+                        }
+                    }
                 }
                 else {
                     log(`\nDRY RUN: Would generate ${langchainResult.files.length} files in: ${langchainOutputDir}`);
@@ -147,6 +380,45 @@ exportCommand.action(async (manifestPath, options) => {
                 }
                 return;
             }
+            case 'langflow': {
+                log('Exporting OSSA manifest to Langflow flow JSON...');
+                const langflowAdapter = registry.getAdapter('langflow');
+                if (!langflowAdapter) {
+                    throw new Error('LangFlow adapter not registered. Ensure initializeAdapters() was called.');
+                }
+                const langflowResult = await langflowAdapter.export(manifest, {
+                    validate: options.validate !== false,
+                    dryRun: options.dryRun,
+                    outputDir: options.output ? path.dirname(options.output) : '.',
+                });
+                if (!langflowResult.success) {
+                    throw new Error(langflowResult.error || 'LangFlow export failed');
+                }
+                const outDir = options.output ? path.dirname(options.output) : '.';
+                const outPath = options.output ||
+                    path.join(outDir, langflowResult.files[0]?.path ||
+                        `${(manifest.metadata?.name || 'agent').replace(/[^a-z0-9-_]/gi, '-')}-langflow.json`);
+                if (!options.dryRun && langflowResult.files.length > 0) {
+                    const outDirAbs = path.dirname(outPath);
+                    if (outDirAbs !== '.')
+                        fs.mkdirSync(outDirAbs, { recursive: true });
+                    fs.writeFileSync(outPath, langflowResult.files[0].content, 'utf-8');
+                    logSuccess(`\nLangflow flow exported to: ${outPath}`);
+                    log(useColor
+                        ? chalk.gray('  Import in Langflow: Projects > Upload a flow, or drag-and-drop the JSON file.')
+                        : '  Import in Langflow: Projects > Upload a flow, or drag-and-drop the JSON file.');
+                    log(useColor
+                        ? chalk.gray('  Langflow: http://127.0.0.1:7860 (or set LANGFLOW_URL env)')
+                        : '  Langflow: http://127.0.0.1:7860 (or set LANGFLOW_URL env)');
+                }
+                else if (options.dryRun) {
+                    log(`\nDRY RUN: Would write Langflow JSON to: ${outPath}`);
+                }
+                if (options.json && langflowResult.files[0]) {
+                    console.log(JSON.stringify(JSON.parse(langflowResult.files[0].content)));
+                }
+                return;
+            }
             case 'crewai': {
                 log('Generating CrewAI multi-agent package...');
                 const crewaiAdapter = new CrewAIAdapter();
@@ -157,8 +429,7 @@ exportCommand.action(async (manifestPath, options) => {
                 if (!crewaiResult.success) {
                     throw new Error(crewaiResult.error || 'CrewAI export failed');
                 }
-                const crewaiOutputDir = options.output ||
-                    `./crewai-${manifest.metadata?.name || 'agent'}`;
+                const crewaiOutputDir = options.output || `./crewai-${manifest.metadata?.name || 'agent'}`;
                 if (!options.dryRun) {
                     fs.mkdirSync(crewaiOutputDir, { recursive: true });
                     for (const file of crewaiResult.files) {
@@ -178,6 +449,30 @@ exportCommand.action(async (manifestPath, options) => {
                     log('  - examples/ (usage examples)');
                     log('  - tests/ (test suite)');
                     log('  - README.md, DEPLOYMENT.md');
+                    // Perfect agent supplementary files
+                    if (options.perfectAgent ||
+                        options.includeTeam ||
+                        options.includeAgentsMd ||
+                        options.includeEvals) {
+                        const perfectFiles = generatePerfectAgentBundle(manifest, {
+                            perfectAgent: options.perfectAgent,
+                            includeTeam: options.includeTeam,
+                            includeEvals: options.includeEvals,
+                            includeAgentsMd: options.includeAgentsMd,
+                            includeGovernance: options.includeGovernance,
+                            includeObservability: options.includeObservability,
+                        }, 'crewai');
+                        for (const file of perfectFiles) {
+                            const filePath = path.join(crewaiOutputDir, file.path);
+                            const fileDir = path.dirname(filePath);
+                            fs.mkdirSync(fileDir, { recursive: true });
+                            fs.writeFileSync(filePath, file.content);
+                            logVerbose(`  Created: ${file.path}`);
+                        }
+                        if (perfectFiles.length > 0) {
+                            logSuccess(`  + ${perfectFiles.length} perfect agent files`);
+                        }
+                    }
                 }
                 else {
                     log(`\nDRY RUN: Would generate ${crewaiResult.files.length} files in: ${crewaiOutputDir}`);
@@ -224,9 +519,11 @@ exportCommand.action(async (manifestPath, options) => {
                 const result = await duoGenerator.generate(manifest, {
                     outputDir: path.dirname(outputDir),
                     overwrite: true,
+                    includeSourceTemplates: true,
                 });
                 if (!result.success) {
-                    throw new Error(result.errors?.join(', ') || 'GitLab Duo package generation failed');
+                    throw new Error(result.errors?.join(', ') ||
+                        'GitLab Duo package generation failed');
                 }
                 if (!options.dryRun) {
                     logSuccess(`✓ GitLab Duo package exported to: ${result.packagePath}`);
@@ -386,6 +683,120 @@ exportCommand.action(async (manifestPath, options) => {
                 }
                 return; // Early return to skip single-file write
             }
+            case 'orchestration':
+            case 'drupal-orchestration': {
+                log('Generating Drupal manifest package + orchestration stub (drupal/orchestration)...');
+                const drupalExporter = new DrupalManifestExporter();
+                const drupalResult = await drupalExporter.export(manifest, {
+                    validate: true,
+                });
+                if (!drupalResult.success) {
+                    throw new Error(drupalResult.error || 'Drupal manifest export failed');
+                }
+                const files = Array.isArray(drupalResult.files)
+                    ? drupalResult.files
+                    : [];
+                const agentName = manifest.metadata?.name
+                    ?.toLowerCase()
+                    .replace(/[^a-z0-9_]/g, '_') || 'ossa_agent';
+                const outputDir = options.output || `./${agentName}-orchestration`;
+                const orchestrationSchema = {
+                    service_id: 'ossa_invoke_agent',
+                    provider_id: 'ai_agents_ossa_orchestration',
+                    label: 'OSSA: Invoke Agent',
+                    description: 'Invoke an OSSA agent by ID with a prompt. Requires ai_agents_ossa_orchestration enabled.',
+                    config: {
+                        agent_id: {
+                            key: 'agent_id',
+                            label: 'OSSA Agent ID',
+                            description: 'The OSSA agent config entity ID (e.g. from GET /orchestration/services)',
+                            required: true,
+                            type: 'string',
+                        },
+                        prompt: {
+                            key: 'prompt',
+                            label: 'Prompt / Input',
+                            description: 'The input text or task to send to the agent',
+                            required: true,
+                            type: 'string',
+                        },
+                    },
+                    execute_url: '/orchestration/service/execute',
+                    body_example: {
+                        id: 'ai_agents_ossa_orchestration::ossa_invoke_agent',
+                        config: { agent_id: agentName, prompt: 'Your task here' },
+                    },
+                };
+                const orchestrationReadme = `# Drupal orchestration (drupal/orchestration)
+
+This package was exported with \`ossa export --platform orchestration\`.
+It includes the Drupal manifest and an orchestration service descriptor so you can invoke this OSSA agent from Activepieces, n8n, Zapier, or any client of drupal/orchestration.
+
+## Full flow (summary)
+
+1. Export: \`ossa export manifest.ossa.yaml --platform orchestration -o ./out\` (done).
+2. Drupal: enable orchestration + ai_agents_ossa + ai_agents_ossa_flowdrop + ai_agents_ossa_orchestration; import this agent; grant "Use orchestration" to a role.
+3. List services: GET \`{BASE}/orchestration/services\` (with auth).
+4. Execute: POST \`{BASE}/orchestration/service/execute\` with body below.
+5. n8n/Zapier: same HTTP API (GET list, POST execute) with Basic Auth or cookie.
+
+## Requirements
+
+- Drupal 10+ with \`drupal/orchestration\`, \`drupal/ai_agents_ossa\`, \`ai_agents_ossa_flowdrop\`, \`ai_agents_ossa_orchestration\`
+- Enable: \`drush en orchestration ai_agents_ossa ai_agents_ossa_flowdrop ai_agents_ossa_orchestration -y\`
+- Import this agent so it appears in the list: \`drush ai-agents:import\` with the manifest from this package (or use the Drupal UI). The agent ID (e.g. \`${agentName}\`) is the \`agent_id\` you pass in execute.
+
+## Orchestration API
+
+- **List services:** \`GET /orchestration/services\` (permission: use orchestration)
+- **Execute service:** \`POST /orchestration/service/execute\`
+  - Body: \`{"id": "ai_agents_ossa_orchestration::ossa_invoke_agent", "config": {"agent_id": "${agentName}", "prompt": "Your task"}}\`
+
+The \`ossa_invoke_agent\` service is provided by \`ai_agents_ossa_orchestration\` and lists all OSSA agents as choices for \`agent_id\`.
+
+## curl examples (replace BASE and user:password)
+
+  BASE=https://your-drupal-site.ddev.site
+
+  # List services
+  curl -s -u "user:password" "$BASE/orchestration/services" | jq
+
+  # Execute this agent
+  curl -s -X POST -u "user:password" -H "Content-Type: application/json" \\
+    -d '{"id":"ai_agents_ossa_orchestration::ossa_invoke_agent","config":{"agent_id":"${agentName}","prompt":"Summarize in one sentence."}}' \\
+    "$BASE/orchestration/service/execute"
+
+## n8n / Activepieces / Zapier
+
+1. Base URL = your Drupal site. Auth = user with "Use orchestration" (Basic Auth or cookie).
+2. GET \`/orchestration/services\` to discover services; find the one with id containing \`ossa_invoke_agent\`.
+3. POST to \`/orchestration/service/execute\` with \`id\` = \`ai_agents_ossa_orchestration::ossa_invoke_agent\` and \`config\` = \`{ "agent_id": "${agentName}", "prompt": "..." }\`.
+
+See also: https://www.drupal.org/project/orchestration
+`;
+                if (!options.dryRun) {
+                    fs.mkdirSync(outputDir, { recursive: true });
+                    for (const file of files) {
+                        const filePath = path.join(outputDir, file.path);
+                        const fileDir = path.dirname(filePath);
+                        fs.mkdirSync(fileDir, { recursive: true });
+                        fs.writeFileSync(filePath, file.content);
+                        logVerbose(`  Created: ${file.path}`);
+                    }
+                    fs.mkdirSync(path.join(outputDir, 'orchestration'), {
+                        recursive: true,
+                    });
+                    fs.writeFileSync(path.join(outputDir, 'orchestration/ossa_invoke_agent.schema.json'), JSON.stringify(orchestrationSchema, null, 2));
+                    fs.writeFileSync(path.join(outputDir, 'ORCHESTRATION.md'), orchestrationReadme);
+                    logSuccess(`\nOrchestration package exported to: ${outputDir}`);
+                    log(`  Drupal manifest + orchestration/ossa_invoke_agent.schema.json, ORCHESTRATION.md`);
+                    log('  Enable ai_agents_ossa_orchestration and use POST /orchestration/service/execute');
+                }
+                else {
+                    log(`\nDRY RUN: Would generate ${files.length + 2} files in: ${outputDir}`);
+                }
+                return;
+            }
             case 'agent-skills': {
                 log('Generating Agent Skills package (SKILL.md format)...');
                 // Use AgentSkillsExporter for complete skills package
@@ -425,13 +836,114 @@ exportCommand.action(async (manifestPath, options) => {
                 }
                 else {
                     log('DRY RUN: Would generate:');
-                    result.files.forEach(file => log(`  - ${file.path}`));
+                    result.files.forEach((file) => log(`  - ${file.path}`));
+                }
+                return; // Early return to skip single-file write
+            }
+            case 'symfony': {
+                log('Exporting OSSA manifest to Symfony AI Agent (PHP bootstrap)...');
+                const symfonyAdapter = registry.getAdapter('symfony');
+                if (!symfonyAdapter) {
+                    throw new Error('Symfony adapter not registered. Ensure initializeAdapters() was called.');
+                }
+                const symfonyResult = await symfonyAdapter.export(manifest, {
+                    validate: options.validate !== false,
+                });
+                if (!symfonyResult.success) {
+                    throw new Error(symfonyResult.error || 'Symfony export failed');
+                }
+                const symfonyName = (manifest.metadata?.name || 'agent')
+                    .toLowerCase()
+                    .replace(/[^a-z0-9_]/g, '_') || 'ossa_agent';
+                const symfonyOutputDir = options.output || `./${symfonyName}`;
+                if (!options.dryRun && symfonyResult.files.length > 0) {
+                    fs.mkdirSync(symfonyOutputDir, { recursive: true });
+                    for (const file of symfonyResult.files) {
+                        const filePath = path.join(symfonyOutputDir, file.path);
+                        const fileDir = path.dirname(filePath);
+                        fs.mkdirSync(fileDir, { recursive: true });
+                        fs.writeFileSync(filePath, file.content);
+                        logVerbose(`  Created: ${file.path}`);
+                    }
+                    logSuccess(`\nSymfony AI Agent package exported to: ${symfonyOutputDir}`);
+                    log(`  ${symfonyResult.files.length} files generated`);
+                    log('  Run: composer require symfony/ai-agent symfony/ai-platform');
+                }
+                else if (options.dryRun) {
+                    log(`\nDRY RUN: Would generate ${symfonyResult.files.length} files in: ${symfonyOutputDir}`);
+                    symfonyResult.files.forEach((f) => logVerbose(`  - ${f.path}`));
+                }
+                return;
+            }
+            case 'openai-agents-sdk': {
+                log('Generating OpenAI Agents SDK package from OSSA manifest...');
+                const openaiAdapter = new OpenAIAgentsAdapter();
+                const openaiResult = await openaiAdapter.export(manifest, {
+                    validate: true,
+                });
+                if (!openaiResult.success) {
+                    throw new Error(openaiResult.error || 'OpenAI Agents SDK export failed');
+                }
+                const openaiAgentName = manifest.metadata?.name
+                    ?.toLowerCase()
+                    .replace(/[^a-z0-9-]/g, '-') || 'openai-agent';
+                const openaiOutputDir = options.output || openaiAgentName;
+                if (!options.dryRun) {
+                    const fsSync = await import('fs');
+                    for (const file of openaiResult.files) {
+                        const filePath = path.join(openaiOutputDir, file.path);
+                        const dir = path.dirname(filePath);
+                        if (!fsSync.existsSync(dir)) {
+                            fsSync.mkdirSync(dir, { recursive: true });
+                        }
+                        fsSync.writeFileSync(filePath, file.content);
+                        log(`  Created: ${filePath}`);
+                    }
+                    log(`\nOpenAI Agents SDK package generated at: ${openaiOutputDir}/`);
+                    log(`Run: cd ${openaiOutputDir} && npm install && npx tsx src/run.ts "Hello"`);
+                }
+                else {
+                    log('DRY RUN: Would generate:');
+                    openaiResult.files.forEach((file) => log(`  - ${file.path}`));
                 }
                 return; // Early return to skip single-file write
             }
             default:
                 throw new Error(`Unsupported platform: ${options.platform}`);
         }
+        // Generate perfect agent supplementary files if requested
+        if (options.perfectAgent ||
+            options.includeTeam ||
+            options.includeEvals ||
+            options.includeAgentsMd ||
+            options.includeGovernance ||
+            options.includeObservability) {
+            const perfectFiles = generatePerfectAgentBundle(manifest, {
+                perfectAgent: options.perfectAgent,
+                includeTeam: options.includeTeam,
+                includeEvals: options.includeEvals,
+                includeAgentsMd: options.includeAgentsMd,
+                includeGovernance: options.includeGovernance,
+                includeObservability: options.includeObservability,
+            });
+            if (perfectFiles.length > 0) {
+                const perfectDir = options.output || `./${manifest.metadata?.name || 'agent'}-perfect`;
+                if (!options.dryRun) {
+                    fs.mkdirSync(perfectDir, { recursive: true });
+                    for (const file of perfectFiles) {
+                        const filePath = path.join(perfectDir, file.path);
+                        const fileDir = path.dirname(filePath);
+                        fs.mkdirSync(fileDir, { recursive: true });
+                        fs.writeFileSync(filePath, file.content);
+                        logVerbose(`  Created: ${file.path}`);
+                    }
+                    logSuccess(`\nPerfect agent files generated: ${perfectFiles.length} files in ${perfectDir}`);
+                }
+                else {
+                    log(`\nDRY RUN: Would generate ${perfectFiles.length} perfect agent files`);
+                }
+            }
+        }
         // Determine output file
         const outputFile = options.output ||
             `${manifest.metadata?.name || 'agent'}.${defaultExtension}`;
@@ -447,23 +959,26 @@ exportCommand.action(async (manifestPath, options) => {
         }
         // Write output (or simulate if dry-run)
         if (options.dryRun) {
-            log(`\n📄 Would write to: ${outputPath}`);
-            logVerbose(`Output size: ${output.length} bytes`);
-            if (options.verbose) {
-                log('\n--- Preview (first 500 chars) ---');
-                console.log(output.substring(0, 500));
-                if (output.length > 500) {
-                    console.log('...');
-                }
-                log('--- End Preview ---\n');
+            if (!options.json) {
+                log(`\n📄 Would write to: ${outputPath}`);
+                logVerbose(`Output size: ${output.length} bytes`);
+                if (options.verbose) {
+                    log('\n--- Preview (first 500 chars) ---');
+                    console.log(output.substring(0, 500));
+                    if (output.length > 500) {
+                        console.log('...');
+                    }
+                    log('--- End Preview ---\n');
+                }
             }
         }
         else {
             fs.writeFileSync(outputPath, output);
-            logSuccess(`✓ Exported to: ${outputPath}`);
-            logVerbose(`Output size: ${output.length} bytes`);
+            if (!options.json) {
+                logSuccess(`✓ Exported to: ${outputPath}`);
+                logVerbose(`Output size: ${output.length} bytes`);
+            }
         }
-        // JSON output for automation
         if (options.json) {
             const result = {
                 success: true,
@@ -473,7 +988,7 @@ exportCommand.action(async (manifestPath, options) => {
                 dryRun: options.dryRun || false,
                 size: output.length,
             };
-            console.log(JSON.stringify(result, null, 2));
+            console.log(JSON.stringify(result, null, options.quiet ? 0 : 2));
         }
     }
     catch (error) {