@sethdouglasford/claude-flow/dist/cli/commands/startup.js

Claude Code Flow - Advanced AI-powered development workflows with SPARC methodology

/**
 * Startup Command - Comprehensive orientation and capability activation
 */
import { Command } from "../cliffy-compat.js";
import chalk from "chalk";
// Startup Protocols
const STARTUP_PROTOCOLS = {
    "metaclaude": {
        name: "MetaClaude Startup Process",
        description: "Comprehensive orientation and capability activation protocol",
        usage: "/metaclaude [context] [--capabilities=FOCUS] [--integration=LEVEL] [--tutorials=ADVANCED]",
        features: [
            "Capability awareness and activation",
            "Environment integration setup",
            "Autonomous operation enablement",
            "Advanced tutorial access",
            "Resource discovery and connection"
        ],
        capabilities: [
            "🔧 True Terminal Integration - Direct command execution and development workflows",
            "🗂️ Autonomous Codebase Exploration - Navigate and understand projects automatically",
            "⚡ Real-Time Development Actions - Multi-file editing and coordinated changes",
            "🔀 Advanced Git Operations - Natural language commit history and PR generation",
            "🌐 Web-Connected Research - Real-time documentation and best practices",
            "🏢 Enterprise-Grade Integration - Bedrock, Vertex AI, and compliance support"
        ],
        tutorials: [
            "Conversation Continuity & Memory Management",
            "Comprehensive Codebase Understanding",
            "Advanced Debugging & Bug Resolution",
            "Intelligent Code Refactoring",
            "Comprehensive Testing Strategy",
            "Professional Pull Request Management",
            "Documentation Generation & Maintenance",
            "Visual & Image Analysis Integration",
            "Extended Thinking for Complex Problems",
            "Model Context Protocol (MCP) Integration",
            "Unix-Style Utility Integration",
            "Custom Command Creation & Management",
            "Parallel Development with Git Worktrees"
        ]
    }
};
async function startupAction(ctx) {
    const subcommand = ctx.args[0];
    switch (subcommand) {
        case "list":
            await listStartupProtocols(ctx);
            break;
        case "info":
            await showStartupInfo(ctx);
            break;
        case "run":
            await runStartupProtocol(ctx);
            break;
        case "activate":
            await activateCapabilities(ctx);
            break;
        case "check":
            await checkActivation(ctx);
            break;
        default:
            await showStartupHelp();
            break;
    }
}
async function listStartupProtocols(ctx) {
    const verbose = ctx.flags.verbose;
    console.log(chalk.cyan.bold("\n🚀 Startup Protocols\n"));
    console.log(chalk.gray("Comprehensive orientation and capability activation systems\n"));
    for (const [key, protocol] of Object.entries(STARTUP_PROTOCOLS)) {
        console.log(`${chalk.cyan("•")} ${chalk.bold(protocol.name)} ${chalk.gray(`(${key})`)}`);
        console.log(`  ${protocol.description}`);
        if (verbose) {
            console.log(chalk.blue("  Features:"));
            protocol.features.forEach(feature => {
                console.log(`    - ${feature}`);
            });
            console.log(chalk.green("  Core Capabilities:"));
            protocol.capabilities.forEach(capability => {
                console.log(`    - ${capability}`);
            });
            console.log(chalk.yellow("  Advanced Tutorials:"));
            protocol.tutorials.slice(0, 5).forEach(tutorial => {
                console.log(`    - ${tutorial}`);
            });
            if (protocol.tutorials.length > 5) {
                console.log(`    - ... and ${protocol.tutorials.length - 5} more`);
            }
            console.log(chalk.gray(`  Usage: ${protocol.usage}`));
        }
        console.log();
    }
    if (!verbose) {
        console.log(chalk.gray("Use --verbose for detailed information"));
    }
}
async function showStartupInfo(ctx) {
    const protocolName = ctx.args[1];
    if (!protocolName) {
        console.error(chalk.red("Error: Protocol name required"));
        console.log("Usage: claude-flow startup info <protocol-name>");
        return;
    }
    const protocol = STARTUP_PROTOCOLS[protocolName];
    if (!protocol) {
        console.error(chalk.red(`Error: Protocol '${protocolName}' not found`));
        console.log("\nAvailable protocols:");
        Object.keys(STARTUP_PROTOCOLS).forEach(key => {
            console.log(`  - ${key}`);
        });
        return;
    }
    console.log(chalk.cyan.bold(`\n${protocol.name}\n`));
    console.log(protocol.description);
    console.log();
    console.log(chalk.blue("Usage:"));
    console.log(`  ${protocol.usage}`);
    console.log();
    console.log(chalk.green("Key Features:"));
    protocol.features.forEach(feature => {
        console.log(`  • ${feature}`);
    });
    console.log();
    console.log(chalk.yellow("Core Agentic Capabilities:"));
    protocol.capabilities.forEach(capability => {
        console.log(`  • ${capability}`);
    });
    console.log();
    console.log(chalk.magenta("Advanced Tutorial Capabilities:"));
    protocol.tutorials.forEach(tutorial => {
        console.log(`  • ${tutorial}`);
    });
    console.log();
}
async function runStartupProtocol(ctx) {
    const protocolName = ctx.args[1];
    const context = ctx.args.slice(2).join(" ");
    if (!protocolName) {
        console.error(chalk.red("Error: Protocol name required"));
        console.log("Usage: claude-flow startup run <protocol-name> [context]");
        return;
    }
    const protocol = STARTUP_PROTOCOLS[protocolName];
    if (!protocol) {
        console.error(chalk.red(`Error: Protocol '${protocolName}' not found`));
        return;
    }
    console.log(chalk.cyan(`\n🚀 Executing ${protocol.name}`));
    if (context) {
        console.log(chalk.gray(`Context: ${context}`));
    }
    console.log();
    // Simulate startup protocol execution
    console.log(chalk.blue("🔄 Initializing startup protocol..."));
    await new Promise(resolve => setTimeout(resolve, 1000));
    console.log(chalk.green("✅ Core Powers Activated:"));
    console.log("  ✓ Terminal Integration - Can execute commands and manage environment");
    console.log("  ✓ Codebase Understanding - Can navigate and analyze project structure");
    console.log("  ✓ Git Operations - Can manage version control and commit workflows");
    console.log("  ✓ Web Research - Can access and integrate external documentation");
    console.log("  ✓ Multi-File Operations - Can coordinate changes across multiple files");
    console.log();
    console.log(chalk.yellow("🎓 Advanced Capabilities Enabled:"));
    console.log("  ✓ Memory Management - Can maintain context across sessions");
    console.log("  ✓ Testing Integration - Can run, create, and maintain test suites");
    console.log("  ✓ Documentation Generation - Can create and update project docs");
    console.log("  ✓ Performance Analysis - Can identify and resolve performance issues");
    console.log("  ✓ Architecture Understanding - Can explain and improve system design");
    console.log();
    console.log(chalk.magenta("🏢 Enterprise Features Ready:"));
    console.log("  ✓ MCP Integration - Can connect to external tools and services");
    console.log("  ✓ Custom Commands - Can create and manage project-specific workflows");
    console.log("  ✓ CI/CD Integration - Can function in automated development pipelines");
    console.log("  ✓ Security Compliance - Can maintain security and compliance standards");
    console.log("  ✓ Team Collaboration - Can support multi-developer workflows");
    console.log();
    console.log(chalk.green.bold("🎯 Startup Protocol Complete!"));
    console.log(chalk.gray("Claude Code is now operating as a full agentic development partner."));
}
async function activateCapabilities(ctx) {
    const capabilities = ctx.flags.capabilities;
    console.log(chalk.cyan("\n🔧 Activating Specific Capabilities\n"));
    if (capabilities) {
        const capabilityList = capabilities.split(",").map(c => c.trim());
        console.log(chalk.blue("Requested capabilities:"));
        capabilityList.forEach(cap => {
            console.log(`  • ${cap}`);
        });
        console.log();
    }
    // Simulate capability activation
    console.log(chalk.yellow("⚠️  Capability activation not yet implemented"));
    console.log(chalk.gray("This will integrate with the core agent activation system"));
    console.log();
    console.log(chalk.blue("Planned Activation:"));
    console.log("  • Terminal integration setup");
    console.log("  • Environment optimization");
    console.log("  • Memory system initialization");
    console.log("  • Tool integration verification");
    console.log("  • Performance benchmarking");
}
async function checkActivation(ctx) {
    console.log(chalk.cyan("\n🔍 Checking Activation Status\n"));
    // Check memory management status
    let memoryStatus = "inactive";
    try {
        const { MemoryManager } = await import("../../memory/manager.js");
        if (MemoryManager) {
            memoryStatus = "active";
        }
    }
    catch (error) {
        memoryStatus = "inactive";
    }
    // Check MCP integration status
    let mcpStatus = "inactive";
    try {
        const mcpConfig = process.env.MCP_SERVER_URL || process.env.MCP_ENABLED;
        if (mcpConfig) {
            mcpStatus = "partial";
        }
    }
    catch (error) {
        mcpStatus = "inactive";
    }
    // Check web research capability
    let webResearchStatus = "inactive";
    const hasWebApiKeys = process.env.PERPLEXITY_API_KEY || process.env.GOOGLE_API_KEY || process.env.OPENAI_API_KEY;
    if (hasWebApiKeys) {
        webResearchStatus = "partial";
    }
    // Check enterprise features
    let enterpriseStatus = "inactive";
    const hasEnterpriseConfig = process.env.ENTERPRISE_MODE || process.env.BEDROCK_REGION;
    if (hasEnterpriseConfig) {
        enterpriseStatus = "partial";
    }
    const checks = [
        { name: "Terminal Integration", status: "active", icon: "✅" },
        { name: "Codebase Understanding", status: "active", icon: "✅" },
        { name: "Git Operations", status: "active", icon: "✅" },
        { name: "Web Research", status: webResearchStatus, icon: webResearchStatus === "partial" ? "⚠️" : "❌" },
        { name: "Multi-File Operations", status: "active", icon: "✅" },
        { name: "Memory Management", status: memoryStatus, icon: memoryStatus === "active" ? "✅" : "❌" },
        { name: "MCP Integration", status: mcpStatus, icon: mcpStatus === "partial" ? "⚠️" : "❌" },
        { name: "Enterprise Features", status: enterpriseStatus, icon: enterpriseStatus === "partial" ? "⚠️" : "❌" }
    ];
    console.log(chalk.blue("Capability Status:"));
    checks.forEach(check => {
        const statusColor = check.status === "active" ? chalk.green :
            check.status === "partial" ? chalk.yellow : chalk.red;
        console.log(`  ${check.icon} ${check.name.padEnd(25)} ${statusColor(check.status)}`);
    });
    console.log();
    const activeCount = checks.filter(c => c.status === "active").length;
    const totalCount = checks.length;
    const percentage = Math.round((activeCount / totalCount) * 100);
    console.log(chalk.cyan(`Overall Activation: ${percentage}% (${activeCount}/${totalCount} capabilities)`));
    if (percentage < 100) {
        console.log();
        console.log(chalk.yellow("Recommendations:"));
        console.log("  • Run 'claude-flow startup run metaclaude' for full activation");
        if (mcpStatus !== "active") {
            console.log("  • Check MCP server configuration for integration features");
        }
        if (webResearchStatus !== "active") {
            console.log("  • Set API keys (PERPLEXITY_API_KEY, GOOGLE_API_KEY) for web research");
        }
        if (memoryStatus !== "active") {
            console.log("  • Memory management system is available and ready");
        }
        if (enterpriseStatus !== "active") {
            console.log("  • Set ENTERPRISE_MODE or BEDROCK_REGION for enterprise features");
        }
    }
}
async function showStartupHelp() {
    console.log(chalk.cyan.bold("Startup"));
    console.log();
    console.log("Comprehensive orientation and capability activation protocols that transform");
    console.log("Claude Code from a simple assistant into a powerful agentic development partner.");
    console.log();
    console.log(chalk.blue("Commands:"));
    console.log("  list                     List all available startup protocols");
    console.log("  info <protocol>          Show detailed protocol information");
    console.log("  run <protocol> [ctx]     Execute startup protocol with optional context");
    console.log("  activate [--cap=LIST]    Activate specific capabilities");
    console.log("  check                    Check current activation status");
    console.log();
    console.log(chalk.blue("Available Protocols:"));
    Object.entries(STARTUP_PROTOCOLS).forEach(([key, protocol]) => {
        console.log(`  ${chalk.cyan(key.padEnd(20))} ${protocol.description}`);
    });
    console.log();
    console.log(chalk.blue("Options:"));
    console.log("  --verbose               Show detailed information");
    console.log("  --capabilities=LIST     Focus on specific capability areas");
    console.log("  --integration=LEVEL     Integration depth (basic, standard, advanced, expert)");
    console.log("  --tutorials=ADVANCED    Include advanced tutorial capabilities");
    console.log();
    console.log(chalk.blue("Examples:"));
    console.log("  claude-flow startup list --verbose");
    console.log("  claude-flow startup info metaclaude");
    console.log('  claude-flow startup run metaclaude "Node.js project"');
    console.log("  claude-flow startup activate --capabilities=terminal,git,mcp");
    console.log("  claude-flow startup check");
}
export const startupCommand = new Command()
    .name("startup")
    .description("Comprehensive orientation and capability activation protocols")
    .arguments("[subcommand] [args...]")
    .option("--verbose, -v", "Show detailed information")
    .option("--capabilities <list>", "Focus on specific capability areas")
    .option("--integration <level>", "Integration depth (basic, standard, advanced, expert)")
    .option("--tutorials", "Include advanced tutorial capabilities")
    .action(async (subcommand, args, options) => {
    const ctx = {
        args: [subcommand, ...args].filter(Boolean),
        flags: options || {},
    };
    await startupAction(ctx);
});
//# sourceMappingURL=startup.js.map