zouroboros-cli 2.0.0

package/dist/commands/migrate.js

@@ -0,0 +1,112 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { Database } from 'bun:sqlite';
+import { existsSync } from 'fs';
+import { loadConfig, createMigrationRunner, MIGRATIONS } from 'zouroboros-core';
+function openDb() {
+    const config = loadConfig();
+    if (!existsSync(config.memory.dbPath)) {
+        console.error(chalk.red(`\n❌ Database not found at ${config.memory.dbPath}`));
+        console.error(chalk.gray('  Run "zouroboros init" first to create the database.\n'));
+        process.exit(1);
+    }
+    return new Database(config.memory.dbPath);
+}
+export const migrateCommand = new Command('migrate')
+    .description('Manage database schema migrations')
+    .addCommand(new Command('up')
+    .description('Apply pending migrations')
+    .option('--to <id>', 'Migrate up to a specific migration ID')
+    .action((opts) => {
+    const db = openDb();
+    try {
+        const runner = createMigrationRunner(db);
+        const targetId = opts.to ? parseInt(opts.to, 10) : undefined;
+        const result = runner.migrate(targetId);
+        if (result.applied.length === 0 && result.errors.length === 0) {
+            console.log(chalk.green('\n✅ Database is up to date — no pending migrations\n'));
+            return;
+        }
+        if (result.applied.length > 0) {
+            console.log(chalk.green(`\n✅ Applied ${result.applied.length} migration(s):\n`));
+            for (const name of result.applied) {
+                console.log(`  ${chalk.gray('↑')} ${name}`);
+            }
+        }
+        if (result.errors.length > 0) {
+            console.log(chalk.red(`\n❌ ${result.errors.length} migration(s) failed:\n`));
+            for (const { name, error } of result.errors) {
+                console.log(`  ${chalk.red('✗')} ${name}: ${error}`);
+            }
+            process.exit(1);
+        }
+        console.log();
+    }
+    finally {
+        db.close();
+    }
+}))
+    .addCommand(new Command('down')
+    .description('Rollback migrations to a specific point')
+    .argument('<target-id>', 'Roll back to this migration ID (0 to rollback all)')
+    .action((targetId) => {
+    const id = parseInt(targetId, 10);
+    if (isNaN(id) || id < 0) {
+        console.error(chalk.red('Target ID must be a non-negative integer'));
+        process.exit(1);
+    }
+    const db = openDb();
+    try {
+        const runner = createMigrationRunner(db);
+        const result = runner.rollback(id);
+        if (result.applied.length === 0) {
+            console.log(chalk.yellow('\nNo migrations to rollback\n'));
+            return;
+        }
+        console.log(chalk.green(`\n✅ Rolled back ${result.applied.length} migration(s):\n`));
+        for (const name of result.applied) {
+            console.log(`  ${chalk.gray('↓')} ${name}`);
+        }
+        if (result.errors.length > 0) {
+            console.log(chalk.red(`\n❌ ${result.errors.length} rollback(s) failed:\n`));
+            for (const { name, error } of result.errors) {
+                console.log(`  ${chalk.red('✗')} ${name}: ${error}`);
+            }
+        }
+        console.log();
+    }
+    finally {
+        db.close();
+    }
+}))
+    .addCommand(new Command('status')
+    .description('Show migration status')
+    .action(() => {
+    const db = openDb();
+    try {
+        const runner = createMigrationRunner(db);
+        const status = runner.getStatus();
+        console.log(chalk.cyan('\nMigration Status:\n'));
+        console.log(`  Current version: ${status.current || chalk.gray('(none)')}`);
+        console.log(`  Applied:         ${status.applied.length}`);
+        console.log(`  Pending:         ${status.pending.length}`);
+        console.log(`  Total available: ${MIGRATIONS.length}\n`);
+        if (status.applied.length > 0) {
+            console.log(chalk.gray('  Applied:'));
+            for (const m of status.applied) {
+                const date = new Date(m.applied_at * 1000).toLocaleString();
+                console.log(`    ${chalk.green('✓')} ${m.name} ${chalk.gray(`(${date})`)}`);
+            }
+        }
+        if (status.pending.length > 0) {
+            console.log(chalk.gray('  Pending:'));
+            for (const m of status.pending) {
+                console.log(`    ${chalk.yellow('○')} ${m.name}`);
+            }
+        }
+        console.log();
+    }
+    finally {
+        db.close();
+    }
+}));

