@bluefly/openstandardagents 0.5.1 → 0.5.4

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

@@ -1,168 +0,0 @@
-/**
- * Memory Command
- * Manages hierarchical memory tiers for OSSA agents.
- *
- * Tiers (workspace > project > session):
- *   workspace/ — cross-project, long-lived facts
- *   project/   — repo-scoped context
- *   session/   — ephemeral, single-run state
- */
-import chalk from 'chalk';
-import * as fs from 'fs';
-import * as path from 'path';
-import { Command } from 'commander';
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-const MEMORY_TIERS = ['workspace', 'project', 'session'];
-const AGENTS_DIR = '.agents/agents';
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-/**
- * Resolve the memory root for a named agent.
- * Returns  .agents/agents/<name>/memory  relative to cwd (or provided root).
- */
-function agentMemoryRoot(agentName, workspaceRoot) {
-    return path.join(workspaceRoot, AGENTS_DIR, agentName, 'memory');
-}
-/**
- * Return the full path for a given tier under an agent's memory root.
- */
-function tierPath(memRoot, tier) {
-    return path.join(memRoot, tier);
-}
-// ---------------------------------------------------------------------------
-// Subcommand: init
-// ---------------------------------------------------------------------------
-const memoryInitCommand = new Command('init')
-    .description('Initialize memory tier directories for an agent (.agents/agents/<name>/memory/{workspace,project,session}/)')
-    .argument('<agent-name>', 'Name of the OSSA agent')
-    .option('-w, --workspace-root <path>', 'Workspace root directory', process.cwd())
-    .action(async (agentName, options) => {
-    const root = path.resolve(options.workspaceRoot);
-    const memRoot = agentMemoryRoot(agentName, root);
-    console.log(chalk.blue(`Initializing memory tiers for agent: ${agentName}`));
-    console.log(chalk.gray(`  Memory root: ${memRoot}\n`));
-    for (const tier of MEMORY_TIERS) {
-        const dir = tierPath(memRoot, tier);
-        // TODO: Replace with OSSA-aware mkdir once MemoryService is implemented.
-        fs.mkdirSync(dir, { recursive: true });
-        console.log(chalk.green(`  ✓ ${tier}/`));
-    }
-    console.log('');
-    console.log(chalk.cyan(`Memory initialized. Use 'ossa memory index ${agentName}' to populate workspace/ tier.`));
-});
-// ---------------------------------------------------------------------------
-// Subcommand: index
-// ---------------------------------------------------------------------------
-const memoryIndexCommand = new Command('index')
-    .description('Index agent files into the memory hierarchy (reads manifest, catalogs capabilities/tools into memory/workspace/)')
-    .argument('<agent-name>', 'Name of the OSSA agent to index')
-    .option('-w, --workspace-root <path>', 'Workspace root directory', process.cwd())
-    .option('-m, --manifest <path>', 'Path to agent manifest (defaults to .agents/agents/<name>/<name>.ossa.yaml)')
-    .action(async (agentName, options) => {
-    const root = path.resolve(options.workspaceRoot);
-    const memRoot = agentMemoryRoot(agentName, root);
-    const workspaceTier = tierPath(memRoot, 'workspace');
-    const manifestPath = options.manifest ??
-        path.join(root, AGENTS_DIR, agentName, `${agentName}.ossa.yaml`);
-    console.log(chalk.blue(`Indexing agent: ${agentName}`));
-    console.log(chalk.gray(`  Manifest: ${manifestPath}`));
-    console.log(chalk.gray(`  Target:   ${workspaceTier}\n`));
-    if (!fs.existsSync(manifestPath)) {
-        console.error(chalk.red(`Manifest not found: ${manifestPath}\n` +
-            `Run 'ossa memory init ${agentName}' first, then ensure a manifest exists.`));
-        process.exit(1);
-    }
-    // TODO: Load manifest via ManifestRepository, extract capabilities/tools,
-    // and write structured JSON entries into workspaceTier/.
-    // Example output file: workspace/capabilities.json, workspace/tools.json
-    console.log(chalk.yellow(`[TODO] Real indexing not yet implemented.\n` +
-        `Would read ${manifestPath} and write catalogued entries to ${workspaceTier}/`));
-    console.log(chalk.green('  ✓ Index stub complete'));
-});
-// ---------------------------------------------------------------------------
-// Subcommand: resolve
-// ---------------------------------------------------------------------------
-const memoryResolveCommand = new Command('resolve')
-    .description('Resolve a memory query across tiers (workspace → project → session, returns first match)')
-    .argument('<agent-name>', 'Name of the OSSA agent')
-    .argument('<query>', 'Memory key or query string to resolve')
-    .option('-w, --workspace-root <path>', 'Workspace root directory', process.cwd())
-    .option('--tier <tier>', `Restrict search to a specific tier (${MEMORY_TIERS.join('|')})`)
-    .action(async (agentName, query, options) => {
-    const root = path.resolve(options.workspaceRoot);
-    const memRoot = agentMemoryRoot(agentName, root);
-    const tiersToSearch = options.tier
-        ? [options.tier]
-        : [...MEMORY_TIERS]; // workspace first (highest priority)
-    console.log(chalk.blue(`Resolving query: "${query}" for agent: ${agentName}`));
-    console.log(chalk.gray(`  Tiers: ${tiersToSearch.join(' → ')}\n`));
-    for (const tier of tiersToSearch) {
-        const dir = tierPath(memRoot, tier);
-        if (!fs.existsSync(dir)) {
-            console.log(chalk.gray(`  [${tier}] directory not found — skipping`));
-            continue;
-        }
-        // TODO: Implement real resolution logic — scan JSON/YAML files in the
-        // tier directory for entries whose key/tags match the query string.
-        console.log(chalk.yellow(`  [${tier}] TODO: scan ${dir} for "${query}"`));
-    }
-    console.log('');
-    console.log(chalk.gray('[TODO] Resolution not yet implemented. No result returned.'));
-});
-// ---------------------------------------------------------------------------
-// Subcommand: promote
-// ---------------------------------------------------------------------------
-const memoryPromoteCommand = new Command('promote')
-    .description('Promote a session-tier memory entry to project or workspace tier')
-    .argument('<agent-name>', 'Name of the OSSA agent')
-    .argument('<entry-key>', 'Key of the memory entry to promote')
-    .option('-w, --workspace-root <path>', 'Workspace root directory', process.cwd())
-    .option('--from <tier>', 'Source tier to promote from', 'session')
-    .option('--to <tier>', 'Destination tier to promote to', 'project')
-    .action(async (agentName, entryKey, options) => {
-    const root = path.resolve(options.workspaceRoot);
-    const memRoot = agentMemoryRoot(agentName, root);
-    const validTiers = new Set(MEMORY_TIERS);
-    if (!validTiers.has(options.from)) {
-        console.error(chalk.red(`Invalid --from tier: "${options.from}". Must be one of: ${MEMORY_TIERS.join(', ')}`));
-        process.exit(1);
-    }
-    if (!validTiers.has(options.to)) {
-        console.error(chalk.red(`Invalid --to tier: "${options.to}". Must be one of: ${MEMORY_TIERS.join(', ')}`));
-        process.exit(1);
-    }
-    const fromDir = tierPath(memRoot, options.from);
-    const toDir = tierPath(memRoot, options.to);
-    console.log(chalk.blue(`Promoting memory entry: "${entryKey}" for agent: ${agentName}`));
-    console.log(chalk.gray(`  From: ${fromDir}`));
-    console.log(chalk.gray(`  To:   ${toDir}\n`));
-    // TODO: Locate the entry file in fromDir, copy it to toDir, then
-    // optionally remove or archive the source entry.
-    console.log(chalk.yellow(`[TODO] Promotion not yet implemented.\n` +
-        `Would copy key "${entryKey}" from ${options.from}/ to ${options.to}/.`));
-    console.log(chalk.green('  ✓ Promote stub complete'));
-});
-// ---------------------------------------------------------------------------
-// Root memory command group
-// ---------------------------------------------------------------------------
-export const memoryCommand = new Command('memory')
-    .description('Manage hierarchical memory tiers for OSSA agents (workspace | project | session)')
-    .addCommand(memoryInitCommand)
-    .addCommand(memoryIndexCommand)
-    .addCommand(memoryResolveCommand)
-    .addCommand(memoryPromoteCommand);
-// ---------------------------------------------------------------------------
-// Register helper (matches task spec — also works with .addCommand() pattern)
-// ---------------------------------------------------------------------------
-/**
- * Register the memory command group on a commander program.
- * Prefer `program.addCommand(memoryCommand)` directly; this helper exists
- * for callers that use a register-function convention.
- */
-export function registerMemoryCommand(program) {
-    program.addCommand(memoryCommand);
-}
-//# sourceMappingURL=memory.command.js.map

