@sylphx/flow 2.1.2 → 2.1.4

package/src/commands/flow/setup.ts

@@ -1,312 +0,0 @@
-/**
- * Setup Phase for Flow Command
- * One-time initialization and preparation for command execution
- */
-
-import chalk from 'chalk';
-import { targetManager } from '../../core/target-manager.js';
-import { StateDetector, type ProjectState } from '../../core/state-detector.js';
-import { projectSettings } from '../../utils/config/settings.js';
-import { showWelcome } from '../../utils/display/banner.js';
-import { showStatus } from '../../utils/display/status.js';
-import { loadAgentContent, extractAgentInstructions } from '../run-command.js';
-import type { RunCommandOptions } from '../../types.js';
-import type { FlowOptions, SetupContext } from './types.js';
-
-/**
- * Execute setup phase once (for loop mode)
- * Returns context needed for repeated command execution
- */
-export async function executeSetupPhase(prompt: string | undefined, options: FlowOptions): Promise<SetupContext> {
-  // Quick mode: enable useDefaults and skip prompts
-  if (options.quick) {
-    options.useDefaults = true;
-    console.log(chalk.cyan('⚡ Quick mode enabled - using saved defaults\n'));
-  }
-
-  // Import orchestrator functions
-  const {
-    checkUpgrades,
-    checkComponentIntegrity,
-  } = await import('../flow-orchestrator.js');
-
-  // Show welcome banner (only once)
-  showWelcome();
-
-  let selectedTarget: string | undefined;
-  let state: ProjectState | undefined;
-
-  // Determine target
-  const initialTarget = options.target || (await projectSettings.getDefaultTarget());
-
-  // Detect state if we have a target
-  if (initialTarget && !options.sync) {
-    const detector = new StateDetector();
-
-    if (options.verbose) {
-      console.log(chalk.dim('🤔 Checking project status...\n'));
-    }
-
-    state = await detector.detect();
-
-    if (options.verbose) {
-      await showStatus(state);
-    }
-
-    // Check for upgrades
-    if (!options.quick) {
-      await checkUpgrades(state, options);
-    }
-
-    // Check component integrity
-    await checkComponentIntegrity(state, options);
-  }
-
-  // Initialize if needed
-  const shouldInitialize =
-    !state?.initialized ||
-    options.sync ||
-    options.repair ||
-    options.initOnly;
-
-  if (shouldInitialize) {
-    selectedTarget = await initializeWithTarget(options);
-  }
-
-  // Resolve target
-  const targetForResolution = resolveTargetPriority(options.target, state?.target, selectedTarget);
-
-  if (!targetForResolution) {
-    console.error(chalk.red.bold('✗ No target selected. Use --target or run init first.'));
-    process.exit(1);
-  }
-
-  const resolvedTarget = await targetManager.resolveTarget({
-    target: targetForResolution,
-    allowSelection: false,
-  });
-
-  console.log(chalk.cyan.bold(`━━━ 🎯 Launching ${resolvedTarget}\n`));
-
-  // Validate target support
-  await validateTargetSupport(resolvedTarget);
-
-  // Handle Claude Code specific setup
-  if (resolvedTarget === 'claude-code') {
-    await setupClaudeCode(options);
-  }
-
-  const agent = options.agent || 'coder';
-  const verbose = options.verbose || false;
-
-  if (verbose || options.runOnly || !options.quick) {
-    console.log(`  🤖 Agent: ${chalk.cyan(agent)}`);
-    console.log(`  🎯 Target: ${chalk.cyan(resolvedTarget)}`);
-    if (prompt) {
-      console.log(`  💬 Prompt: ${chalk.dim(prompt)}\n`);
-    } else {
-      console.log(`  💬 Mode: ${chalk.dim('Interactive')}\n`);
-    }
-  }
-
-  // Load agent and prepare prompts
-  const agentContent = await loadAgentContent(agent, options.agentFile);
-  const agentInstructions = extractAgentInstructions(agentContent);
-  const systemPrompt = `AGENT INSTRUCTIONS:\n${agentInstructions}`;
-
-  // Prepare run options
-  const runOptions: RunCommandOptions = {
-    target: resolvedTarget,
-    verbose,
-    dryRun: options.dryRun,
-    agent,
-    agentFile: options.agentFile,
-    prompt,
-    print: options.print,
-    continue: options.continue,
-  };
-
-  return {
-    resolvedTarget,
-    initializedSuccessfully: true,
-    systemPrompt,
-    runOptions,
-  };
-}
-
-/**
- * Initialize project with target selection and component installation
- */
-async function initializeWithTarget(options: FlowOptions): Promise<string | undefined> {
-  let selectedTarget: string | undefined;
-
-  try {
-    const { selectAndValidateTarget, previewDryRun, installComponents } =
-      await import('../init-core.js');
-
-    const initOptions = {
-      target: options.target,
-      verbose: options.verbose || false,
-      dryRun: options.dryRun || false,
-      clear: options.sync || false,
-      mcp: options.mcp !== false,
-      agents: options.agents !== false,
-      rules: options.rules !== false,
-      outputStyles: options.outputStyles !== false,
-      slashCommands: options.slashCommands !== false,
-      hooks: options.hooks !== false,
-    };
-
-    // Handle sync mode - delete template files first
-    if (options.sync && !options.dryRun) {
-      selectedTarget = await handleSyncMode(initOptions);
-    } else if (!options.sync) {
-      const targetId = await selectAndValidateTarget(initOptions);
-      selectedTarget = targetId;
-    }
-
-    if (options.dryRun) {
-      // Ensure we have a target ID for dry run
-      if (!selectedTarget) {
-        const targetId = await selectAndValidateTarget(initOptions);
-        selectedTarget = targetId;
-      }
-
-      await previewDryRun(selectedTarget, initOptions);
-      console.log(chalk.dim('✓ Initialization dry run complete\n'));
-    } else {
-      // Ensure we have a target ID for installation
-      if (!selectedTarget) {
-        const targetId = await selectAndValidateTarget(initOptions);
-        selectedTarget = targetId;
-      }
-
-      await installComponents(selectedTarget, initOptions);
-      console.log(chalk.green.bold('✓ Initialization complete\n'));
-    }
-  } catch (error) {
-    console.error(chalk.red.bold('✗ Initialization failed:'), error);
-    process.exit(1);
-  }
-
-  return selectedTarget;
-}
-
-/**
- * Handle sync mode: delete templates then reinstall
- */
-async function handleSyncMode(initOptions: any): Promise<string> {
-  const { buildSyncManifest, showSyncPreview, selectUnknownFilesToRemove, showFinalSummary, confirmSync, executeSyncDelete, removeMCPServers, removeHooks } = await import('../../utils/files/sync-utils.js');
-  const { selectAndValidateTarget } = await import('../init-core.js');
-
-  // Need target to build manifest
-  const targetId = await selectAndValidateTarget(initOptions);
-
-  const targetOption = targetManager.getTarget(targetId);
-  if (targetOption._tag === 'None') {
-    throw new Error(`Target not found: ${targetId}`);
-  }
-
-  const target = targetOption.value;
-  const manifest = await buildSyncManifest(process.cwd(), target);
-
-  // Show preview
-  console.log(chalk.cyan.bold('━━━ 🔄 Synchronizing Files\n'));
-  showSyncPreview(manifest, process.cwd(), target);
-
-  // Select unknown files to remove
-  const selectedUnknowns = await selectUnknownFilesToRemove(manifest);
-
-  // Show final summary
-  showFinalSummary(manifest, selectedUnknowns);
-
-  // Confirm
-  const confirmed = await confirmSync();
-  if (!confirmed) {
-    console.log(chalk.yellow('\n✗ Sync cancelled\n'));
-    process.exit(0);
-  }
-
-  // Execute deletion
-  const { templates, unknowns } = await executeSyncDelete(manifest, selectedUnknowns);
-
-  // Remove MCP servers
-  let mcpRemoved = 0;
-  if (selectedUnknowns.mcpServers.length > 0) {
-    mcpRemoved = await removeMCPServers(process.cwd(), selectedUnknowns.mcpServers);
-  }
-
-  // Remove hooks
-  let hooksRemoved = 0;
-  if (selectedUnknowns.hooks.length > 0) {
-    hooksRemoved = await removeHooks(process.cwd(), selectedUnknowns.hooks);
-  }
-
-  // Summary
-  console.log(chalk.green(`\n✓ Synced ${templates} templates`));
-  const totalRemoved = unknowns + mcpRemoved + hooksRemoved;
-  if (totalRemoved > 0) {
-    console.log(chalk.green(`✓ Removed ${totalRemoved} items`));
-  }
-  const totalSelected = selectedUnknowns.files.length + selectedUnknowns.mcpServers.length + selectedUnknowns.hooks.length;
-  const preserved = manifest.agents.unknown.length + manifest.slashCommands.unknown.length + manifest.rules.unknown.length + manifest.mcpServers.notInRegistry.length + manifest.hooks.orphaned.length - totalSelected;
-  if (preserved > 0) {
-    console.log(chalk.green(`✓ Preserved ${preserved} custom items`));
-  }
-  console.log('');
-
-  return targetId;
-}
-
-/**
- * Resolve target priority: options > state > selected
- */
-function resolveTargetPriority(
-  optionsTarget: string | undefined,
-  stateTarget: string | undefined,
-  selectedTarget: string | undefined
-): string | undefined {
-  return selectedTarget || optionsTarget || stateTarget;
-}
-
-/**
- * Validate that target supports command execution
- */
-async function validateTargetSupport(resolvedTarget: string): Promise<void> {
-  const { getTargetsWithCommandSupport } = await import('../../config/targets.js');
-  const supportedTargets = getTargetsWithCommandSupport().map(t => t.id);
-
-  if (!supportedTargets.includes(resolvedTarget)) {
-    console.log(chalk.red.bold('✗ Unsupported target platform\n'));
-    console.log(chalk.yellow(`Target '${resolvedTarget}' does not support agent execution.`));
-    console.log(chalk.cyan(`Supported platforms: ${supportedTargets.join(', ')}\n`));
-    console.log(chalk.dim('Tip: Use --target claude-code to specify Claude Code platform'));
-    console.log(chalk.dim('Example: bun dev:flow --target claude-code\n'));
-    process.exit(1);
-  }
-}
-
-/**
- * Setup Claude Code provider and agent
- */
-async function setupClaudeCode(options: FlowOptions): Promise<void> {
-  const { SmartConfigService } = await import('../../services/smart-config-service.js');
-  const { ConfigService } = await import('../../services/config-service.js');
-
-  if (!(await ConfigService.hasInitialSetup())) {
-    console.log(chalk.cyan('🔑 First-time setup for Claude Code\n'));
-    await SmartConfigService.initialSetup();
-    console.log(chalk.green('✓ Setup complete!\n'));
-  }
-
-  const runtimeChoices = await SmartConfigService.selectRuntimeChoices({
-    selectProvider: options.selectProvider,
-    selectAgent: options.selectAgent,
-    useDefaults: options.useDefaults,
-    provider: options.provider,
-    agent: options.agent,
-  });
-
-  await SmartConfigService.setupEnvironment(runtimeChoices.provider!);
-  options.agent = runtimeChoices.agent;
-}