package/dist/commands/persona.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const personaCommand: Command;

package/dist/commands/persona.js

@@ -0,0 +1,45 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+export const personaCommand = new Command('persona')
+    .description('Persona management commands')
+    .addCommand(new Command('create')
+    .description('Create a new persona')
+    .argument('<name>', 'Persona name')
+    .option('--domain <domain>', 'Domain', 'general')
+    .option('--interactive', 'Interactive mode', false)
+    .action(async (name, options) => {
+    const { generatePersona } = await import('zouroboros-personas');
+    if (options.interactive) {
+        console.log(chalk.cyan(`\n🎭 Creating persona: ${name}\n`));
+        // Interactive mode would go here
+    }
+    else {
+        const slug = name.toLowerCase().replace(/\s+/g, '-');
+        const config = {
+            name,
+            slug,
+            domain: options.domain,
+            description: `${name} persona for ${options.domain} domain`,
+            expertise: [],
+            requiresApiKey: false,
+            safetyRules: [],
+            capabilities: [],
+        };
+        const genOptions = {
+            outputDir: process.cwd(),
+        };
+        const result = await generatePersona(config, genOptions);
+        const files = result.filter((r) => r.output).map((r) => r.output);
+        console.log(chalk.green(`✅ Persona '${name}' created`));
+        console.log(chalk.gray(`   Phases: ${result.length} completed`));
+        if (files.length > 0) {
+            console.log(chalk.gray(`   Output: ${files.join(', ')}`));
+        }
+    }
+}))
+    .addCommand(new Command('list')
+    .description('List all personas')
+    .action(() => {
+    console.log(chalk.cyan('\nAvailable Personas:\n'));
+    console.log('Run with --interactive to create one.\n');
+}));

package/dist/commands/skills.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const skillsCommand: Command;

package/dist/commands/skills.js

@@ -0,0 +1,48 @@
+import { Command } from 'commander';
+import { spawn } from 'child_process';
+import { resolve } from 'path';
+const REPO_ROOT = resolve(import.meta.dirname || __dirname, '../../..');
+export const skillsCommand = new Command('skills')
+    .description('Manage Zouroboros skills')
+    .addCommand(new Command('install')
+    .description('Export skills to ~/Skills/ (or custom directory)')
+    .option('--dest <dir>', 'Target directory (default: ~/Skills)')
+    .option('--skill <name>', 'Install a single skill by name')
+    .action((options) => {
+    const args = [];
+    if (options.dest)
+        args.push('--dest', options.dest);
+    if (options.skill)
+        args.push('--skill', options.skill);
+    spawn('bash', [resolve(REPO_ROOT, 'scripts/export-skills.sh'), ...args], {
+        stdio: 'inherit',
+    });
+}))
+    .addCommand(new Command('list')
+    .description('List available skills')
+    .action(() => {
+    console.log(`
+Zouroboros Skills
+═════════════════
+
+Workflow Skills (packages/workflow):
+  spec-first-interview    Socratic interview & seed specification generator
+  three-stage-eval        Mechanical/semantic/consensus evaluation pipeline
+  autoloop                Single-metric optimization loop (inspired by autoresearch)
+  unstuck-lateral         5 lateral-thinking personas for creative problem solving
+
+Self-Enhancement Skills (packages/selfheal):
+  zouroboros-introspect   7-metric health scorecard for Zo ecosystem
+  zouroboros-prescribe    Auto-generate improvement prescriptions from scorecard
+  zouroboros-evolve       Execute prescriptions with regression detection
+
+Core System Skills:
+  zo-swarm-orchestrator   Multi-agent swarm orchestration with DAG execution
+  zo-memory-system        Hybrid SQLite + vector memory engine
+
+Install:
+  zouroboros skills install              # Export all to ~/Skills/
+  zouroboros skills install --skill autoloop  # Export one skill
+  zouroboros skills install --dest ./my-skills # Custom directory
+`);
+}));

package/dist/commands/swarm.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const swarmCommand: Command;

package/dist/commands/swarm.js

