@bluefly/openstandardagents 0.4.4 → 0.4.6

package/dist/cli/commands/agents-local.command.js

@@ -0,0 +1,281 @@
+/**
+ * Local .agents/ folder management commands
+ * Manages the flat agent structure: .agents/<name>/agent.ossa.yaml
+ */
+import chalk from 'chalk';
+import { Command } from 'commander';
+import * as fs from 'fs';
+import * as path from 'path';
+import { getApiVersion } from '../../utils/version.js';
+import { AGENTS_DIR, WORKSPACE_DIR, MANIFEST_NAME, REGISTRY_NAME, } from '../../utils/constants.js';
+import { safeParseYAML, safeStringifyYAML } from '../../utils/yaml-parser.js';
+/**
+ * Initialize .agents/ structure in current project
+ */
+const initCommand = new Command('init')
+    .description('Initialize .agents/ and .agents-workspace/ in current directory')
+    .action(() => {
+    const agentsDir = path.resolve(AGENTS_DIR);
+    const workspaceDir = path.resolve(WORKSPACE_DIR);
+    if (fs.existsSync(agentsDir)) {
+        console.log(chalk.yellow(`${AGENTS_DIR}/ already exists`));
+    }
+    else {
+        fs.mkdirSync(agentsDir, { recursive: true });
+        fs.writeFileSync(path.join(agentsDir, '.gitkeep'), `# .agents/ - Agent definitions (version controlled)\n#\n# Structure:\n#   registry.yaml                  - Auto-generated agent index\n#   <agent-name>/agent.ossa.yaml   - OSSA manifest (one per agent)\n#   _shared/                       - Cross-agent resources (optional)\n`);
+        console.log(chalk.green(`Created ${AGENTS_DIR}/`));
+    }
+    if (fs.existsSync(workspaceDir)) {
+        console.log(chalk.yellow(`${WORKSPACE_DIR}/ already exists`));
+    }
+    else {
+        fs.mkdirSync(workspaceDir, { recursive: true });
+        fs.writeFileSync(path.join(workspaceDir, '.gitkeep'), `# .agents-workspace/ - Ephemeral runtime data (gitignored except this file)\n# exports/   - ossa export output\n# state/     - Runtime sessions, checkpoints\n# logs/      - Execution logs\n`);
+        console.log(chalk.green(`Created ${WORKSPACE_DIR}/`));
+    }
+    // Ensure .gitignore has workspace entry
+    const gitignorePath = path.resolve('.gitignore');
+    if (fs.existsSync(gitignorePath)) {
+        const content = fs.readFileSync(gitignorePath, 'utf-8');
+        if (!content.includes('.agents-workspace')) {
+            fs.appendFileSync(gitignorePath, '\n# Agent workspace (ephemeral)\n.agents-workspace/\n!.agents-workspace/.gitkeep\n');
+            console.log(chalk.green('Added .agents-workspace/ to .gitignore'));
+        }
+    }
+    console.log(chalk.green('\nReady. Add agents with: ossa agents add <name>'));
+});
+/**
+ * Add a new agent to .agents/
+ */
+const addCommand = new Command('add')
+    .argument('<name>', 'Agent name (kebab-case)')
+    .option('--role <role>', 'Agent role/system prompt')
+    .option('--provider <provider>', 'LLM provider', 'anthropic')
+    .option('--model <model>', 'LLM model', 'claude-sonnet-4-5-20250929')
+    .option('--kind <kind>', 'Agent kind (worker, specialist, orchestrator)')
+    .description('Create a new agent in .agents/<name>/')
+    .action((name, options) => {
+    const agentsDir = path.resolve(AGENTS_DIR);
+    if (!fs.existsSync(agentsDir)) {
+        console.error(chalk.red('No .agents/ directory. Run: ossa agents init'));
+        process.exit(1);
+    }
+    // Validate name is kebab-case
+    if (!/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/.test(name)) {
+        console.error(chalk.red('Agent name must be kebab-case (e.g., code-reviewer)'));
+        process.exit(1);
+    }
+    const agentDir = path.join(agentsDir, name);
+    if (fs.existsSync(agentDir)) {
+        console.error(chalk.red(`Agent ${name} already exists at ${agentDir}/`));
+        process.exit(1);
+    }
+    fs.mkdirSync(agentDir, { recursive: true });
+    const manifest = {
+        apiVersion: getApiVersion(),
+        kind: 'Agent',
+        metadata: {
+            name,
+            version: '1.0.0',
+            description: `${name} agent`,
+            ...(options.kind ? { agentKind: options.kind } : {}),
+            labels: {
+                category: 'general',
+            },
+        },
+        spec: {
+            role: options.role || `You are the ${name} agent.`,
+            llm: {
+                provider: options.provider || 'anthropic',
+                model: options.model || 'claude-sonnet-4-5-20250929',
+                temperature: 0.7,
+                maxTokens: 4096,
+            },
+            tools: [],
+        },
+    };
+    fs.writeFileSync(path.join(agentDir, MANIFEST_NAME), safeStringifyYAML(manifest));
+    console.log(chalk.green(`Created ${AGENTS_DIR}/${name}/${MANIFEST_NAME}`));
+    console.log(chalk.gray(`\nEdit the manifest, then run: ossa agents sync`));
+});
+/**
+ * Rebuild registry.yaml from filesystem
+ */
+const syncCommand = new Command('sync')
+    .description('Rebuild registry.yaml from .agents/ filesystem')
+    .action(() => {
+    const agentsDir = path.resolve(AGENTS_DIR);
+    if (!fs.existsSync(agentsDir)) {
+        console.error(chalk.red('No .agents/ directory. Run: ossa agents init'));
+        process.exit(1);
+    }
+    const entries = fs.readdirSync(agentsDir, { withFileTypes: true });
+    const agents = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory() ||
+            entry.name.startsWith('.') ||
+            entry.name.startsWith('_')) {
+            continue;
+        }
+        const manifestPath = path.join(agentsDir, entry.name, MANIFEST_NAME);
+        if (!fs.existsSync(manifestPath)) {
+            console.log(chalk.yellow(`Skipping ${entry.name}/ (no ${MANIFEST_NAME})`));
+            continue;
+        }
+        try {
+            const content = fs.readFileSync(manifestPath, 'utf-8');
+            const manifest = safeParseYAML(content);
+            agents.push({
+                name: manifest.metadata?.name || entry.name,
+                manifest: `${entry.name}/${MANIFEST_NAME}`,
+                kind: manifest.metadata?.agentKind,
+                labels: manifest.metadata?.labels,
+            });
+        }
+        catch (err) {
+            console.log(chalk.yellow(`Skipping ${entry.name}/ (invalid YAML)`));
+        }
+    }
+    agents.sort((a, b) => a.name.localeCompare(b.name));
+    const registry = {
+        '# Auto-generated by': 'ossa agents sync',
+        '# Do not edit manually': '',
+        version: '1.0',
+        agents: agents.map((a) => ({
+            name: a.name,
+            manifest: a.manifest,
+            ...(a.kind ? { kind: a.kind } : {}),
+            ...(a.labels && Object.keys(a.labels).length > 0
+                ? { labels: a.labels }
+                : {}),
+        })),
+    };
+    // Write clean YAML without the comment hack
+    const yamlContent = `# Auto-generated by: ossa agents sync\n# Do not edit manually\nversion: "1.0"\nagents:\n${agents
+        .map((a) => {
+        let entry = `  - name: ${a.name}\n    manifest: ${a.manifest}`;
+        if (a.kind)
+            entry += `\n    kind: ${a.kind}`;
+        if (a.labels && Object.keys(a.labels).length > 0) {
+            const labelsStr = Object.entries(a.labels)
+                .map(([k, v]) => `${k}: ${v}`)
+                .join(', ');
+            entry += `\n    labels: { ${labelsStr} }`;
+        }
+        return entry;
+    })
+        .join('\n\n')}\n`;
+    fs.writeFileSync(path.join(agentsDir, REGISTRY_NAME), yamlContent);
+    console.log(chalk.green(`Synced ${agents.length} agent(s) to ${AGENTS_DIR}/${REGISTRY_NAME}`));
+    agents.forEach((a) => {
+        console.log(chalk.gray(`  ${a.name}${a.kind ? ` (${a.kind})` : ''}`));
+    });
+});
+/**
+ * List agents from local .agents/ directory
+ */
+const localListCommand = new Command('local')
+    .description('List agents from local .agents/ directory')
+    .option('--kind <kind>', 'Filter by agent kind')
+    .option('--category <category>', 'Filter by category label')
+    .option('--json', 'Output as JSON')
+    .action((options) => {
+    const agentsDir = path.resolve(AGENTS_DIR);
+    if (!fs.existsSync(agentsDir)) {
+        console.error(chalk.red('No .agents/ directory. Run: ossa agents init'));
+        process.exit(1);
+    }
+    const registryPath = path.join(agentsDir, REGISTRY_NAME);
+    let agents = [];
+    if (fs.existsSync(registryPath)) {
+        const content = fs.readFileSync(registryPath, 'utf-8');
+        const registry = safeParseYAML(content);
+        agents = registry?.agents || [];
+    }
+    else {
+        // Fallback: scan filesystem
+        const entries = fs.readdirSync(agentsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory() ||
+                entry.name.startsWith('.') ||
+                entry.name.startsWith('_'))
+                continue;
+            const manifestPath = path.join(agentsDir, entry.name, MANIFEST_NAME);
+            if (fs.existsSync(manifestPath)) {
+                try {
+                    const manifest = safeParseYAML(fs.readFileSync(manifestPath, 'utf-8'));
+                    agents.push({
+                        name: manifest.metadata?.name || entry.name,
+                        manifest: `${entry.name}/${MANIFEST_NAME}`,
+                        kind: manifest.metadata?.agentKind,
+                        labels: manifest.metadata?.labels,
+                    });
+                }
+                catch {
+                    /* skip invalid */
+                }
+            }
+        }
+    }
+    // Apply filters
+    if (options.kind) {
+        agents = agents.filter((a) => a.kind === options.kind);
+    }
+    if (options.category) {
+        agents = agents.filter((a) => a.labels?.category === options.category);
+    }
+    if (options.json) {
+        console.log(JSON.stringify(agents, null, 2));
+        return;
+    }
+    if (agents.length === 0) {
+        console.log(chalk.yellow('No agents found'));
+        return;
+    }
+    console.log(chalk.bold(`\n${agents.length} agent(s) in ${AGENTS_DIR}/\n`));
+    for (const agent of agents) {
+        const kindBadge = agent.kind ? chalk.cyan(` [${agent.kind}]`) : '';
+        const category = agent.labels?.category
+            ? chalk.gray(` (${agent.labels.category})`)
+            : '';
+        console.log(`  ${chalk.white(agent.name)}${kindBadge}${category}`);
+        console.log(chalk.gray(`    ${agent.manifest}`));
+    }
+    console.log('');
+});
+/**
+ * Export a specific agent from .agents/
+ */
+const exportAgentCommand = new Command('export-agent')
+    .argument('<name>', 'Agent name from .agents/')
+    .requiredOption('-p, --platform <platform>', 'Target platform')
+    .option('-o, --output <dir>', 'Output directory')
+    .description('Export an agent from .agents/ to a platform')
+    .action(async (name, options) => {
+    const manifestPath = path.resolve(AGENTS_DIR, name, MANIFEST_NAME);
+    if (!fs.existsSync(manifestPath)) {
+        console.error(chalk.red(`Agent not found: ${AGENTS_DIR}/${name}/${MANIFEST_NAME}`));
+        process.exit(1);
+    }
+    const outputDir = options.output ||
+        `.agents-workspace/exports/${name}-${options.platform}`;
+    // Delegate to the existing export command
+    console.log(chalk.blue(`Exporting ${name} to ${options.platform}...`));
+    const { execSync } = await import('child_process');
+    try {
+        execSync(`node ${path.resolve('dist/cli/index.js')} export "${manifestPath}" -p ${options.platform} -o "${outputDir}" --verbose`, { stdio: 'inherit', cwd: process.cwd() });
+    }
+    catch {
+        process.exit(1);
+    }
+});
+/**
+ * Agents local command group
+ */
+export const agentsLocalCommandGroup = new Command('agents-local').description('Manage local .agents/ folder structure');
+agentsLocalCommandGroup.addCommand(initCommand);
+agentsLocalCommandGroup.addCommand(addCommand);
+agentsLocalCommandGroup.addCommand(syncCommand);
+agentsLocalCommandGroup.addCommand(localListCommand);
+agentsLocalCommandGroup.addCommand(exportAgentCommand);
+//# sourceMappingURL=agents-local.command.js.map

