@sylphx/flow 2.1.2 → 2.1.4

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

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