@@ -0,0 +1,32 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { existsSync } from 'fs';
+export const swarmCommand = new Command('swarm')
+    .description('Swarm orchestration commands')
+    .addCommand(new Command('run')
+    .description('Run a swarm campaign')
+    .argument('<tasks-file>', 'JSON file with tasks')
+    .option('--strategy <strategy>', 'Routing strategy', 'balanced')
+    .option('--max-concurrent <n>', 'Max concurrent tasks', '8')
+    .action(async (tasksFile, options) => {
+    if (!existsSync(tasksFile)) {
+        console.log(chalk.red(`Error: Tasks file not found: ${tasksFile}`));
+        process.exit(1);
+    }
+    // Import and run orchestrator
+    const { SwarmOrchestrator } = await import('zouroboros-swarm');
+    const orchestrator = new SwarmOrchestrator({
+        routingStrategy: options.strategy,
+        localConcurrency: parseInt(options.maxConcurrent),
+    });
+    const { readFileSync } = await import('fs');
+    const tasks = JSON.parse(readFileSync(tasksFile, 'utf-8'));
+    const results = await orchestrator.run(tasks);
+    const successCount = results.filter((r) => r.success).length;
+    console.log(chalk.green(`\n✅ Campaign complete: ${successCount}/${results.length} tasks succeeded`));
+}))
+    .addCommand(new Command('status')
+    .description('Check swarm status')
+    .action(() => {
+    console.log(chalk.cyan('Swarm status: Ready'));
+}));

package/dist/commands/tui.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const tuiCommand: Command;

package/dist/commands/tui.js

@@ -0,0 +1,11 @@
+import { Command } from 'commander';
+import { spawn } from 'child_process';
+import { join } from 'path';
+export const tuiCommand = new Command('tui')
+    .description('Launch Terminal User Interface dashboard')
+    .action(() => {
+    // Launch the TUI from the separate tui package
+    spawn('bun', [join(__dirname, '../../../tui/src/index.ts')], {
+        stdio: 'inherit'
+    });
+});

package/dist/commands/workflow.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare const workflowCommand: Command;
+export declare const selfhealCommand: Command;

package/dist/commands/workflow.js