package/dist/cli/commands/agents-md.command.js

@@ -7,6 +7,7 @@ import chalk from 'chalk';
 import { container } from '../../di-container.js';
 import { ManifestRepository } from '../../repositories/manifest.repository.js';
 import { AgentsMdService } from '../../services/agents-md/agents-md.service.js';
+import { AgentsMdDiscoveryService } from '../../services/agents-md/agents-md-discovery.service.js';
 import { handleCommandError } from '../utils/index.js';
 export const agentsMdCommand = new Command('agents-md').description('Generate, validate, and sync OpenAI agents.md files from OSSA manifests');
 // Generate subcommand
@@ -131,8 +132,7 @@ extensions:
         await agentsMdService.syncAgentsMd(manifestPath, options.watch || false);
         console.log(chalk.green('✓ AGENTS.md synced successfully'));
         if (options.watch) {
-            console.log(chalk.blue('\n👀 Watching for changes... (Press Ctrl+C to stop)'));
-            // Keep process alive for watching
+            console.log(chalk.blue('\nWatching for changes... (Press Ctrl+C to stop)'));
             await new Promise(() => { });
         }
         else {
@@ -143,4 +143,94 @@ extensions:
         handleCommandError(error);
     }
 });
+// Discover subcommand: find all AGENTS.md files and their manifests
+agentsMdCommand
+    .command('discover')
+    .argument('[dir]', 'Workspace directory to scan', process.cwd())
+    .option('-v, --verbose', 'Show validation warnings')
+    .description('Discover all AGENTS.md files in workspace (.agents/*/ and root) for update and maintenance')
+    .action(async (dir, options) => {
+    try {
+        const baseDir = dir || process.cwd();
+        console.log(chalk.blue(`Discovering AGENTS.md in ${baseDir}...`));
+        const discovery = container.get(AgentsMdDiscoveryService);
+        const results = await discovery.discover(baseDir);
+        if (results.length === 0) {
+            console.log(chalk.yellow('No AGENTS.md files or .agents/ agents found.'));
+            console.log(chalk.gray('Create agents with the wizard (step 9c) or run ossa agents-md generate <manifest>'));
+            process.exit(0);
+            return;
+        }
+        console.log(chalk.bold(`\nDiscovered ${results.length} AGENTS.md entry(ies):\n`));
+        console.log('Path'.padEnd(60) +
+            'Agent'.padEnd(24) +
+            'Manifest'.padEnd(12) +
+            'Status');
+        console.log('─'.repeat(100));
+        for (const r of results) {
+            const relPath = r.agentsMdPath.replace(baseDir, '').replace(/^\//, '') || 'AGENTS.md';
+            const agent = (r.agentName ?? '-').padEnd(22);
+            const hasManifest = r.manifestPath ? 'yes' : 'no ';
+            let status;
+            if (r.valid === null)
+                status = chalk.yellow('missing');
+            else if (r.valid)
+                status = chalk.green('valid');
+            else
+                status = chalk.red('invalid');
+            console.log(`${relPath.padEnd(60)}${agent}${hasManifest.padEnd(12)}${status}`);
+            if (options.verbose && r.warnings.length > 0) {
+                r.warnings.forEach((w) => console.log(chalk.gray(`  - ${w}`)));
+            }
+        }
+        console.log(chalk.gray('\nRun ossa agents-md maintain [dir] to validate and regenerate outdated AGENTS.md'));
+        process.exit(0);
+    }
+    catch (error) {
+        handleCommandError(error);
+    }
+});
+// Maintain subcommand: discover then validate/regenerate to update and maintain
+agentsMdCommand
+    .command('maintain')
+    .argument('[dir]', 'Workspace directory to scan', process.cwd())
+    .option('-r, --regenerate', 'Regenerate all (not only invalid) from manifest')
+    .option('--dry-run', 'Only report what would be updated')
+    .option('-v, --verbose', 'Verbose output')
+    .description('Discover AGENTS.md files and update/maintain them (validate, regenerate invalid or all)')
+    .action(async (dir, options) => {
+    try {
+        const baseDir = dir || process.cwd();
+        console.log(chalk.blue(`Maintaining AGENTS.md in ${baseDir}...`));
+        const discovery = container.get(AgentsMdDiscoveryService);
+        const { discovered, updated, skipped, failed } = await discovery.maintain(baseDir, {
+            regenerate: options.regenerate ?? false,
+            dryRun: options.dryRun,
+        });
+        if (discovered.length === 0) {
+            console.log(chalk.yellow('Nothing to maintain. Run ossa agents-md discover to list.'));
+            process.exit(0);
+            return;
+        }
+        if (options.verbose || updated.length > 0 || failed.length > 0) {
+            console.log(chalk.bold('\nMaintain result:'));
+            console.log(chalk.green(`  Updated: ${updated.length}`));
+            console.log(chalk.gray(`  Skipped (valid/no manifest): ${skipped.length}`));
+            if (failed.length > 0) {
+                console.log(chalk.red(`  Failed: ${failed.length}`));
+                failed.forEach((f) => console.log(chalk.red(`    ${f.path}: ${f.error}`)));
+            }
+        }
+        if (updated.length > 0) {
+            console.log(chalk.green('\nUpdated:'));
+            updated.forEach((p) => console.log(chalk.cyan(`  ${p}`)));
+        }
+        if (failed.length > 0)
+            process.exit(1);
+        process.exit(0);
+    }
+    catch (error) {
+        handleCommandError(error);
+    }
+});
 //# sourceMappingURL=agents-md.command.js.map

package/dist/cli/commands/agents.command.d.ts

@@ -1,11 +1,11 @@
 /**
- * OSSA Agent CRUD Commands
- * Complete Create, Read, Update, Delete operations for agents
- * Follows DRY, SOLID, Zod, OpenAPI, and CRUD principles
+ * OSSA Agent Commands
+ * Create, List, and Get operations for agents
+ * Follows DRY, SOLID, Zod, OpenAPI principles
  */
 import { Command } from 'commander';
 /**
- * Agent CRUD Command Group
+ * Agent Command Group
  */
 export declare const agentsCommandGroup: Command;
 //# sourceMappingURL=agents.command.d.ts.map

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

@@ -1,7 +1,7 @@
 /**
- * OSSA Agent CRUD Commands
- * Complete Create, Read, Update, Delete operations for agents
- * Follows DRY, SOLID, Zod, OpenAPI, and CRUD principles
+ * OSSA Agent Commands
+ * Create, List, and Get operations for agents
+ * Follows DRY, SOLID, Zod, OpenAPI principles
  */
 import chalk from 'chalk';
 import { Command } from 'commander';
@@ -23,22 +23,10 @@ const AgentVersionSchema = z
     .string()
     .regex(/^\d+\.\d+\.\d+(-[a-zA-Z0-9]+(\.[a-zA-Z0-9]+)*)?(\+[a-zA-Z0-9]+(\.[a-zA-Z0-9]+)*)?$/);
 const AgentPathSchema = z.string().min(1);
-const AgentUpdateSchema = z
-    .object({
-    description: z.string().optional(),
-    labels: z.record(z.string(), z.string()).optional(),
-    llm: z
-        .object({
-        temperature: z.number().min(0).max(2).optional(),
-        maxTokens: z.number().min(1).max(200000).optional(),
-    })
-        .optional(),
-})
-    .partial();
 /**
- * Agent CRUD Command Group
+ * Agent Command Group
  */
-export const agentsCommandGroup = new Command('agents').description('Manage OSSA agents (CRUD operations)');
+export const agentsCommandGroup = new Command('agents').description('Manage OSSA agents (create, list, get)');
 /**
  * Create Agent Command
  * POST /agents
@@ -220,127 +208,6 @@ agentsCommandGroup
         process.exit(1);
     }
 });
-/**
- * Update Agent Command
- * PUT /agents/{id}
- */
-agentsCommandGroup
-    .command('update')
-    .alias('edit')
-    .argument('<agent>', 'Agent identifier (name@version)')
-    .option('--description <desc>', 'Update description')
-    .option('--label <key=value>', 'Add or update label (can be used multiple times)', [])
-    .option('--temperature <num>', 'Update LLM temperature', parseFloat)
-    .option('--max-tokens <num>', 'Update LLM max tokens', parseInt)
-    .option('--dry-run', 'Preview changes without updating')
-    .description('Update an existing agent')
-    .action(async (agent, options) => {
-    try {
-        const parts = agent.split('@');
-        if (parts.length !== 2) {
-            throw new Error('Agent identifier must be in format: name@version');
-        }
-        const agentName = parts[0];
-        const version = parts[1];
-        AgentIdSchema.parse(agentName);
-        AgentVersionSchema.parse(version);
-        const updatePayload = {};
-        if (options.description) {
-            updatePayload.description = options.description;
-        }
-        if (options.label && options.label.length > 0) {
-            updatePayload.labels = {};
-            options.label.forEach((label) => {
-                const [key, value] = label.split('=');
-                if (!key || !value) {
-                    throw new Error(`Invalid label format: ${label}. Use key=value`);
-                }
-                updatePayload.labels[key] = value;
-            });
-        }
-        if (options.temperature !== undefined ||
-            options.maxTokens !== undefined) {
-            updatePayload.llm = {};
-            if (options.temperature !== undefined) {
-                updatePayload.llm.temperature = options.temperature;
-            }
-            if (options.maxTokens !== undefined) {
-                updatePayload.llm.maxTokens = options.maxTokens;
-            }
-        }
-        const validated = AgentUpdateSchema.parse(updatePayload);
-        if (options.dryRun) {
-            console.log(chalk.yellow('\n[DRY RUN] Would update agent:'));
-            console.log(`  Agent: ${agentName}@${version}`);
-            console.log(`  Changes:`, JSON.stringify(validated, null, 2));
-            return;
-        }
-        console.log(chalk.blue(`Updating agent: ${agentName}@${version}`));
-        console.log(chalk.yellow('[WARN]  Update functionality requires API implementation'));
-        console.log(chalk.gray('  Validated update payload:'), JSON.stringify(validated, null, 2));
-        console.log(chalk.green(`\n✓ Update validated (API implementation pending)`));
-    }
-    catch (error) {
-        if (error instanceof z.ZodError) {
-            console.error(chalk.red('✗ Validation error:'));
-            error.issues.forEach((issue) => {
-                console.error(chalk.red(`  - ${issue.path.join('.')}: ${issue.message}`));
-            });
-        }
-        else {
-            console.error(chalk.red('✗ Failed to update agent:'), error instanceof Error ? error.message : String(error));
-        }
-        process.exit(1);
-    }
-});
-/**
- * Delete Agent Command
- * DELETE /agents/{id}
- */
-agentsCommandGroup
-    .command('delete')
-    .alias('remove')
-    .alias('rm')
-    .argument('<agent>', 'Agent identifier (name@version)')
-    .option('--force', 'Force deletion without confirmation')
-    .option('--dry-run', 'Preview deletion without deleting')
-    .description('Delete an agent')
-    .action(async (agent, options) => {
-    try {
-        const parts = agent.split('@');
-        if (parts.length !== 2) {
-            throw new Error('Agent identifier must be in format: name@version');
-        }
-        const agentName = parts[0];
-        const version = parts[1];
-        AgentIdSchema.parse(agentName);
-        AgentVersionSchema.parse(version);
-        if (options.dryRun) {
-            console.log(chalk.yellow('\n[DRY RUN] Would delete agent:'));
-            console.log(`  Agent: ${agentName}@${version}`);
-            return;
-        }
-        if (!options.force) {
-            console.log(chalk.yellow(`[WARN]  This will delete agent: ${agentName}@${version}`));
-            console.log(chalk.yellow('   Use --force to skip confirmation'));
-        }
-        console.log(chalk.blue(`Deleting agent: ${agentName}@${version}`));
-        console.log(chalk.yellow('[WARN]  Delete functionality requires API implementation'));
-        console.log(chalk.green(`\n✓ Delete validated (API implementation pending)`));
-    }
-    catch (error) {
-        if (error instanceof z.ZodError) {
-            console.error(chalk.red('✗ Validation error:'));
-            error.issues.forEach((issue) => {
-                console.error(chalk.red(`  - ${issue.path.join('.')}: ${issue.message}`));
-            });
-        }
-        else {
-            console.error(chalk.red('✗ Failed to delete agent:'), error instanceof Error ? error.message : String(error));
-        }
-        process.exit(1);
-    }
-});
 /**
  * Persona Management Command
  * Display and edit agent persona configuration

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

@@ -9,12 +9,13 @@ 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, langchain, crewai, temporal, docker, kubernetes)', 'all')
+    .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) => {
@@ -27,7 +28,11 @@ export const buildCommand = new Command('build')
         const manifest = await manifestRepo.load(manifestPath);
         if (options.validate) {
             console.log(chalk.yellow('Validating manifest...'));
-            // TODO: Add validation
+            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
@@ -36,16 +41,7 @@ export const buildCommand = new Command('build')
             fs.mkdirSync(outputDir, { recursive: true });
         }
         const platforms = options.platform === 'all'
-            ? [
-                'kagent',
-                'langchain',
-                'crewai',
-                'temporal',
-                'n8n',
-                'gitlab',
-                'docker',
-                'kubernetes',
-            ]
+            ? ['kagent', 'docker', 'kubernetes']
             : [options.platform];
         const results = [];
         for (const platform of platforms) {
@@ -96,21 +92,6 @@ async function buildForPlatform(manifest, platform, outputDir) {
             files.push(crdPath);
             break;
         }
-        case 'langchain': {
-            // TODO: Implement LangChain converter
-            console.log(chalk.yellow('  LangChain converter not yet implemented'));
-            break;
-        }
-        case 'crewai': {
-            // TODO: Implement CrewAI converter
-            console.log(chalk.yellow('  CrewAI converter not yet implemented'));
-            break;
-        }
-        case 'temporal': {
-            // TODO: Implement Temporal converter
-            console.log(chalk.yellow('  Temporal converter not yet implemented'));
-            break;
-        }
         case 'docker': {
             try {
                 // Use manifest parameter directly (already loaded)

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

@@ -0,0 +1,7 @@
+/**
+ * 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