@sylphx/flow 2.1.3 → 2.1.4

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));
-  }
-}

package/src/core/rule-loader.ts

@@ -1,147 +0,0 @@
-/**
- * Rule Loader
- * Loads rule definitions from markdown files with front matter
- */
-
-import { readFile, readdir, access } from 'node:fs/promises';
-import { join, parse, relative, dirname } from 'node:path';
-import { homedir } from 'node:os';
-import { fileURLToPath } from 'node:url';
-import matter from 'gray-matter';
-import type { Rule, RuleMetadata } from '../types/rule.types.js';
-
-/**
- * Load a single rule from a markdown file
- */
-export async function loadRuleFromFile(
-  filePath: string,
-  isBuiltin: boolean = false,
-  ruleId?: string
-): Promise<Rule | null> {
-  try {
-    const fileContent = await readFile(filePath, 'utf-8');
-    const { data, content } = matter(fileContent);
-
-    // Validate front matter
-    if (!data.name || typeof data.name !== 'string') {
-      console.error(`Rule file ${filePath} missing required 'name' field`);
-      return null;
-    }
-
-    const metadata: RuleMetadata = {
-      name: data.name,
-      description: data.description || '',
-      enabled: data.enabled !== undefined ? Boolean(data.enabled) : true,
-    };
-
-    // Get rule ID from parameter or filename
-    const id = ruleId || parse(filePath).name;
-
-    return {
-      id,
-      metadata,
-      content: content.trim(),
-      isBuiltin,
-      filePath,
-    };
-  } catch (error) {
-    console.error(`Failed to load rule from ${filePath}:`, error);
-    return null;
-  }
-}
-
-/**
- * Load all rules from a directory (recursively)
- */
-export async function loadRulesFromDirectory(dirPath: string, isBuiltin: boolean = false): Promise<Rule[]> {
-  try {
-    // Read directory recursively to support subdirectories
-    const files = await readdir(dirPath, { recursive: true, withFileTypes: true });
-
-    // Filter for .md files and calculate rule IDs from relative paths
-    const ruleFiles = files
-      .filter((f) => f.isFile() && f.name.endsWith('.md'))
-      .map((f) => {
-        const fullPath = join(f.parentPath || f.path, f.name);
-        // Calculate relative path from dirPath and remove .md extension
-        const relativePath = relative(dirPath, fullPath).replace(/\.md$/, '');
-        return { fullPath, ruleId: relativePath };
-      });
-
-    const rules = await Promise.all(
-      ruleFiles.map(({ fullPath, ruleId }) => loadRuleFromFile(fullPath, isBuiltin, ruleId))
-    );
-
-    return rules.filter((rule): rule is Rule => rule !== null);
-  } catch (error) {
-    // Directory doesn't exist or can't be read
-    return [];
-  }
-}
-
-/**
- * Get system rules path (bundled with the app)
- */
-export async function getSystemRulesPath(): Promise<string> {
-  // Get the directory of the current module (cross-platform)
-  const currentFile = fileURLToPath(import.meta.url);
-  const currentDir = dirname(currentFile);
-
-  // In production (dist), assets are at dist/assets/rules
-  // In development (src), go up to project root: src/core -> project root
-  const distPath = join(currentDir, '..', 'assets', 'rules');
-  const devPath = join(currentDir, '..', '..', 'assets', 'rules');
-
-  // Check which one exists (try dist first, then dev)
-  try {
-    await access(distPath);
-    return distPath;
-  } catch {
-    return devPath;
-  }
-}
-
-/**
- * Get all rule search paths
- */
-export function getRuleSearchPaths(cwd: string): string[] {
-  const globalPath = join(homedir(), '.sylphx-flow', 'rules');
-  const projectPath = join(cwd, '.sylphx-flow', 'rules');
-
-  return [globalPath, projectPath];
-}
-
-/**
- * Load all available rules from all sources
- */
-export async function loadAllRules(cwd: string): Promise<Rule[]> {
-  const systemPath = await getSystemRulesPath();
-  const [globalPath, projectPath] = getRuleSearchPaths(cwd);
-
-  const [systemRules, globalRules, projectRules] = await Promise.all([
-    loadRulesFromDirectory(systemPath, true),  // System rules are marked as builtin
-    loadRulesFromDirectory(globalPath, false),
-    loadRulesFromDirectory(projectPath, false),
-  ]);
-
-  // Priority: system < global < project
-  // Use Map to deduplicate by ID (later entries override earlier ones)
-  const ruleMap = new Map<string, Rule>();
-
-  // Add system rules first (lowest priority)
-  for (const rule of systemRules) {
-    ruleMap.set(rule.id, rule);
-  }
-
-  // Add global rules (override system)
-  for (const rule of globalRules) {
-    ruleMap.set(rule.id, rule);
-  }
-
-  // Add project rules (override globals and system)
-  for (const rule of projectRules) {
-    ruleMap.set(rule.id, rule);
-  }
-
-  return Array.from(ruleMap.values());
-}

package/src/core/rule-manager.ts