@@ -0,0 +1,87 @@
+import { Command } from 'commander';
+import { spawn } from 'child_process';
+import { join, resolve } from 'path';
+const PACKAGES = resolve(import.meta.dirname || __dirname, '../../../packages');
+function runCli(pkg, cli, args = []) {
+    spawn('bun', [join(PACKAGES, pkg, 'src/cli', `${cli}.ts`), ...args], {
+        stdio: 'inherit',
+    });
+}
+export const workflowCommand = new Command('workflow')
+    .description('Workflow tools (interview, evaluate, unstuck, autoloop)')
+    .addCommand(new Command('interview')
+    .description('Run spec-first interview')
+    .option('--topic <topic>', 'Interview topic')
+    .action((options) => {
+    const args = options.topic ? ['--topic', options.topic] : [];
+    runCli('workflow', 'interview', args);
+}))
+    .addCommand(new Command('evaluate')
+    .description('Run three-stage evaluation')
+    .requiredOption('--seed <path>', 'Seed specification file')
+    .requiredOption('--artifact <path>', 'Artifact to evaluate')
+    .action((options) => {
+    runCli('workflow', 'evaluate', ['--seed', options.seed, '--artifact', options.artifact]);
+}))
+    .addCommand(new Command('unstuck')
+    .description('Run unstuck lateral thinking')
+    .argument('<problem>', 'Description of what you are stuck on')
+    .action((problem) => {
+    runCli('workflow', 'unstuck', [problem]);
+}))
+    .addCommand(new Command('autoloop')
+    .description('Run autoloop optimization')
+    .requiredOption('--program <path>', 'Program.md file')
+    .action((options) => {
+    runCli('workflow', 'autoloop', ['--program', options.program]);
+}));
+export const selfhealCommand = new Command('selfheal')
+    .description('Self-enhancement tools (introspect, prescribe, evolve)')
+    .addCommand(new Command('introspect')
+    .description('Run 7-metric health scorecard')
+    .option('--json', 'Output raw JSON')
+    .option('--store', 'Persist scorecard')
+    .option('--verbose', 'Print formatted table')
+    .action((options) => {
+    const args = [];
+    if (options.json)
+        args.push('--json');
+    if (options.store)
+        args.push('--store');
+    if (options.verbose)
+        args.push('--verbose');
+    runCli('selfheal', 'introspect', args);
+}))
+    .addCommand(new Command('prescribe')
+    .description('Generate improvement prescription')
+    .option('--scorecard <path>', 'Path to scorecard JSON')
+    .option('--target <metric>', 'Target metric name')
+    .option('--live', 'Run live introspection')
+    .option('--dry-run', 'Preview without writing')
+    .action((options) => {
+    const args = [];
+    if (options.scorecard)
+        args.push('--scorecard', options.scorecard);
+    if (options.target)
+        args.push('--target', options.target);
+    if (options.live)
+        args.push('--live');
+    if (options.dryRun)
+        args.push('--dry-run');
+    runCli('selfheal', 'prescribe', args);
+}))
+    .addCommand(new Command('evolve')
+    .description('Execute prescription with regression detection')
+    .option('--prescription <path>', 'Path to prescription JSON')
+    .option('--dry-run', 'Preview without changes')
+    .option('--skip-governor', 'Bypass governor safety gate')
+    .action((options) => {
+    const args = [];
+    if (options.prescription)
+        args.push('--prescription', options.prescription);
+    if (options.dryRun)
+        args.push('--dry-run');
+    if (options.skipGovernor)
+        args.push('--skip-governor');
+    runCli('selfheal', 'evolve', args);
+}));

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env bun
+/**
+ * Zouroboros CLI
+ *
+ * Unified command-line interface for all Zouroboros packages.
+ *
+ * @module zouroboros-cli
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env bun
+/**
+ * Zouroboros CLI
+ *
+ * Unified command-line interface for all Zouroboros packages.
+ *
+ * @module zouroboros-cli
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { VERSION } from 'zouroboros-core';
+// Import commands
+import { initCommand } from './commands/init.js';
+import { doctorCommand } from './commands/doctor.js';
+import { configCommand } from './commands/config.js';
+import { memoryCommand } from './commands/memory.js';
+import { swarmCommand } from './commands/swarm.js';
+import { personaCommand } from './commands/persona.js';
+import { workflowCommand, selfhealCommand } from './commands/workflow.js';
+import { healCommand } from './commands/heal.js';
+import { tuiCommand } from './commands/tui.js';
+import { backupCommand } from './commands/backup.js';
+import { migrateCommand } from './commands/migrate.js';
+import { skillsCommand } from './commands/skills.js';
+import { agentsCommand } from './commands/agents.js';
+const program = new Command();
+program
+    .name('zouroboros')
+    .description('🐍⭕ Zouroboros - Self-enhancing AI memory and orchestration system')
+    .version(VERSION, '-v, --version', 'Display version number')
+    .helpOption('-h, --help', 'Display help for command')
+    .configureOutput({
+    writeOut: (str) => process.stdout.write(str),
+    writeErr: (str) => process.stderr.write(str),
+});
+// Global options
+program
+    .option('--config <path>', 'Path to config file')
+    .option('--verbose', 'Enable verbose output')
+    .option('--json', 'Output as JSON');
+// Register commands
+program.addCommand(initCommand);
+program.addCommand(doctorCommand);
+program.addCommand(configCommand);
+program.addCommand(memoryCommand);
+program.addCommand(swarmCommand);
+program.addCommand(personaCommand);
+program.addCommand(workflowCommand);
+program.addCommand(selfhealCommand);
+program.addCommand(healCommand);
+program.addCommand(tuiCommand);
+program.addCommand(backupCommand);
+program.addCommand(migrateCommand);
+program.addCommand(skillsCommand);
+program.addCommand(agentsCommand);
+// Default action (no command)
+program.action(() => {
+    console.log(chalk.cyan('\n🐍⭕ Zouroboros'));
+    console.log(chalk.gray('Self-enhancing AI memory and orchestration system\n'));
+    console.log('Run ' + chalk.yellow('zouroboros --help') + ' for available commands\n');
+});
+// Error handling
+program.exitOverride();
+try {
+    await program.parseAsync();
+}
+catch (err) {
+    if (err.code === 'commander.help') {
+        process.exit(0);
+    }
+    if (err.code === 'commander.version') {
+        process.exit(0);
+    }
+    if (err.code === 'commander.unknownOption') {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+    }
+    if (err.code === 'commander.missingArgument') {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+    }
+    throw err;
+}

package/dist/utils/doctor.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Doctor utility - Health check for Zouroboros components
+ */
+export declare function runDoctor(options?: {
+    fix?: boolean;
+}): Promise<boolean>;