@sylphx/flow 1.0.1 → 1.0.3

package/src/commands/init-core.ts

@@ -0,0 +1,322 @@
+/**
+ * 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/settings.js';
+import { validateTarget } from '../utils/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) {
+    targetId = await targetManager.promptForTargetSelection();
+  }
+
+  // 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 });
+      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 });
+      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 });
+      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 });
+      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/commands/knowledge-command.ts

@@ -0,0 +1,161 @@
+/**
+ * Knowledge CLI commands
+ * Knowledge base search and management functionality
+ */
+
+import { Command } from 'commander';
+import { getKnowledgeContent } from '../domains/knowledge/resources.js';
+import { getSearchService } from '../services/search/unified-search-service.js';
+import { CLIError } from '../utils/error-handler.js';
+
+/**
+ * Knowledge search command
+ */
+export const knowledgeSearchCommand = new Command('search')
+  .description('Search knowledge base, documentation, and guides')
+  .argument('<query>', 'Search query - use natural language, technology names, or topic keywords')
+  .option('-l, --limit <number>', 'Maximum number of results to return', '10')
+  .option('--include-content', 'Include full content in results', true)
+  .action(async (query, options) => {
+    try {
+      console.log(`📚 Searching knowledge base for: "${query}"`);
+
+      const searchService = getSearchService();
+      await searchService.initialize();
+
+      const result = await searchService.searchKnowledge(query, {
+        limit: Number.parseInt(options.limit, 10) || 10,
+        include_content: options.includeContent !== false,
+      });
+
+      const output = searchService.formatResultsForCLI(result.results, query, result.totalIndexed);
+      console.log(output);
+    } catch (error) {
+      throw new CLIError(`Knowledge search failed: ${(error as Error).message}`);
+    }
+  });
+
+/**
+ * Knowledge get command
+ */
+export const knowledgeGetCommand = new Command('get')
+  .description('Get specific knowledge document by URI')
+  .argument('<uri>', 'Knowledge URI to access (e.g., "knowledge://stacks/react-app")')
+  .action(async (uri) => {
+    try {
+      const content = await getKnowledgeContent(uri);
+      console.log(content);
+    } catch (error) {
+      const errorMessage = `Knowledge get failed: ${(error as Error).message}`;
+
+      // Show available URIs
+      const searchService = getSearchService();
+      const availableURIs = await searchService.getAvailableKnowledgeURIs();
+      if (availableURIs.length > 0) {
+        console.log('\n**Available knowledge URIs:**');
+        for (const uri of availableURIs) {
+          console.log(`• ${uri}`);
+        }
+      }
+      throw new CLIError(errorMessage);
+    }
+  });
+
+/**
+ * Knowledge list command
+ */
+export const knowledgeListCommand = new Command('list')
+  .description('List all available knowledge resources')
+  .option('--category <type>', 'Filter by category (stacks, guides, universal, data)')
+  .action(async (options) => {
+    try {
+      const searchService = getSearchService();
+      await searchService.initialize();
+      const availableURIs = await searchService.getAvailableKnowledgeURIs();
+
+      if (availableURIs.length === 0) {
+        console.log('📭 No knowledge documents available');
+        return;
+      }
+
+      let filteredURIs = availableURIs;
+      if (options.category) {
+        filteredURIs = availableURIs.filter((uri) => uri.includes(`/${options.category}/`));
+      }
+
+      console.log(`📚 Available Knowledge Resources (${filteredURIs.length} documents):\n`);
+
+      // Group by category
+      const grouped = filteredURIs.reduce(
+        (acc, uri) => {
+          const category = uri.split('/')[2] || 'unknown';
+          if (!acc[category]) {
+            acc[category] = [];
+          }
+          acc[category].push(uri);
+          return acc;
+        },
+        {} as Record<string, string[]>
+      );
+
+      for (const [category, uris] of Object.entries(grouped)) {
+        console.log(`### ${category.charAt(0).toUpperCase() + category.slice(1)}`);
+        for (const uri of uris) {
+          const name = uri.split('/').pop() || 'Unknown';
+          console.log(`• ${name} - ${uri}`);
+        }
+        console.log('');
+      }
+
+      console.log('**Usage:**');
+      console.log('• sylphx knowledge search <query> - Search knowledge base');
+      console.log('• sylphx knowledge get <uri> - Get specific document');
+    } catch (error) {
+      throw new CLIError(`Knowledge status failed: ${(error as Error).message}`);
+    }
+  });
+
+/**
+ * Knowledge status command
+ */
+export const knowledgeStatusCommand = new Command('status')
+  .description('Get knowledge base system status')
+  .action(async () => {
+    try {
+      console.log('\n### 📚 Knowledge Base Status\n');
+
+      const searchService = getSearchService();
+      await searchService.initialize();
+      const status = await searchService.getStatus();
+
+      if (status.knowledge.indexed) {
+        console.log('**Status:** ✓ Ready');
+        console.log(`**Documents:** ${status.knowledge.documentCount} files`);
+      } else if (status.knowledge.isIndexing) {
+        console.log(`**Status:** 🔄 Building index (${status.knowledge.progress || 0}%)`);
+        console.log('**Note:** Please wait a moment and try again');
+      } else {
+        console.log('**Status:** ⚠️ Not initialized');
+        console.log('**Note:** Will auto-index on first search');
+      }
+
+      console.log('\n**Available Commands:**');
+      console.log('• sylphx knowledge search <query> - Search knowledge base');
+      console.log('• sylphx knowledge get <uri> - Get specific document');
+    } catch (error) {
+      throw new CLIError(`Knowledge list failed: ${(error as Error).message}`);
+    }
+  });
+
+/**
+ * Main knowledge command
+ */
+export const knowledgeCommand = new Command('knowledge').description(
+  'Knowledge base search and management commands'
+);
+
+// Add subcommands
+knowledgeCommand.addCommand(knowledgeSearchCommand);
+knowledgeCommand.addCommand(knowledgeGetCommand);
+knowledgeCommand.addCommand(knowledgeListCommand);
+knowledgeCommand.addCommand(knowledgeStatusCommand);

package/src/commands/run-command.ts

@@ -0,0 +1,120 @@
+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/paths.js';
+
+export async function loadAgentContent(agentName: string, agentFilePath?: 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');
+      return content;
+    }
+
+    // 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 rules and styles
+        return await enhanceAgentContent(content);
+      } 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 rules and styles
+        return await enhanceAgentContent(content);
+      }
+    }
+  } 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.
+ */