@sylphx/flow 2.1.2 → 2.1.3

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @sylphx/flow
 
+## 2.1.3
+
+### Patch Changes
+
+- f571de3: Fix rules and output styles loading logic
+
+  - Fix output styles duplication: Only attach during runtime, not during attach phase
+  - Fix rules loading: Use intersection of agent frontmatter rules and globally enabled rules
+  - Remove deprecated command files (execute.ts, setup.ts, run-command.ts)
+  - Move loadAgentContent and extractAgentInstructions to agent-enhancer.ts
+
 ## 2.1.2
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sylphx/flow",
-  "version": "2.1.2",
+  "version": "2.1.3",
   "description": "One CLI to rule them all. Unified orchestration layer for Claude Code, OpenCode, Cursor and all AI development tools. Auto-detection, auto-installation, auto-upgrade.",
   "type": "module",
   "bin": {

package/src/commands/flow/execute-v2.ts

@@ -9,7 +9,7 @@ import { FlowExecutor } from '../../core/flow-executor.js';
 import { targetManager } from '../../core/target-manager.js';
 import { UpgradeManager } from '../../core/upgrade-manager.js';
 import { showWelcome } from '../../utils/display/banner.js';
-import { loadAgentContent, extractAgentInstructions } from '../run-command.js';
+import { loadAgentContent, extractAgentInstructions } from '../../utils/agent-enhancer.js';
 import { CLIError } from '../../utils/error-handler.js';
 import type { RunCommandOptions } from '../../types.js';
 import type { FlowOptions } from './types.js';
@@ -299,7 +299,8 @@ export async function executeFlowV2(
     console.log(chalk.dim(`   Enabled rules: ${enabledRules.join(', ')}`));
     console.log(chalk.dim(`   Enabled output styles: ${enabledOutputStyles.join(', ')}\n`));
 
-    // Load agent content with only enabled rules and styles
+    // Load agent content with enabled rules and output styles
+    // Rules are filtered: intersection of agent's frontmatter rules and globally enabled rules
     const agentContent = await loadAgentContent(
       agent,
       options.agentFile,

package/src/commands/flow/index.ts

@@ -3,9 +3,7 @@
  * Centralized exports for all flow command components
  */
 
-export { executeFlow } from './execute.js';
-export { executeSetupPhase } from './setup.js';
-export { executeTargetCommand, executeCommandOnly, executeFlowOnce } from './execute.js';
+export { executeFlow } from './execute-v2.js';
 export { resolvePrompt } from './prompt.js';
 export { getExecutableTargets } from './targets.js';
-export type { FlowOptions, SetupContext } from './types.js';
+export type { FlowOptions } from './types.js';

package/src/commands/flow/types.ts

@@ -39,10 +39,3 @@ export interface FlowOptions {
   loop?: number;
   maxRuns?: number;
 }
-
-export interface SetupContext {
-  resolvedTarget: string;
-  initializedSuccessfully: boolean;
-  systemPrompt?: string;
-  runOptions?: RunCommandOptions;
-}

package/src/targets/claude-code.ts

@@ -428,7 +428,8 @@ Please begin your response with a comprehensive summary of all the instructions
 
   /**
    * Setup agents for Claude Code
-   * Install agents to .claude/agents/ directory with rules and output styles appended
+   * Install agents to .claude/agents/ directory with rules appended
+   * Output styles are applied dynamically at runtime based on user settings
    */
   async setupAgents(cwd: string, options: CommonOptions): Promise<SetupResult> {
     const { enhanceAgentContent } = await import('../utils/agent-enhancer.js');
@@ -445,8 +446,8 @@ Please begin your response with a comprehensive summary of all the instructions
         // Transform agent content (converts to Claude Code format, strips unsupported fields)
         const transformed = await this.transformAgentContent(content, undefined, sourcePath);
 
-        // Enhance with rules and output styles
-        const enhanced = await enhanceAgentContent(transformed, rules);
+        // Enhance with rules only (output styles are applied dynamically at runtime)
+        const enhanced = await enhanceAgentContent(transformed, rules, []);
 
         return enhanced;
       },

package/src/utils/agent-enhancer.ts

@@ -12,8 +12,9 @@
 
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { getOutputStylesDir, getRulesDir } from './config/paths.js';
+import { getOutputStylesDir, getRulesDir, getAgentsDir } from './config/paths.js';
 import { yamlUtils } from './config/target-utils.js';
+import { CLIError } from './error-handler.js';
 
 /**
  * Load and combine rules and output styles
@@ -130,3 +131,110 @@ export async function enhanceAgentContent(
 
   return `${agentContent}\n\n---\n\n# Rules and Output Styles\n\n${rulesAndStyles}`;
 }
+
+/**
+ * Filter rules: intersection of agent's required rules and globally enabled rules
+ * @param agentRules - Rules defined in agent frontmatter
+ * @param enabledRules - Globally enabled rules from user settings
+ * @returns Intersection of both arrays (rules that are both required by agent AND enabled globally)
+ */
+function filterRules(agentRules?: string[], enabledRules?: string[]): string[] | undefined {
+  // If agent doesn't define rules, return undefined (will use default)
+  if (!agentRules || agentRules.length === 0) {
+    return undefined;
+  }
+
+  // If no global filter, use all agent rules
+  if (!enabledRules || enabledRules.length === 0) {
+    return agentRules;
+  }
+
+  // Return intersection: rules that are both in agent's list AND globally enabled
+  const filtered = agentRules.filter(rule => enabledRules.includes(rule));
+  return filtered.length > 0 ? filtered : undefined;
+}
+
+/**
+ * Load agent content from various locations
+ * @param agentName - Name of the agent (without .md extension)
+ * @param agentFilePath - Optional specific file path to load from
+ * @param enabledRules - Globally enabled rules (filtered with agent's frontmatter rules)
+ * @param enabledOutputStyles - Optional array of enabled output style names
+ */
+export async function loadAgentContent(
+  agentName: string,
+  agentFilePath?: string,
+  enabledRules?: string[],
+  enabledOutputStyles?: string[]
+): Promise<string> {
+  try {
+    // If specific file path provided, load from there
+    if (agentFilePath) {
+      const content = await fs.readFile(path.resolve(agentFilePath), 'utf-8');
+      // Extract rules from agent frontmatter
+      const { metadata } = await yamlUtils.extractFrontMatter(content);
+      const agentRules = metadata.rules as string[] | undefined;
+      // Filter: intersection of agent's rules and globally enabled rules
+      const rulesToLoad = filterRules(agentRules, enabledRules);
+      // Enhance with filtered rules and enabled output styles
+      return await enhanceAgentContent(content, rulesToLoad, enabledOutputStyles);
+    }
+
+    // First try to load from .claude/agents/ directory (processed agents with rules already included)
+    const claudeAgentPath = path.join(process.cwd(), '.claude', 'agents', `${agentName}.md`);
+
+    try {
+      const content = await fs.readFile(claudeAgentPath, 'utf-8');
+      // Enhance with enabled output styles (rules are already included in the file)
+      return await enhanceAgentContent(content, [], enabledOutputStyles);
+    } catch (_error) {
+      // Try to load from local agents/ directory (user-defined agents)
+      const localAgentPath = path.join(process.cwd(), 'agents', `${agentName}.md`);
+
+      try {
+        const content = await fs.readFile(localAgentPath, 'utf-8');
+        // Extract rules from agent frontmatter
+        const { metadata } = await yamlUtils.extractFrontMatter(content);
+        const agentRules = metadata.rules as string[] | undefined;
+        // Filter: intersection of agent's rules and globally enabled rules
+        const rulesToLoad = filterRules(agentRules, enabledRules);
+        // Enhance with filtered rules and enabled output styles
+        return await enhanceAgentContent(content, rulesToLoad, enabledOutputStyles);
+      } catch (_error2) {
+        // Try to load from the package's agents directory
+        const packageAgentsDir = getAgentsDir();
+        const packageAgentPath = path.join(packageAgentsDir, `${agentName}.md`);
+
+        const content = await fs.readFile(packageAgentPath, 'utf-8');
+        // Extract rules from agent frontmatter
+        const { metadata } = await yamlUtils.extractFrontMatter(content);
+        const agentRules = metadata.rules as string[] | undefined;
+        // Filter: intersection of agent's rules and globally enabled rules
+        const rulesToLoad = filterRules(agentRules, enabledRules);
+        // Enhance with filtered rules and enabled output styles
+        return await enhanceAgentContent(content, rulesToLoad, enabledOutputStyles);
+      }
+    }
+  } catch (_error) {
+    throw new CLIError(
+      `Agent '${agentName}' not found${agentFilePath ? ` at ${agentFilePath}` : ''}`,
+      'AGENT_NOT_FOUND'
+    );
+  }
+}
+
+/**
+ * Extract agent instructions from agent content (strip YAML front matter)
+ */
+export function extractAgentInstructions(agentContent: string): string {
+  // Extract content after YAML front matter
+  const yamlFrontMatterRegex = /^---\s*\n[\s\S]*?\n---\s*\n/;
+  const match = agentContent.match(yamlFrontMatterRegex);
+
+  if (match) {
+    return agentContent.substring(match[0].length).trim();
+  }
+
+  // If no front matter, return the full content
+  return agentContent.trim();
+}

package/src/commands/flow/execute.ts

@@ -1,453 +0,0 @@
-/**
- * Execution Logic for Flow Command
- * Command execution for single-run and loop modes
- */
-
-import chalk from 'chalk';
-import { targetManager } from '../../core/target-manager.js';
-import { StateDetector } from '../../core/state-detector.js';
-import { UpgradeManager } from '../../core/upgrade-manager.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 { CLIError } from '../../utils/error-handler.js';
-import type { RunCommandOptions } from '../../types.js';
-import type { FlowOptions, SetupContext } from './types.js';
-import { resolvePrompt } from './prompt.js';
-import { executeSetupPhase } from './setup.js';
-import { getExecutableTargets } from './targets.js';
-
-/**
- * Execute command using target's executeCommand method
- */
-export async function executeTargetCommand(
-  targetId: string,
-  systemPrompt: string,
-  userPrompt: string,
-  options: RunCommandOptions
-): Promise<void> {
-  const targetOption = targetManager.getTarget(targetId);
-
-  if (targetOption._tag === 'None') {
-    throw new CLIError(`Target not found: ${targetId}`, 'TARGET_NOT_FOUND');
-  }
-
-  const target = targetOption.value;
-
-  if (!target.isImplemented) {
-    throw new CLIError(
-      `Target '${targetId}' is not implemented. Supported targets: ${getExecutableTargets().join(', ')}`,
-      'TARGET_NOT_IMPLEMENTED'
-    );
-  }
-
-  if (!target.executeCommand) {
-    throw new CLIError(
-      `Target '${targetId}' does not support command execution. Supported targets: ${getExecutableTargets().join(', ')}`,
-      'EXECUTION_NOT_SUPPORTED'
-    );
-  }
-
-  return target.executeCommand(systemPrompt, userPrompt, options);
-}
-
-/**
- * Execute command only (for loop mode iterations)
- * Uses pre-setup context to execute command without re-doing setup
- */
-export async function executeCommandOnly(
-  context: SetupContext,
-  prompt: string | undefined,
-  options: FlowOptions
-): Promise<void> {
-  const userPrompt = prompt?.trim() || '';
-
-  // Update continue flag in runOptions
-  const runOptions = {
-    ...context.runOptions,
-    continue: options.continue,
-  };
-
-  try {
-    await executeTargetCommand(context.resolvedTarget, context.systemPrompt!, userPrompt, runOptions);
-  } catch (error) {
-    console.error(chalk.red.bold('\n✗ Launch failed:'), error);
-    throw error;
-  }
-}
-
-/**
- * Single flow execution (used by both normal and loop mode)
- */
-export async function executeFlowOnce(prompt: string | undefined, options: FlowOptions): Promise<void> {
-  // Quick mode: enable useDefaults and skip prompts
-  if (options.quick) {
-    options.useDefaults = true;
-    console.log(chalk.cyan('⚡ Quick mode enabled - using saved defaults\n'));
-  }
-
-  // Continue mode always requires print mode
-  if (options.continue && !options.print) {
-    options.print = true;
-  }
-
-  // Import orchestrator functions
-  const {
-    checkUpgrades,
-    checkComponentIntegrity,
-    checkSyncStatus,
-  } = await import('../flow-orchestrator.js');
-
-  // Show welcome banner
-  showWelcome();
-
-  // Declare at function level to persist across steps
-  let selectedTarget: string | undefined;
-  let state = undefined;
-
-  // First: determine target (from options, saved settings, or init will prompt)
-  const initialTarget = options.target || (await projectSettings.getDefaultTarget());
-
-  // Only detect state if we have a target (can't check components without knowing target structure)
-  if (initialTarget && !options.sync) {
-    const detector = new StateDetector();
-    const upgradeManager = new UpgradeManager();
-
-    if (options.verbose) {
-      console.log(chalk.dim('🤔 Checking project status...\n'));
-    }
-
-    state = await detector.detect();
-
-    if (options.verbose) {
-      await showStatus(state);
-    }
-
-    // Step 1: Check for upgrades (non-intrusive notification)
-    if (!options.quick) {
-      await checkUpgrades(state, options);
-    }
-
-    // Step 2.5: Check component integrity (only if we have valid state)
-    await checkComponentIntegrity(state, options);
-
-    // Step 2.6: Check sync status (new templates available)
-    await checkSyncStatus(state, options);
-  }
-
-  // Step 3: Initialize (only if actually needed)
-  const shouldInitialize =
-    !state?.initialized ||
-    options.sync ||
-    options.repair ||
-    options.initOnly;
-
-  if (shouldInitialize) {
-    console.log(chalk.cyan.bold('━━━ 🚀 Initializing Project\n'));
-    selectedTarget = await initializeProject(options, state);
-  }
-
-  // Step 4: Launch target (if not init-only)
-  if (!options.initOnly) {
-    await launchTarget(prompt, options, state, selectedTarget);
-  } else {
-    console.log(chalk.dim('✓ Init-only mode, skipping execution\n'));
-  }
-}
-
-/**
- * Initialize project with components
- */
-async function initializeProject(options: FlowOptions, state: any): Promise<string | undefined> {
-  const {
-    selectAndValidateTarget,
-    previewDryRun,
-    installComponents,
-  } = await import('../init-core.js');
-
-  let selectedTarget: string | undefined;
-
-  try {
-    // In repair mode, use existing target from state
-    const targetForInit = options.repair && state?.target
-      ? state.target
-      : options.target;
-
-    // Prepare init options
-    const initOptions = {
-      target: targetForInit,
-      verbose: options.verbose,
-      dryRun: options.dryRun,
-      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 {
-      // Select and validate target
-      const targetId = await selectAndValidateTarget(initOptions);
-      selectedTarget = targetId;
-    }
-
-    // Dry run preview
-    if (options.dryRun) {
-      if (!selectedTarget) {
-        const targetId = await selectAndValidateTarget(initOptions);
-        selectedTarget = targetId;
-      }
-
-      await previewDryRun(selectedTarget, initOptions);
-      console.log(chalk.dim('✓ Initialization dry run complete\n'));
-    } else {
-      // Actually install components
-      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
- */
-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');
-
-  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);
-
-  console.log(chalk.cyan.bold('━━━ 🔄 Synchronizing Files\n'));
-  showSyncPreview(manifest, process.cwd(), target);
-
-  const selectedUnknowns = await selectUnknownFilesToRemove(manifest);
-  showFinalSummary(manifest, selectedUnknowns);
-
-  const confirmed = await confirmSync();
-  if (!confirmed) {
-    console.log(chalk.yellow('\n✗ Sync cancelled\n'));
-    process.exit(0);
-  }
-
-  const { templates, unknowns } = await executeSyncDelete(manifest, selectedUnknowns);
-
-  let mcpRemoved = 0;
-  if (selectedUnknowns.mcpServers.length > 0) {
-    mcpRemoved = await removeMCPServers(process.cwd(), selectedUnknowns.mcpServers);
-  }
-
-  let hooksRemoved = 0;
-  if (selectedUnknowns.hooks.length > 0) {
-    hooksRemoved = await removeHooks(process.cwd(), selectedUnknowns.hooks);
-  }
-
-  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;
-}
-
-/**
- * Launch target with agent
- */
-async function launchTarget(
-  prompt: string | undefined,
-  options: FlowOptions,
-  state: any,
-  selectedTarget: string | undefined
-): Promise<void> {
-  // Resolve target - use the target we just selected
-  let targetForResolution = options.target || state?.target || selectedTarget;
-
-  // If we just selected a target during init, use that
-  if (selectedTarget) {
-    targetForResolution = 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`));
-
-  // 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`));
-    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);
-  }
-
-  // Claude Code handling - needs provider/agent 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}`;
-
-  const userPrompt = prompt?.trim() || '';
-
-  // Run options
-  const runOptions: RunCommandOptions = {
-    target: resolvedTarget,
-    verbose,
-    dryRun: options.dryRun,
-    agent,
-    agentFile: options.agentFile,
-    prompt,
-    print: options.print,
-    continue: options.continue,
-  };
-
-  try {
-    await executeTargetCommand(resolvedTarget, systemPrompt, userPrompt, runOptions);
-  } catch (error) {
-    console.error(chalk.red.bold('\n✗ Launch failed:'), error);
-    process.exit(1);
-  }
-
-  if (!options.dryRun) {
-    console.log(chalk.dim('━━━\n'));
-    console.log(chalk.green('✓ Session complete\n'));
-  }
-}
-
-/**
- * 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;
-}
-
-/**
- * Main flow execution logic - simplified with orchestrator
- */
-export async function executeFlow(prompt: string | undefined, options: FlowOptions): Promise<void> {
-  // Resolve prompt (handle file input)
-  const resolvedPrompt = await resolvePrompt(prompt);
-
-  // Loop mode: Setup once, then loop only execution
-  if (options.loop !== undefined) {
-    const { LoopController } = await import('../../core/loop-controller.js');
-    const controller = new LoopController();
-
-    // Default to 0s (no cooldown) if just --loop with no value
-    const interval = typeof options.loop === 'number' ? options.loop : 0;
-
-    // Auto-enable headless mode for loop
-    options.print = true;
-
-    // ONE-TIME SETUP: Do all initialization once before loop starts
-    const setupContext = await executeSetupPhase(resolvedPrompt, options);
-
-    // Save original continue flag
-    const originalContinue = options.continue || false;
-
-    // LOOP: Only execute the command repeatedly
-    await controller.run(
-      async () => {
-        const isFirstIteration = controller['state'].iteration === 1;
-
-        // Continue logic:
-        // - If user specified --continue, always use it (all iterations)
-        // - If user didn't specify, only use from 2nd iteration onwards
-        options.continue = originalContinue || !isFirstIteration;
-
-        try {
-          await executeCommandOnly(setupContext, resolvedPrompt, options);
-          return { exitCode: 0 };
-        } catch (error) {
-          return { exitCode: 1, error: error as Error };
-        }
-      },
-      {
-        enabled: true,
-        interval,
-        maxRuns: options.maxRuns,
-      }
-    );
-
-    return;
-  }
-
-  // Normal execution (non-loop)
-  await executeFlowOnce(resolvedPrompt, options);
-}

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/run-command.ts

@@ -1,126 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { Command } from 'commander';
-import { targetManager } from '../core/target-manager.js';
-import { CLIError } from '../utils/error-handler.js';
-import { getAgentsDir } from '../utils/config/paths.js';
-
-export async function loadAgentContent(
-  agentName: string,
-  agentFilePath?: string,
-  enabledRules?: string[],
-  enabledOutputStyles?: string[]
-): Promise<string> {
-  const { enhanceAgentContent } = await import('../utils/agent-enhancer.js');
-
-  try {
-    // If specific file path provided, load from there
-    if (agentFilePath) {
-      const content = await fs.readFile(path.resolve(agentFilePath), 'utf-8');
-      // Enhance with enabled rules and styles
-      return await enhanceAgentContent(content, enabledRules, enabledOutputStyles);
-    }
-
-    // First try to load from .claude/agents/ directory (processed agents with rules and styles)
-    const claudeAgentPath = path.join(process.cwd(), '.claude', 'agents', `${agentName}.md`);
-
-    try {
-      const content = await fs.readFile(claudeAgentPath, 'utf-8');
-      return content;
-    } catch (_error) {
-      // Try to load from local agents/ directory (user-defined agents)
-      const localAgentPath = path.join(process.cwd(), 'agents', `${agentName}.md`);
-
-      try {
-        const content = await fs.readFile(localAgentPath, 'utf-8');
-        // Enhance user-defined agents with enabled rules and styles
-        return await enhanceAgentContent(content, enabledRules, enabledOutputStyles);
-      } catch (_error2) {
-        // Try to load from the package's agents directory
-        const packageAgentsDir = getAgentsDir();
-        const packageAgentPath = path.join(packageAgentsDir, `${agentName}.md`);
-
-        const content = await fs.readFile(packageAgentPath, 'utf-8');
-        // Enhance package agents with enabled rules and styles
-        return await enhanceAgentContent(content, enabledRules, enabledOutputStyles);
-      }
-    }
-  } catch (_error) {
-    throw new CLIError(
-      `Agent '${agentName}' not found${agentFilePath ? ` at ${agentFilePath}` : ''}`,
-      'AGENT_NOT_FOUND'
-    );
-  }
-}
-
-export function extractAgentInstructions(agentContent: string): string {
-  // Extract content after YAML front matter
-  const yamlFrontMatterRegex = /^---\s*\n[\s\S]*?\n---\s*\n/;
-  const match = agentContent.match(yamlFrontMatterRegex);
-
-  if (match) {
-    return agentContent.substring(match[0].length).trim();
-  }
-
-  // If no front matter, return the full content
-  return agentContent.trim();
-}
-
-function executeTargetCommand(
-  targetId: string,
-  systemPrompt: string,
-  userPrompt: string,
-  options: RunCommandOptions
-): Promise<void> {
-  // Get the target object
-  const targetOption = targetManager.getTarget(targetId);
-
-  if (targetOption._tag === 'None') {
-    throw new CLIError(`Target not found: ${targetId}`, 'TARGET_NOT_FOUND');
-  }
-
-  const target = targetOption.value;
-
-  // Check if the target is implemented
-  if (!target.isImplemented) {
-    throw new CLIError(
-      `Target '${targetId}' is not implemented. Supported targets: ${getExecutableTargets().join(', ')}`,
-      'TARGET_NOT_IMPLEMENTED'
-    );
-  }
-
-  // Check if the target supports command execution
-  if (!target.executeCommand) {
-    throw new CLIError(
-      `Target '${targetId}' does not support command execution. Supported targets: ${getExecutableTargets().join(', ')}`,
-      'EXECUTION_NOT_SUPPORTED'
-    );
-  }
-
-  // Use the target's executeCommand method
-  return target.executeCommand(systemPrompt, userPrompt, options);
-}
-
-/**
- * Get list of targets that support command execution
- */
-function getExecutableTargets(): string[] {
-  return targetManager.getImplementedTargetIDs().filter((targetId) => {
-    const targetOption = targetManager.getTarget(targetId);
-    if (targetOption._tag === 'None') {
-      return false;
-    }
-    return targetOption.value.executeCommand !== undefined;
-  });
-}
-
-/**
- * LEGACY: run command has been integrated into the flow command.
- * Use `flow [prompt]` instead of standalone `run` command.
- *
- * This file now only exports utility functions:
- * - loadAgentContent()
- * - extractAgentInstructions()
- *
- * These are used internally by the flow command.
- */