package/src/commands/flow-orchestrator.ts

@@ -1,328 +0,0 @@
-/**
- * Flow Orchestrator - Simplified flow management
- * Separates concerns and reduces complexity
- */
-
-import chalk from 'chalk';
-import type { FlowOptions } from './flow/types.js';
-import { StateDetector, type ProjectState } from '../core/state-detector.js';
-import { UpgradeManager } from '../core/upgrade-manager.js';
-import { targetManager } from '../core/target-manager.js';
-import { detectPackageManager, getUpgradeCommand } from '../utils/package-manager-detector.js';
-
-/**
- * Step 1: Check for available upgrades
- */
-export async function checkUpgrades(
-  state: ProjectState,
-  options: FlowOptions
-): Promise<void> {
-  if (options.initOnly || options.runOnly) return;
-
-  const upgradeManager = new UpgradeManager();
-  const updates = await upgradeManager.checkUpdates();
-  const packageManager = detectPackageManager();
-
-  // Check Flow upgrade
-  if (updates.flowUpdate && updates.flowVersion) {
-    const upgradeCmd = getUpgradeCommand('@sylphx/flow', packageManager);
-    console.log(
-      chalk.yellow(
-        `📦 Sylphx Flow update available: ${updates.flowVersion.current} → ${updates.flowVersion.latest}`
-      )
-    );
-    console.log(chalk.dim(`   Quick upgrade: ${chalk.cyan('sylphx-flow upgrade --auto')}`));
-    console.log(chalk.dim(`   Or run: ${chalk.cyan(upgradeCmd)}\n`));
-  }
-
-  // Check target upgrade
-  if (updates.targetUpdate && updates.targetVersion) {
-    console.log(
-      chalk.yellow(
-        `📦 Target update available: ${updates.targetVersion.current} → ${updates.targetVersion.latest}`
-      )
-    );
-    console.log(chalk.dim(`   Run: ${chalk.cyan('sylphx-flow upgrade --target --auto')}\n`));
-  }
-}
-
-
-/**
- * Step 2: Check component integrity and prompt for repair
- */
-export async function checkComponentIntegrity(
-  state: ProjectState,
-  options: FlowOptions
-): Promise<void> {
-  // Skip if not initialized or cleaning or init-only
-  if (!state.initialized || options.clean || options.initOnly) return;
-
-  // Skip in quick mode
-  if (options.quick) return;
-
-  // Find missing components (target-aware)
-  const missing: string[] = [];
-
-  // Agents are always required
-  if (!state.components.agents.installed) missing.push('agents');
-
-  // For OpenCode: check rules (separate AGENTS.md file)
-  // For Claude Code: rules are included in agent files, so skip this check
-  if (state.target === 'opencode' && !state.components.rules.installed) {
-    missing.push('rules');
-  }
-
-  // Hooks are optional - don't check
-  // Claude Code can have hooks in .claude/hooks/*.js but they're optional
-  // OpenCode doesn't have separate hooks
-
-  // MCP is optional now - many users don't use MCP
-  // if (!state.components.mcp.installed) missing.push('mcp');
-
-  // Output styles:
-  // - Claude Code: included in agent files, so skip check
-  // - OpenCode: included in AGENTS.md, so skip check
-
-  // Slash commands are optional
-  // if (!state.components.slashCommands.installed) missing.push('slash commands');
-
-  // If no missing components, we're good
-  if (missing.length === 0) return;
-
-  // Prompt user to repair
-  console.log(chalk.yellow(`\n⚠️  Missing components detected: ${missing.join(', ')}\n`));
-  const { default: inquirer } = await import('inquirer');
-  const { repair } = await inquirer.prompt([
-    {
-      type: 'confirm',
-      name: 'repair',
-      message: 'Install missing components now?',
-      default: true,
-    },
-  ]);
-
-  if (repair) {
-    // Set repair mode - will trigger component installation without full re-init
-    options.repair = true;
-    console.log(chalk.cyan('\n🔧 Repairing components...\n'));
-  } else {
-    console.log(chalk.dim('Skipping repair. Components may not work correctly.\n'));
-  }
-}
-
-/**
- * Step 2.5: Check sync status (new templates available)
- * Only checks for missing templates, ignores unknown files
- */
-export async function checkSyncStatus(
-  state: ProjectState,
-  options: FlowOptions
-): Promise<void> {
-  // Skip if not initialized, syncing, or init-only
-  if (!state.initialized || options.sync || options.initOnly) return;
-
-  // Skip in quick mode
-  if (options.quick) return;
-
-  // Need target to check sync status
-  if (!state.target) return;
-
-  try {
-    const { buildSyncManifest } = await import('../utils/files/sync-utils.js');
-    const target = targetManager.getTarget(state.target);
-
-    if (target._tag === 'None') return;
-
-    const manifest = await buildSyncManifest(process.cwd(), target.value);
-
-    // Count missing templates (new templates not installed locally)
-    const missingCount =
-      manifest.agents.missing.length +
-      manifest.slashCommands.missing.length +
-      manifest.rules.missing.length;
-
-    // Only prompt if there are missing templates
-    if (missingCount > 0) {
-      const missing: string[] = [];
-
-      if (manifest.agents.missing.length > 0) {
-        missing.push(`${manifest.agents.missing.length} agent${manifest.agents.missing.length > 1 ? 's' : ''}`);
-      }
-      if (manifest.slashCommands.missing.length > 0) {
-        missing.push(`${manifest.slashCommands.missing.length} command${manifest.slashCommands.missing.length > 1 ? 's' : ''}`);
-      }
-      if (manifest.rules.missing.length > 0) {
-        missing.push(`${manifest.rules.missing.length} rule${manifest.rules.missing.length > 1 ? 's' : ''}`);
-      }
-
-      console.log(chalk.yellow(`\n📦 New templates available: ${missing.join(', ')}\n`));
-      console.log(chalk.dim(`   Run ${chalk.cyan('sylphx-flow --sync')} to install new templates\n`));
-    }
-  } catch (error) {
-    // Silently ignore sync check errors - don't block execution
-  }
-}
-
-/**
- * Step 3: Handle target selection
- * Returns the selected target ID
- */
-export async function selectTarget(
-  state: ProjectState,
-  options: FlowOptions
-): Promise<string | undefined> {
-  // Force target selection when cleaning
-  if (options.clean) {
-    try {
-      const targetId = await targetManager.promptForTargetSelection();
-      console.log(chalk.green(`✅ Selected target: ${targetId}`));
-      return targetId;
-    } catch (error) {
-      // User cancelled with Ctrl+C - exit gracefully
-      if (error instanceof Error && error.name === 'ExitPromptError') {
-        console.log('\n');
-        process.exit(0);
-      }
-      throw error;
-    }
-  }
-
-  // Use existing target or option
-  return options.target || state.target;
-}
-
-/**
- * Step 3: Initialize project
- */
-export async function initializeProject(
-  targetId: string | undefined,
-  options: FlowOptions
-): Promise<void> {
-  if (options.runOnly && !options.clean) return;
-
-  console.log(chalk.cyan.bold('━ Initializing Project\n'));
-
-  const { runInit } = await import('./init-command.js');
-
-  const initOptions = {
-    target: targetId,
-    verbose: options.verbose,
-    dryRun: options.dryRun,
-    clear: options.clean || false,
-    mcp: options.mcp !== false,
-    agents: options.agents !== false,
-    rules: options.rules !== false,
-    outputStyles: options.outputStyles !== false,
-    slashCommands: options.slashCommands !== false,
-    hooks: options.hooks !== false,
-    helpOption: () => {},
-  };
-
-  try {
-    await runInit(initOptions);
-
-    if (!options.dryRun) {
-      console.log(chalk.green.bold('\n✓ Initialization complete\n'));
-    } else {
-      console.log(chalk.dim('\n✓ Dry run complete - skipping execution\n'));
-    }
-  } catch (error) {
-    console.error(chalk.red.bold('\n✗ Initialization failed:'), error);
-    throw error;
-  }
-}
-
-/**
- * Step 4: Launch target
- */
-export async function launchTarget(
-  targetId: string | undefined,
-  prompt: string | undefined,
-  options: FlowOptions,
-  state: ProjectState
-): Promise<void> {
-  if (options.initOnly) return;
-
-  // Resolve target
-  const resolvedTarget = await targetManager.resolveTarget({
-    target: targetId || state.target,
-    allowSelection: false,
-  });
-
-  console.log(chalk.cyan.bold(`━ Launching ${resolvedTarget}\n`));
-
-  // Check if target supports command execution
-  const { getTargetsWithCommandSupport } = await import('../config/targets.js');
-  const supportedTargets = getTargetsWithCommandSupport().map(t => t.id);
-
-  if (!supportedTargets.includes(resolvedTarget)) {
-    console.log(chalk.red.bold('✗ Unsupported target platform\n'));
-    console.log(
-      chalk.yellow(`Target '${resolvedTarget}' does not support agent execution.`)
-    );
-    console.log(chalk.cyan(`Supported platforms: ${supportedTargets.join(', ')}\n`));
-    throw new Error(`Unsupported target: ${resolvedTarget}`);
-  }
-
-  // Handle Claude Code specific setup
-  if (resolvedTarget === 'claude-code') {
-    await setupClaudeCode(options);
-  }
-
-  // Execute command
-  await executeCommand(resolvedTarget, prompt, options);
-}
-
-/**
- * Setup Claude Code (provider + agent selection)
- */
-async function setupClaudeCode(options: FlowOptions): Promise<void> {
-  const { SmartConfigService } = await import('../services/smart-config-service.js');
-  const { ConfigService } = await import('../services/config-service.js');
-
-  // Check if API keys are configured
-  if (!(await ConfigService.hasInitialSetup())) {
-    console.log(chalk.cyan('\n🔑 First-time setup for Claude Code:\n'));
-    await SmartConfigService.initialSetup();
-    console.log(chalk.green('\n✅ Claude Code setup complete!\n'));
-  }
-
-  // Select provider and agent
-  const runtimeChoices = await SmartConfigService.selectRuntimeChoices({
-    selectProvider: options.selectProvider,
-    selectAgent: options.selectAgent,
-    useDefaults: options.useDefaults,
-    provider: options.provider,
-    agent: options.agent,
-  });
-
-  // Setup environment
-  await SmartConfigService.setupEnvironment(runtimeChoices.provider!);
-
-  // Store selected agent
-  options.agent = runtimeChoices.agent;
-}
-
-/**
- * Execute the target command
- */
-async function executeCommand(
-  targetId: string,
-  prompt: string | undefined,
-  options: FlowOptions
-): Promise<void> {
-  const agent = options.agent || 'coder';
-  const verbose = options.verbose || false;
-
-  if (verbose || options.runOnly) {
-    console.log(`🤖 Agent: ${agent}`);
-    console.log(`🎯 Target: ${targetId}`);
-    if (prompt) {
-      console.log(`💬 Prompt: ${prompt}\n`);
-    }
-  }
-
-  // Run the command
-  const { runCommand } = await import('./run-command.js');
-  await runCommand({ target: targetId, agent, prompt, verbose });
-}