@@ -1,240 +0,0 @@
-/**
- * Rule Manager
- * Manages rule state and operations
- */
-
-import type { Rule } from '../types/rule.types.js';
-import { loadAllRules } from './rule-loader.js';
-
-/**
- * Rule manager state
- */
-interface RuleManagerState {
-  rules: Map<string, Rule>;
-  cwd: string;
-}
-
-let state: RuleManagerState | null = null;
-
-/**
- * Get the app store (lazy import to avoid circular dependencies)
- */
-let getAppStore: (() => any) | null = null;
-
-/**
- * Set the app store getter (called during initialization)
- */
-export function setRuleAppStoreGetter(getter: () => any): void {
-  getAppStore = getter;
-}
-
-/**
- * Initialize rule manager
- */
-export async function initializeRuleManager(cwd: string): Promise<void> {
-  const allRules = await loadAllRules(cwd);
-
-  const ruleMap = new Map<string, Rule>();
-  for (const rule of allRules) {
-    ruleMap.set(rule.id, rule);
-  }
-
-  state = {
-    rules: ruleMap,
-    cwd,
-  };
-
-  // Initialize store with default enabled rules
-  if (getAppStore) {
-    const store = getAppStore();
-    if (store.getState) {
-      const currentEnabledRules = store.getState().enabledRuleIds || [];
-
-      // If no rules are enabled yet, enable all rules that have enabled: true in metadata
-      if (currentEnabledRules.length === 0) {
-        const defaultEnabledRules = allRules
-          .filter((rule) => rule.metadata.enabled !== false)
-          .map((rule) => rule.id);
-
-        if (defaultEnabledRules.length > 0) {
-          store.getState().setEnabledRuleIds(defaultEnabledRules);
-        }
-      }
-    }
-  }
-}
-
-/**
- * Get all available rules
- */
-export function getAllRules(): Rule[] {
-  if (!state) {
-    return [];
-  }
-  return Array.from(state.rules.values());
-}
-
-/**
- * Get rule by ID
- */
-export function getRuleById(id: string): Rule | null {
-  if (!state) {
-    return null;
-  }
-  return state.rules.get(id) || null;
-}
-
-/**
- * Get enabled rule IDs from store
- */
-export function getEnabledRuleIds(): string[] {
-  if (getAppStore) {
-    const store = getAppStore();
-    if (store.getState) {
-      return store.getState().enabledRuleIds || [];
-    }
-  }
-  return [];
-}
-
-/**
- * Get enabled rules
- */
-export function getEnabledRules(): Rule[] {
-  if (!state) {
-    return [];
-  }
-
-  const enabledIds = getEnabledRuleIds();
-  return enabledIds
-    .map((id) => state!.rules.get(id))
-    .filter((rule): rule is Rule => rule !== null);
-}
-
-/**
- * Toggle a rule on/off
- */
-export function toggleRule(ruleId: string): boolean {
-  if (!state || !state.rules.has(ruleId)) {
-    return false;
-  }
-
-  if (getAppStore) {
-    const store = getAppStore();
-    if (store.getState) {
-      const currentEnabled = store.getState().enabledRuleIds || [];
-
-      if (currentEnabled.includes(ruleId)) {
-        // Disable: remove from list
-        store.getState().setEnabledRuleIds(currentEnabled.filter((id) => id !== ruleId));
-      } else {
-        // Enable: add to list
-        store.getState().setEnabledRuleIds([...currentEnabled, ruleId]);
-      }
-      return true;
-    }
-  }
-
-  return false;
-}
-
-/**
- * Enable a rule
- */
-export function enableRule(ruleId: string): boolean {
-  if (!state || !state.rules.has(ruleId)) {
-    return false;
-  }
-
-  if (getAppStore) {
-    const store = getAppStore();
-    if (store.getState) {
-      const currentEnabled = store.getState().enabledRuleIds || [];
-
-      if (!currentEnabled.includes(ruleId)) {
-        store.getState().setEnabledRuleIds([...currentEnabled, ruleId]);
-      }
-      return true;
-    }
-  }
-
-  return false;
-}
-
-/**
- * Disable a rule
- */
-export function disableRule(ruleId: string): boolean {
-  if (!state || !state.rules.has(ruleId)) {
-    return false;
-  }
-
-  if (getAppStore) {
-    const store = getAppStore();
-    if (store.getState) {
-      const currentEnabled = store.getState().enabledRuleIds || [];
-      store.getState().setEnabledRuleIds(currentEnabled.filter((id) => id !== ruleId));
-      return true;
-    }
-  }
-
-  return false;
-}
-
-/**
- * Reload rules from disk
- */
-export async function reloadRules(): Promise<void> {
-  if (!state) {
-    return;
-  }
-
-  const cwd = state.cwd;
-  const currentEnabled = getEnabledRuleIds();
-
-  await initializeRuleManager(cwd);
-
-  // Keep only enabled rules that still exist
-  if (state && getAppStore) {
-    const store = getAppStore();
-    if (store.getState) {
-      const validEnabled = currentEnabled.filter((id) => state!.rules.has(id));
-      store.getState().setEnabledRuleIds(validEnabled);
-    }
-  }
-}
-
-/**
- * Set enabled rules (replaces current enabled rules)
- */
-export function setEnabledRules(ruleIds: string[]): boolean {
-  if (!state) {
-    return false;
-  }
-
-  // Validate all rule IDs exist
-  const validRuleIds = ruleIds.filter((id) => state!.rules.has(id));
-
-  if (getAppStore) {
-    const store = getAppStore();
-    if (store.getState) {
-      store.getState().setEnabledRuleIds(validRuleIds);
-      return true;
-    }
-  }
-
-  return false;
-}
-
-/**
- * Get combined content of all enabled rules
- */
-export function getEnabledRulesContent(): string {
-  const enabledRules = getEnabledRules();
-
-  if (enabledRules.length === 0) {
-    return '';
-  }
-
-  return enabledRules.map((rule) => rule.content).join('\n\n');
-}