@sylphx/flow 2.1.3 → 2.1.5

package/src/commands/init-core.ts

@@ -1,331 +0,0 @@
-/**
- * Core initialization logic - extracted for reuse without UI coupling
- * Used by both flow command (integrated) and legacy init command (standalone)
- */
-
-import chalk from 'chalk';
-import ora from 'ora';
-import { targetManager } from '../core/target-manager.js';
-import { CLIError } from '../utils/error-handler.js';
-import { projectSettings } from '../utils/config/settings.js';
-import { validateTarget } from '../utils/config/target-config.js';
-import { ConfigService } from '../services/config-service.js';
-
-export interface InitOptions {
-  target?: string;
-  verbose?: boolean;
-  dryRun?: boolean;
-  clear?: boolean;
-  mcp?: boolean;
-  agents?: boolean;
-  rules?: boolean;
-  outputStyles?: boolean;
-  slashCommands?: boolean;
-  hooks?: boolean;
-  quiet?: boolean; // Suppress all output for programmatic use
-}
-
-export interface ComponentInstallResult {
-  targetId: string;
-  targetName: string;
-  installed: {
-    mcp?: number;
-    agents?: number;
-    outputStyles?: number;
-    rules?: number;
-    slashCommands?: number;
-    hooks?: number;
-  };
-}
-
-/**
- * Select and validate target - PURE LOGIC, no UI
- * @returns targetId
- */
-export async function selectAndValidateTarget(options: InitOptions): Promise<string> {
-  let targetId = options.target;
-
-  // Target selection (with UI prompt if needed)
-  if (!targetId) {
-    try {
-      targetId = await targetManager.promptForTargetSelection();
-    } catch (error) {
-      // User cancelled with Ctrl+C - exit gracefully
-      if (error instanceof Error && error.name === 'ExitPromptError') {
-        console.log('\n');
-        process.exit(0);
-      }
-      throw error;
-    }
-  }
-
-  // Validate target
-  if (targetId) {
-    try {
-      validateTarget(targetId);
-    } catch (error) {
-      if (error instanceof Error) {
-        throw new CLIError(error.message, 'UNSUPPORTED_TARGET');
-      }
-      throw error;
-    }
-  }
-
-  if (!targetId) {
-    throw new Error('Target ID not set');
-  }
-
-  return targetId;
-}
-
-/**
- * Preview what will be installed in dry run mode
- */
-export async function previewDryRun(targetId: string, options: InitOptions): Promise<void> {
-  const targetOption = targetManager.getTarget(targetId);
-  if (targetOption._tag === 'None') {
-    throw new Error(`Target not found: ${targetId}`);
-  }
-
-  const target = targetOption.value;
-
-  if (options.mcp !== false && target.setupMCP) {
-    console.log(chalk.cyan.bold('MCP Tools:'));
-    console.log(chalk.dim('  ✓ MCP servers will be configured'));
-  }
-
-  if (options.agents !== false && target.setupAgents) {
-    console.log(chalk.cyan.bold('\nAgents:'));
-    console.log(chalk.dim('  ✓ Development agents will be installed'));
-  }
-
-  if (options.outputStyles !== false && target.setupOutputStyles) {
-    console.log(chalk.cyan.bold('\nOutput Styles:'));
-    console.log(chalk.dim('  ✓ Output styles will be installed'));
-  }
-
-  if (options.rules !== false && target.setupRules) {
-    console.log(chalk.cyan.bold('\nRules:'));
-    console.log(chalk.dim('  ✓ Custom rules will be installed'));
-  }
-
-  if (options.slashCommands !== false && target.setupSlashCommands) {
-    console.log(chalk.cyan.bold('\nSlash Commands:'));
-    console.log(chalk.dim('  ✓ Slash commands will be installed'));
-  }
-
-  if (options.hooks !== false && target.setupHooks) {
-    console.log(chalk.cyan.bold('\nHooks:'));
-    console.log(chalk.dim('  ✓ Hooks will be configured'));
-  }
-}
-
-/**
- * Install all components - CORE LOGIC with minimal UI
- */
-export async function installComponents(
-  targetId: string,
-  options: InitOptions
-): Promise<ComponentInstallResult> {
-  const targetOption = targetManager.getTarget(targetId);
-  if (targetOption._tag === 'None') {
-    throw new Error(`Target not found: ${targetId}`);
-  }
-
-  const target = targetOption.value;
-  const quiet = options.quiet || false;
-  const result: ComponentInstallResult = {
-    targetId,
-    targetName: target.name,
-    installed: {},
-  };
-
-  // Setup MCP servers if target supports it and MCP is enabled
-  // Note: No spinner here because MCP setup is interactive (user prompts)
-  if (target.setupMCP && options.mcp !== false) {
-    try {
-      const mcpResult = await target.setupMCP(process.cwd(), options);
-      result.installed.mcp = mcpResult.count;
-
-      if (!quiet) {
-        if (mcpResult.count > 0) {
-          console.log(
-            chalk.green(
-              `✔ Installed ${chalk.cyan(mcpResult.count)} MCP server${mcpResult.count !== 1 ? 's' : ''}`
-            )
-          );
-        } else {
-          console.log(chalk.dim('ℹ No MCP servers selected'));
-        }
-      }
-    } catch (error) {
-      // If user cancels MCP setup (Ctrl+C), continue with other components
-      if (error instanceof Error && error.name === 'ExitPromptError') {
-        if (!quiet) {
-          console.log(chalk.yellow('\n⚠️  MCP setup cancelled, continuing with other components\n'));
-        }
-      } else {
-        if (!quiet) {
-          console.error(chalk.red('✖ Failed to setup MCP servers'));
-        }
-        throw error;
-      }
-    }
-  }
-
-  // Install agents if target supports it and agents are not skipped
-  if (target.setupAgents && options.agents !== false) {
-    const agentSpinner = quiet ? null : ora({ text: 'Installing agents', color: 'cyan' }).start();
-    try {
-      const agentResult = await target.setupAgents(process.cwd(), { ...options, quiet: true, force: options.clear });
-      result.installed.agents = agentResult.count;
-
-      if (agentSpinner) {
-        agentSpinner.succeed(
-          chalk.green(`Installed ${chalk.cyan(agentResult.count)} agent${agentResult.count !== 1 ? 's' : ''}`)
-        );
-      }
-    } catch (error) {
-      if (agentSpinner) {
-        agentSpinner.fail(chalk.red('Failed to install agents'));
-      }
-      throw error;
-    }
-  }
-
-  // Install output styles if target supports it and output styles are not skipped
-  if (target.setupOutputStyles && options.outputStyles !== false) {
-    const stylesSpinner = quiet ? null : ora({ text: 'Installing output styles', color: 'cyan' }).start();
-    try {
-      const stylesResult = await target.setupOutputStyles(process.cwd(), { ...options, quiet: true, force: options.clear });
-      result.installed.outputStyles = stylesResult.count;
-
-      if (stylesSpinner) {
-        if (stylesResult.count > 0) {
-          stylesSpinner.succeed(
-            chalk.green(
-              `Installed ${chalk.cyan(stylesResult.count)} output style${stylesResult.count !== 1 ? 's' : ''}`
-            )
-          );
-        } else if (stylesResult.message) {
-          stylesSpinner.info(chalk.dim(stylesResult.message));
-        } else {
-          stylesSpinner.info(chalk.dim('No output styles to install'));
-        }
-      }
-    } catch (error) {
-      if (stylesSpinner) {
-        stylesSpinner.fail(chalk.red('Failed to install output styles'));
-      }
-      throw error;
-    }
-  }
-
-  // Install rules if target supports it and rules are not skipped
-  if (target.setupRules && options.rules !== false) {
-    const rulesSpinner = quiet ? null : ora({ text: 'Installing rules', color: 'cyan' }).start();
-    try {
-      const rulesResult = await target.setupRules(process.cwd(), { ...options, quiet: true, force: options.clear });
-      result.installed.rules = rulesResult.count;
-
-      if (rulesSpinner) {
-        if (rulesResult.count > 0) {
-          rulesSpinner.succeed(
-            chalk.green(
-              `Installed ${chalk.cyan(rulesResult.count)} rule${rulesResult.count !== 1 ? 's' : ''}`
-            )
-          );
-        } else if (rulesResult.message) {
-          rulesSpinner.info(chalk.dim(rulesResult.message));
-        } else {
-          rulesSpinner.info(chalk.dim('No rules to install'));
-        }
-      }
-    } catch (error) {
-      if (rulesSpinner) {
-        rulesSpinner.fail(chalk.red('Failed to install rules'));
-      }
-      throw error;
-    }
-  }
-
-  // Install slash commands if target supports it and slash commands are not skipped
-  if (target.setupSlashCommands && options.slashCommands !== false) {
-    const commandsSpinner = quiet ? null : ora({
-      text: 'Installing slash commands',
-      color: 'cyan',
-    }).start();
-    try {
-      const commandsResult = await target.setupSlashCommands(process.cwd(), { ...options, quiet: true, force: options.clear });
-      result.installed.slashCommands = commandsResult.count;
-
-      if (commandsSpinner) {
-        if (commandsResult.count > 0) {
-          commandsSpinner.succeed(
-            chalk.green(
-              `Installed ${chalk.cyan(commandsResult.count)} slash command${commandsResult.count !== 1 ? 's' : ''}`
-            )
-          );
-        } else if (commandsResult.message) {
-          commandsSpinner.info(chalk.dim(commandsResult.message));
-        } else {
-          commandsSpinner.info(chalk.dim('No slash commands to install'));
-        }
-      }
-    } catch (error) {
-      if (commandsSpinner) {
-        commandsSpinner.fail(chalk.red('Failed to install slash commands'));
-      }
-      throw error;
-    }
-  }
-
-  // Setup hooks if target supports it and hooks are not skipped
-  if (target.setupHooks && options.hooks !== false) {
-    const hooksSpinner = quiet ? null : ora({ text: 'Setting up hooks', color: 'cyan' }).start();
-    try {
-      const hooksResult = await target.setupHooks(process.cwd(), { ...options, quiet: true });
-      result.installed.hooks = hooksResult.count;
-
-      if (hooksSpinner) {
-        if (hooksResult.count > 0) {
-          const message = hooksResult.message
-            ? `Configured ${chalk.cyan(hooksResult.count)} hook${hooksResult.count !== 1 ? 's' : ''} - ${hooksResult.message}`
-            : `Configured ${chalk.cyan(hooksResult.count)} hook${hooksResult.count !== 1 ? 's' : ''}`;
-          hooksSpinner.succeed(chalk.green(message));
-        } else {
-          hooksSpinner.info(chalk.dim(hooksResult.message || 'No hooks to configure'));
-        }
-      }
-    } catch (error) {
-      // Don't fail entire setup if hooks fail
-      if (hooksSpinner) {
-        hooksSpinner.warn(chalk.yellow('Could not setup hooks'));
-        console.warn(chalk.dim(`  ${error instanceof Error ? error.message : String(error)}`));
-      }
-    }
-  }
-
-  // Save the selected target as project default
-  try {
-    await projectSettings.setDefaultTarget(targetId);
-
-    // Save to new ConfigService for proper layered configuration
-    await ConfigService.saveProjectSettings({
-      target: targetId,
-      version: '1.0.0',
-      lastUpdated: new Date().toISOString(),
-    });
-  } catch (error) {
-    // Don't fail the entire setup if we can't save settings
-    if (!quiet) {
-      console.warn(
-        chalk.yellow(
-          `⚠ Warning: Could not save default target: ${error instanceof Error ? error.message : String(error)}`
-        )
-      );
-    }
-  }
-
-  return result;
-}