package/dist/cli/commands/migrate-batch.command.d.ts

@@ -1,19 +0,0 @@
-/**
- * OSSA Migrate Batch Command
- * Batch migrate OSSA agent manifests across directories
- *
- * Features:
- * - Auto-discover manifests in directories
- * - Dry-run mode for previewing changes
- * - Interactive mode for conflict resolution
- * - Detailed migration reports (console + JSON)
- * - Validation of migrated manifests
- *
- * Usage:
- *   ossa migrate-batch --to v0.3.5 --dir ./agents
- *   ossa migrate-batch --to v0.3.5 --dir ./agents --dry-run
- *   ossa migrate-batch --to v0.3.5 --dir ./agents --interactive
- */
-import { Command } from 'commander';
-export declare const migrateBatchCommand: Command;
-//# sourceMappingURL=migrate-batch.command.d.ts.map

package/dist/cli/commands/migrate-batch.command.js

@@ -1,223 +0,0 @@
-/**
- * OSSA Migrate Batch Command
- * Batch migrate OSSA agent manifests across directories
- *
- * Features:
- * - Auto-discover manifests in directories
- * - Dry-run mode for previewing changes
- * - Interactive mode for conflict resolution
- * - Detailed migration reports (console + JSON)
- * - Validation of migrated manifests
- *
- * Usage:
- *   ossa migrate-batch --to v0.3.5 --dir ./agents
- *   ossa migrate-batch --to v0.3.5 --dir ./agents --dry-run
- *   ossa migrate-batch --to v0.3.5 --dir ./agents --interactive
- */
-import chalk from 'chalk';
-import { Command } from 'commander';
-import * as path from 'path';
-import * as readline from 'readline';
-import { container } from '../../di-container.js';
-import { ManifestRepository } from '../../repositories/manifest.repository.js';
-import { MigrationService } from '../../services/migration.service.js';
-import { ValidationService } from '../../services/validation.service.js';
-import { getVersionInfo } from '../../utils/version.js';
-import { discoverManifests } from '../utils/manifest-discovery.js';
-import { generateReport, printReport, saveReportToFile, } from '../utils/migration-reporter.js';
-// ============================================================================
-// Command
-// ============================================================================
-export const migrateBatchCommand = new Command('migrate-batch')
-    .description('Batch migrate OSSA agent manifests')
-    .requiredOption('--to <version>', 'Target OSSA version (e.g., v0.3.5)')
-    .option('--dir <path>', 'Directory to scan for manifests', '.')
-    .option('--dry-run', 'Preview changes without writing files')
-    .option('--interactive', 'Prompt for conflicts and decisions')
-    .option('--no-validate', 'Skip validation of migrated manifests')
-    .option('-o, --output <path>', 'Output directory for migrated manifests')
-    .option('-v, --verbose', 'Verbose output with detailed information')
-    .action(async (options) => {
-    try {
-        const startTime = Date.now();
-        // Get services
-        const migrationService = container.get(MigrationService);
-        const manifestRepo = container.get(ManifestRepository);
-        const validationService = container.get(ValidationService);
-        // Get current version info
-        const versionInfo = getVersionInfo();
-        const targetVersion = options.to.replace(/^v/, ''); // Remove 'v' prefix if present
-        const currentVersion = versionInfo.version;
-        console.log(chalk.blue.bold('\nOSSA Batch Migration Tool\n'));
-        console.log(chalk.gray(`Target Version: ${chalk.white(`v${targetVersion}`)}`));
-        console.log(chalk.gray(`Scan Directory: ${chalk.white(options.dir || '.')}`));
-        console.log(chalk.gray(`Dry Run: ${chalk.white(options.dryRun ? 'Yes' : 'No')}`));
-        console.log(chalk.gray(`Interactive: ${chalk.white(options.interactive ? 'Yes' : 'No')}`));
-        console.log(chalk.gray(`Validation: ${chalk.white(options.validate !== false ? 'Yes' : 'No')}\n`));
-        // Discover manifests
-        console.log(chalk.cyan('[DISCOVERY] Scanning for OSSA manifests...\n'));
-        const discovered = await discoverManifests(options.dir || '.', {
-            recursive: true,
-            verbose: options.verbose,
-        });
-        if (discovered.length === 0) {
-            console.log(chalk.yellow('No OSSA manifests found in the specified directory.'));
-            process.exit(0);
-        }
-        console.log(chalk.green(`\n✓ Found ${discovered.length} manifest${discovered.length !== 1 ? 's' : ''}\n`));
-        // Show discovered manifests
-        if (options.verbose) {
-            console.log(chalk.gray('Discovered manifests:'));
-            discovered.forEach((m) => {
-                console.log(chalk.gray(`  - ${m.relativePath} (${m.version || 'unknown version'})`));
-            });
-            console.log('');
-        }
-        // Migrate each manifest
-        console.log(chalk.cyan('[MIGRATION] Processing manifests...\n'));
-        const results = [];
-        for (const manifest of discovered) {
-            const result = await migrateSingleManifest(manifest, targetVersion, currentVersion, {
-                migrationService,
-                manifestRepo,
-                validationService,
-                options,
-            });
-            results.push(result);
-        }
-        // Generate report
-        const endTime = Date.now();
-        const duration = (endTime - startTime) / 1000;
-        const report = generateReport(results, {
-            targetVersion: `v${targetVersion}`,
-            dryRun: options.dryRun || false,
-            duration,
-            directory: options.dir || '.',
-        });
-        // Print report to console
-        console.log('');
-        printReport(report);
-        // Save JSON report if requested
-        if (options.output || !options.dryRun) {
-            const reportPath = options.output ||
-                path.join(options.dir || '.', `.ossa-migration-report-${Date.now()}.json`);
-            await saveReportToFile(report, reportPath);
-            console.log(chalk.gray(`\nReport saved to: ${chalk.white(reportPath)}`));
-        }
-        // Exit with appropriate code
-        const hasErrors = results.some((r) => !r.success && !r.skipped);
-        process.exit(hasErrors ? 1 : 0);
-    }
-    catch (error) {
-        console.error(chalk.red('\n[ERROR] Batch migration failed:'), error instanceof Error ? error.message : String(error));
-        if (options.verbose && error instanceof Error) {
-            console.error(chalk.gray(error.stack));
-        }
-        process.exit(1);
-    }
-});
-/**
- * Migrate a single manifest file
- */
-async function migrateSingleManifest(manifest, targetVersion, currentVersion, context) {
-    const { migrationService, manifestRepo, validationService, options } = context;
-    try {
-        // Load manifest
-        const loadedManifest = await manifestRepo.load(manifest.path);
-        // Check if migration is needed
-        if (!migrationService.needsMigration(loadedManifest)) {
-            console.log(chalk.gray(`  ⊙ ${manifest.relativePath} - already at target version`));
-            return {
-                manifest,
-                success: true,
-                skipped: true,
-                skipReason: 'Already at target version',
-            };
-        }
-        // Interactive prompt if enabled
-        if (options.interactive) {
-            const shouldMigrate = await promptForMigration(manifest);
-            if (!shouldMigrate) {
-                console.log(chalk.gray(`  ⊙ ${manifest.relativePath} - skipped by user`));
-                return {
-                    manifest,
-                    success: true,
-                    skipped: true,
-                    skipReason: 'Skipped by user',
-                };
-            }
-        }
-        // Migrate
-        const migrated = await migrationService.migrate(loadedManifest);
-        // Validate if enabled
-        if (options.validate !== false) {
-            const validationResult = await validationService.validate(migrated, 'current');
-            if (!validationResult.valid) {
-                console.log(chalk.red(`  ✗ ${manifest.relativePath} - migration produced invalid manifest`));
-                return {
-                    manifest,
-                    success: false,
-                    error: 'Validation failed',
-                    validationErrors: validationResult.errors.map((e) => `${e.instancePath}: ${e.message}`),
-                    migratedContent: migrated,
-                };
-            }
-        }
-        // Save migrated manifest (unless dry-run)
-        if (!options.dryRun) {
-            const outputPath = determineOutputPath(manifest.path, currentVersion, options);
-            await manifestRepo.save(outputPath, migrated);
-            console.log(chalk.green(`  ✓ ${manifest.relativePath} → ${path.basename(outputPath)}`));
-        }
-        else {
-            console.log(chalk.yellow(`  → ${manifest.relativePath} (dry-run - not saved)`));
-        }
-        return {
-            manifest,
-            success: true,
-            migratedContent: migrated,
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        console.log(chalk.red(`  ✗ ${manifest.relativePath} - ${errorMessage}`));
-        return {
-            manifest,
-            success: false,
-            error: errorMessage,
-        };
-    }
-}
-/**
- * Determine output path for migrated manifest
- */
-function determineOutputPath(sourcePath, targetVersion, options) {
-    const parsed = path.parse(sourcePath);
-    const outputDir = options.output || parsed.dir;
-    // Remove existing version suffixes
-    let name = parsed.name.replace(/\.v\d+\.\d+\.\d+\.ossa$/, '.ossa');
-    // Add new version suffix
-    if (name.endsWith('.ossa')) {
-        name = name.replace(/\.ossa$/, `.v${targetVersion}.ossa`);
-    }
-    else {
-        name = `${name}.v${targetVersion}.ossa`;
-    }
-    return path.join(outputDir, `${name}${parsed.ext}`);
-}
-/**
- * Prompt user for migration decision (interactive mode)
- */
-async function promptForMigration(manifest) {
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    return new Promise((resolve) => {
-        rl.question(chalk.yellow(`Migrate ${manifest.relativePath} (${manifest.version || 'unknown version'})? (y/n): `), (answer) => {
-            rl.close();
-            resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
-        });
-    });
-}
-//# sourceMappingURL=migrate-batch.command.js.map

package/dist/cli/commands/migrate-langchain.command.d.ts

@@ -1,23 +0,0 @@
-/**
- * OSSA Migrate LangChain Command
- * Migrate LangChain agents (Python/TypeScript) to OSSA manifests
- *
- * Supported formats:
- * - Python LangChain (.py)
- * - TypeScript LangChain (.ts, .js)
- * - JSON/YAML config files (.json, .yaml, .yml)
- *
- * Usage:
- *   ossa migrate langchain <source> [options]
- *
- * Options:
- *   -o, --output <path>      Output path for migrated manifest
- *   --report <path>          Save migration report to file
- *   --format <json|yaml>     Report format (default: json)
- *   --validate               Validate generated manifest (default: true)
- *   --dry-run                Preview migration without writing files
- *   -v, --verbose            Verbose output
- */
-import { Command } from 'commander';
-export declare const migrateLangchainCommand: Command;
-//# sourceMappingURL=migrate-langchain.command.d.ts.map

package/dist/cli/commands/migrate-langchain.command.js

@@ -1,167 +0,0 @@
-/**
- * OSSA Migrate LangChain Command
- * Migrate LangChain agents (Python/TypeScript) to OSSA manifests
- *
- * Supported formats:
- * - Python LangChain (.py)
- * - TypeScript LangChain (.ts, .js)
- * - JSON/YAML config files (.json, .yaml, .yml)
- *
- * Usage:
- *   ossa migrate langchain <source> [options]
- *
- * Options:
- *   -o, --output <path>      Output path for migrated manifest
- *   --report <path>          Save migration report to file
- *   --format <json|yaml>     Report format (default: json)
- *   --validate               Validate generated manifest (default: true)
- *   --dry-run                Preview migration without writing files
- *   -v, --verbose            Verbose output
- */
-import chalk from 'chalk';
-import { Command } from 'commander';
-import { stringify as yamlStringify } from 'yaml';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { LangChainMigrationService } from '../../services/migration/langchain-migration.service.js';
-import { ValidationService } from '../../services/validation.service.js';
-import { ManifestRepository } from '../../repositories/manifest.repository.js';
-import { container } from '../../di-container.js';
-export const migrateLangchainCommand = new Command('langchain')
-    .argument('<source>', 'Path to LangChain code file (Python/TypeScript) or config (JSON/YAML)')
-    .option('-o, --output <path>', 'Output path for migrated manifest')
-    .option('--report <path>', 'Save migration report to file')
-    .option('--format <format>', 'Report format: json or yaml', 'json')
-    .option('--validate', 'Validate generated manifest', true)
-    .option('--dry-run', 'Preview migration without writing files')
-    .option('-v, --verbose', 'Verbose output')
-    .description('Migrate LangChain agents to OSSA manifests')
-    .action(async (source, options) => {
-    try {
-        console.log(chalk.blue(`Migrating LangChain agent from ${source}...`));
-        // Initialize services
-        const migrationService = new LangChainMigrationService();
-        const validationService = container.get(ValidationService);
-        const manifestRepo = container.get(ManifestRepository);
-        // Determine output path
-        const outputPath = options.output || generateOutputPath(source);
-        // Perform migration
-        const { manifest, report } = await migrationService.migrate(source, outputPath);
-        // Display migration summary
-        console.log(chalk.cyan('\nMigration Summary:'));
-        console.log(chalk.gray(`  Source: ${report.sourceFile}`));
-        console.log(chalk.gray(`  Format: ${report.sourceFormat}`));
-        console.log(chalk.gray(`  Target: ${outputPath}`));
-        console.log(chalk.gray(`  Confidence: ${report.confidence}%`));
-        // Display detected components
-        if (options.verbose) {
-            console.log(chalk.cyan('\nDetected Components:'));
-            report.components.detected.forEach((comp) => {
-                const type = comp.type.toUpperCase();
-                const detail = comp.agentType || comp.chainType || comp.llmConfig?.model || '';
-                console.log(chalk.gray(`  - ${type}: ${detail}`));
-            });
-        }
-        // Display mappings
-        console.log(chalk.cyan('\nMappings:'));
-        report.components.mapped.forEach((mapping) => {
-            const icon = mapping.confidence === 'high'
-                ? '✓'
-                : mapping.confidence === 'medium'
-                    ? '~'
-                    : '?';
-            const color = mapping.confidence === 'high'
-                ? chalk.green
-                : mapping.confidence === 'medium'
-                    ? chalk.yellow
-                    : chalk.red;
-            console.log(color(`  ${icon} ${mapping.source} → ${mapping.target}`));
-        });
-        // Display unmapped features
-        if (report.components.unmapped.length > 0) {
-            console.log(chalk.yellow('\nUnmapped Features:'));
-            report.components.unmapped.forEach((feature) => {
-                console.log(chalk.yellow(`  ⚠ ${feature}`));
-            });
-        }
-        // Display warnings
-        if (report.warnings.length > 0) {
-            console.log(chalk.yellow('\nWarnings:'));
-            report.warnings.forEach((warning) => {
-                console.log(chalk.yellow(`  ⚠ ${warning}`));
-            });
-        }
-        // Display recommendations
-        if (report.recommendations.length > 0) {
-            console.log(chalk.cyan('\nRecommendations:'));
-            report.recommendations.forEach((rec) => {
-                console.log(chalk.gray(`  • ${rec}`));
-            });
-        }
-        // Validate if requested
-        if (options.validate) {
-            console.log(chalk.blue('\nValidating manifest...'));
-            const validationResult = await validationService.validate(manifest, 'current');
-            if (!validationResult.valid) {
-                console.error(chalk.red('✗ Generated manifest is invalid:'));
-                validationResult.errors.forEach((error) => {
-                    console.error(chalk.red(`  - ${error.instancePath}: ${error.message}`));
-                });
-                process.exit(1);
-            }
-            console.log(chalk.green('✓ Manifest is valid'));
-            if (validationResult.warnings.length > 0) {
-                console.log(chalk.yellow('\nValidation Warnings:'));
-                validationResult.warnings.forEach((warning) => {
-                    console.log(chalk.yellow(`  ⚠ ${warning}`));
-                });
-            }
-        }
-        // Save files if not dry-run
-        if (options.dryRun) {
-            console.log(chalk.yellow('\n[DRY RUN] No files written'));
-            console.log(chalk.gray('\nGenerated Manifest Preview:'));
-            console.log(chalk.white(yamlStringify(manifest, { indent: 2, lineWidth: 120 })));
-        }
-        else {
-            // Save manifest
-            await manifestRepo.save(outputPath, manifest);
-            console.log(chalk.green(`\n✓ Manifest saved to: ${outputPath}`));
-            // Save report if requested
-            if (options.report) {
-                const reportContent = options.format === 'yaml'
-                    ? yamlStringify(report, { indent: 2, lineWidth: 120 })
-                    : JSON.stringify(report, null, 2);
-                await fs.writeFile(options.report, reportContent, 'utf-8');
-                console.log(chalk.green(`✓ Report saved to: ${options.report}`));
-            }
-        }
-        // Display next steps
-        console.log(chalk.cyan('\nNext Steps:'));
-        console.log(chalk.gray(`  1. Review the generated manifest: ${outputPath}`));
-        console.log(chalk.gray(`  2. Implement tool functions/endpoints`));
-        console.log(chalk.gray(`  3. Test the agent: ossa run ${outputPath}`));
-        process.exit(0);
-    }
-    catch (error) {
-        console.error(chalk.red('Error:'), error instanceof Error ? error.message : String(error));
-        if (options.verbose && error instanceof Error) {
-            console.error(chalk.gray(error.stack));
-        }
-        process.exit(1);
-    }
-});
-/**
- * Generate output path from source file
- */
-function generateOutputPath(sourcePath) {
-    const dir = path.dirname(sourcePath);
-    const basename = path.basename(sourcePath, path.extname(sourcePath));
-    const outputName = `${basename}.ossa.yaml`;
-    // If source has -before suffix, use -after
-    if (basename.endsWith('-before')) {
-        return path.join(dir, basename.replace('-before', '-after') + '.ossa.yaml');
-    }
-    return path.join(dir, outputName);
-}
-//# sourceMappingURL=migrate-langchain.command.js.map

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

@@ -1,10 +0,0 @@
-/**
- * Migrate Command
- * Migrates OSSA manifests between spec versions using registered transforms.
- *
- * Cross-framework migration (langchain, crewai, autogen) was removed -
- * those parsers were stubs. Use `ossa import` for format conversion.
- */
-import { Command } from 'commander';
-export declare const migrateCommand: Command;
-//# sourceMappingURL=migrate.command.d.ts.map