package/src/core/agent-manager.ts

@@ -1,174 +0,0 @@
-/**
- * Agent Manager
- * Manages agent state and operations
- */
-
-import type { Agent } from '../types/agent.types.js';
-import { loadAllAgents } from './agent-loader.js';
-import { DEFAULT_AGENT_ID } from './builtin-agents.js';
-
-/**
- * Agent manager state
- */
-interface AgentManagerState {
-  agents: Map<string, Agent>;
-  cwd: string;
-}
-
-let state: AgentManagerState | null = null;
-
-/**
- * Get the app store (lazy import to avoid circular dependencies)
- */
-let getAppStore: (() => any) | null = null;
-
-/**
- * Fallback agent when state is not initialized
- */
-const FALLBACK_AGENT: Agent = {
-  id: DEFAULT_AGENT_ID,
-  metadata: {
-    name: 'Coder',
-    description: 'Fallback agent (agent manager not initialized)',
-  },
-  systemPrompt: 'You are a helpful coding assistant.',
-  isBuiltin: true,
-};
-
-/**
- * Set the app store getter (called during initialization)
- */
-export function setAppStoreGetter(getter: () => any): void {
-  getAppStore = getter;
-}
-
-/**
- * Initialize agent manager
- */
-export async function initializeAgentManager(cwd: string): Promise<void> {
-  const allAgents = await loadAllAgents(cwd);
-
-  const agentMap = new Map<string, Agent>();
-  for (const agent of allAgents) {
-    agentMap.set(agent.id, agent);
-  }
-
-  state = {
-    agents: agentMap,
-    cwd,
-  };
-
-  // Initialize store with default agent if store is available
-  if (getAppStore) {
-    const store = getAppStore();
-    if (store.getState) {
-      const currentAgentId = store.getState().currentAgentId || DEFAULT_AGENT_ID;
-      // Ensure the current agent exists, fallback to default if not
-      if (!agentMap.has(currentAgentId)) {
-        store.getState().setCurrentAgentId(DEFAULT_AGENT_ID);
-      }
-    }
-  }
-}
-
-/**
- * Get all available agents
- */
-export function getAllAgents(): Agent[] {
-  if (!state) {
-    return [FALLBACK_AGENT];
-  }
-  return Array.from(state.agents.values());
-}
-
-/**
- * Get agent by ID
- */
-export function getAgentById(id: string): Agent | null {
-  if (!state) {
-    return id === DEFAULT_AGENT_ID ? FALLBACK_AGENT : null;
-  }
-  return state.agents.get(id) || null;
-}
-
-/**
- * Get current agent
- */
-export function getCurrentAgent(): Agent {
-  const currentAgentId = getCurrentAgentId();
-
-  if (!state) {
-    return FALLBACK_AGENT;
-  }
-  return state.agents.get(currentAgentId) || FALLBACK_AGENT;
-}
-
-/**
- * Get current agent ID
- */
-export function getCurrentAgentId(): string {
-  // Try to get from store first
-  if (getAppStore) {
-    const store = getAppStore();
-    if (store.getState) {
-      return store.getState().currentAgentId || DEFAULT_AGENT_ID;
-    }
-  }
-  // Fallback to default
-  return DEFAULT_AGENT_ID;
-}
-
-/**
- * Switch to a different agent
- */
-export function switchAgent(agentId: string): boolean {
-  if (!state) {
-    return false;
-  }
-
-  const agent = state.agents.get(agentId);
-  if (!agent) {
-    return false;
-  }
-
-  // Update store if available (this triggers reactive updates)
-  if (getAppStore) {
-    const store = getAppStore();
-    if (store.getState) {
-      store.getState().setCurrentAgentId(agentId);
-    }
-  }
-
-  return true;
-}
-
-/**
- * Reload agents from disk
- */
-export async function reloadAgents(): Promise<void> {
-  if (!state) {
-    return;
-  }
-
-  const cwd = state.cwd;
-  const currentAgentId = getCurrentAgentId();
-
-  await initializeAgentManager(cwd);
-
-  // Restore current agent if it still exists, otherwise reset to default
-  if (state && !state.agents.has(currentAgentId)) {
-    if (getAppStore) {
-      const store = getAppStore();
-      if (store.getState) {
-        store.getState().setCurrentAgentId(DEFAULT_AGENT_ID);
-      }
-    }
-  }
-}
-
-/**
- * Get system prompt for current agent
- */
-export function getCurrentSystemPrompt(): string {
-  return getCurrentAgent().systemPrompt;
-}

package/src/core/loop-controller.ts

@@ -1,200 +0,0 @@
-/**
- * Loop Controller - Simple continuous execution
- *
- * Core concept: Keep executing the same task with context persistence
- * - First run: Fresh start
- * - Subsequent runs: Auto-continue (builds on previous work)
- * - Stop: Manual (Ctrl+C) or max-runs limit
- *
- * Use case: "Keep working on X until I stop you"
- */
-
-import chalk from 'chalk';
-import type { FlowOptions } from '../commands/flow/types.js';
-
-export interface LoopOptions {
-  enabled: boolean;
-  interval: number;          // Wait time in seconds between runs (0 = no wait)
-  maxRuns?: number;          // Optional max iterations (default: infinite)
-}
-
-export interface LoopResult {
-  exitCode: number;
-  error?: Error;
-}
-
-export interface LoopState {
-  iteration: number;
-  startTime: Date;
-  successCount: number;
-  errorCount: number;
-}
-
-/**
- * Controller for loop execution mode
- */
-export class LoopController {
-  private state: LoopState;
-  private shouldStop: boolean = false;
-
-  constructor() {
-    this.state = {
-      iteration: 0,
-      startTime: new Date(),
-      successCount: 0,
-      errorCount: 0,
-    };
-
-    // Handle graceful shutdown
-    this.setupSignalHandlers();
-  }
-
-  /**
-   * Execute task in loop mode
-   * Simple: Keep running same task until manual stop or max-runs
-   */
-  async run(
-    executor: () => Promise<LoopResult>,
-    options: LoopOptions
-  ): Promise<void> {
-    console.log(chalk.cyan.bold('\n━━━ 🔄 Loop Mode Activated\n'));
-    console.log(chalk.dim(`  Wait time: ${options.interval}s`));
-    console.log(chalk.dim(`  Max runs: ${options.maxRuns || '∞'}`));
-    console.log(chalk.dim(`  Stop: Ctrl+C or max-runs limit\n`));
-
-    while (this.shouldContinue(options)) {
-      this.state.iteration++;
-
-      try {
-        await this.executeIteration(executor, options);
-      } catch (error) {
-        this.handleError(error as Error);
-      }
-
-      // Wait for next iteration
-      if (this.shouldContinue(options)) {
-        await this.waitForNextRun(options);
-      }
-    }
-
-    this.printSummary();
-  }
-
-  /**
-   * Execute single iteration
-   * Simple: Run task, track success/error, continue
-   */
-  private async executeIteration(
-    executor: () => Promise<LoopResult>,
-    options: LoopOptions
-  ): Promise<void> {
-    const maxDisplay = options.maxRuns || '∞';
-    console.log(
-      chalk.cyan(
-        `\n🔄 Loop iteration ${this.state.iteration}/${maxDisplay}`
-      )
-    );
-    console.log(chalk.dim(`Started: ${new Date().toLocaleTimeString()}\n`));
-
-    const result = await executor();
-
-    // Update state (just count success/error)
-    if (result.error || result.exitCode !== 0) {
-      this.state.errorCount++;
-      console.log(chalk.yellow(`\n⚠️  Task encountered error (continuing...)`));
-    } else {
-      this.state.successCount++;
-    }
-  }
-
-  /**
-   * Handle execution error
-   * Simple: Log and continue (resilient)
-   */
-  private handleError(error: Error): void {
-    this.state.errorCount++;
-    console.error(chalk.yellow('\n⚠️  Error occurred - continuing to next iteration'));
-    console.error(chalk.dim(`Error: ${error.message}\n`));
-  }
-
-  /**
-   * Wait for next iteration
-   */
-  private async waitForNextRun(options: LoopOptions): Promise<void> {
-    const maxDisplay = options.maxRuns || '∞';
-    const progress = `${this.state.iteration}/${maxDisplay}`;
-
-    console.log(
-      chalk.dim(
-        `\n⏳ Waiting ${options.interval}s until next run... (completed: ${progress})`
-      )
-    );
-
-    // Countdown display (optional, can be removed if too verbose)
-    const startTime = Date.now();
-    const endTime = startTime + options.interval * 1000;
-
-    while (Date.now() < endTime && !this.shouldStop) {
-      await this.sleep(1000);
-
-      const remaining = Math.ceil((endTime - Date.now()) / 1000);
-      if (remaining > 0 && remaining % 10 === 0) {
-        process.stdout.write(chalk.dim(`\r⏳ ${remaining}s remaining...`));
-      }
-    }
-
-    if (!this.shouldStop) {
-      process.stdout.write('\r' + ' '.repeat(50) + '\r'); // Clear line
-    }
-  }
-
-  /**
-   * Check if should continue looping
-   * Simple: Stop only on manual interrupt or max-runs
-   */
-  private shouldContinue(options: LoopOptions): boolean {
-    if (this.shouldStop) return false;
-    if (options.maxRuns && this.state.iteration >= options.maxRuns) return false;
-    return true;
-  }
-
-  /**
-   * Print execution summary
-   */
-  private printSummary(): void {
-    const duration = Date.now() - this.state.startTime.getTime();
-    const minutes = Math.floor(duration / 60000);
-    const seconds = Math.floor((duration % 60000) / 1000);
-
-    console.log(chalk.cyan.bold('\n━━━ 🏁 Loop Summary\n'));
-    console.log(`  Total iterations: ${this.state.iteration}`);
-    console.log(
-      `  Successful: ${chalk.green(this.state.successCount.toString())}`
-    );
-    console.log(`  Errors: ${chalk.red(this.state.errorCount.toString())}`);
-    console.log(`  Duration: ${minutes}m ${seconds}s`);
-    console.log();
-  }
-
-  /**
-   * Setup signal handlers for graceful shutdown
-   */
-  private setupSignalHandlers(): void {
-    const handler = () => {
-      console.log(
-        chalk.yellow('\n\n⚠️  Interrupt received - finishing current iteration...')
-      );
-      this.shouldStop = true;
-    };
-
-    process.on('SIGINT', handler);
-    process.on('SIGTERM', handler);
-  }
-
-  /**
-   * Sleep helper
-   */
-  private sleep(ms: number): Promise<void> {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-}