@sylphx/flow 1.1.1 → 1.3.0

package/src/targets/functional/claude-code-logic.ts

@@ -31,7 +31,6 @@ export interface ClaudeCodeSettings {
 }
 
 export interface HookConfig {
-  sessionCommand?: string;
   notificationCommand?: string;
 }
 
@@ -41,17 +40,15 @@ export interface HookConfig {
  */
 export const generateHookCommands = async (targetId: string): Promise<HookConfig> => {
   return {
-    sessionCommand: `sylphx-flow hook --type session --target ${targetId}`,
     notificationCommand: `sylphx-flow hook --type notification --target ${targetId}`,
   };
 };
 
 /**
  * Default hook commands (fallback)
- * Simplified to only include session and notification hooks
+ * Simplified to only include notification hook
  */
 export const DEFAULT_HOOKS: HookConfig = {
-  sessionCommand: 'sylphx-flow hook --type session --target claude-code',
   notificationCommand: 'sylphx-flow hook --type notification --target claude-code',
 };
 
@@ -74,20 +71,9 @@ export const parseSettings = (content: string): Result<ClaudeCodeSettings, Confi
 export const buildHookConfiguration = (
   config: HookConfig = DEFAULT_HOOKS
 ): ClaudeCodeSettings['hooks'] => {
-  const sessionCommand = config.sessionCommand || DEFAULT_HOOKS.sessionCommand!;
   const notificationCommand = config.notificationCommand || DEFAULT_HOOKS.notificationCommand!;
 
   return {
-    SessionStart: [
-      {
-        hooks: [
-          {
-            type: 'command',
-            command: sessionCommand,
-          },
-        ],
-      },
-    ],
     Notification: [
       {
         matcher: '',
@@ -140,7 +126,7 @@ export const serializeSettings = (settings: ClaudeCodeSettings): string => {
  * Get success message (pure)
  */
 export const getSuccessMessage = (): string => {
-  return 'Claude Code hooks configured: SessionStart (static info) + UserPromptSubmit (dynamic info)';
+  return 'Claude Code hook configured: Notification';
 };
 
 /**
@@ -173,12 +159,8 @@ export const processSettings = (
  * Validate hook configuration (pure)
  */
 export const validateHookConfig = (config: HookConfig): Result<HookConfig, ConfigError> => {
-  if (config.sessionCommand !== undefined && config.sessionCommand.trim() === '') {
-    return failure(configError('Session command cannot be empty'));
-  }
-
-  if (config.messageCommand !== undefined && config.messageCommand.trim() === '') {
-    return failure(configError('Message command cannot be empty'));
+  if (config.notificationCommand !== undefined && config.notificationCommand.trim() === '') {
+    return failure(configError('Notification command cannot be empty'));
   }
 
   return success(config);

package/src/targets/opencode.ts

@@ -23,12 +23,6 @@ export const opencodeTarget: Target = {
   isImplemented: true,
   isDefault: true,
 
-  mcpServerConfig: {
-    disableTime: false,
-    disableKnowledge: false,
-    disableCodebase: false,
-  },
-
   config: {
     agentDir: '.opencode/agent',
     agentExtension: '.md',

package/src/types/mcp.types.ts

@@ -1,30 +1,26 @@
 /**
- * MCP (Model Context Protocol) configuration types
- * Types for configuring and managing MCP servers
+ * MCP (Model Context Protocol) Configuration Types
+ * Defines configuration formats for different MCP server implementations
  */
 
-import type { Resolvable } from './common.types.js';
-
 /**
- * MCP server configuration for stdio-based servers
- * Communicates via standard input/output
+ * Base MCP server configuration with stdio transport
  */
-export interface MCPServerConfig {
+export type MCPServerConfig = {
   type: 'stdio';
-  command: Resolvable<string>;
-  args?: Resolvable<string[]>;
+  command: string;
+  args?: string[];
   env?: Record<string, string>;
-}
+};
 
 /**
- * MCP server configuration for HTTP-based servers
- * Communicates via HTTP requests
+ * MCP server configuration with HTTP transport
  */
-export interface MCPServerConfigHTTP {
+export type MCPServerConfigHTTP = {
   type: 'http';
-  url: Resolvable<string>;
+  url: string;
   headers?: Record<string, string>;
-}
+};
 
 /**
  * Union of all possible MCP server configurations
@@ -32,38 +28,33 @@ export interface MCPServerConfigHTTP {
 export type MCPServerConfigUnion = MCPServerConfig | MCPServerConfigHTTP;
 
 /**
- * MCP server configuration flags
- * Used to disable specific server features per target
+ * OpenCode-specific configuration format
  */
-export type MCPServerConfigFlags = {
-  disableTime?: boolean;
-  disableKnowledge?: boolean;
-  disableCodebase?: boolean;
+export type OpenCodeConfig = {
+  type: 'local' | 'remote';
+  command?: string[];
+  url?: string;
+  headers?: Record<string, string>;
+  environment?: Record<string, string>;
 };
 
 /**
- * OpenCode-specific configuration format
+ * Type guard for stdio config
  */
-export interface OpenCodeConfig {
-  $schema?: string;
-  mcp?: Record<string, MCPServerConfigUnion>;
+export function isStdioConfig(config: MCPServerConfigUnion): config is MCPServerConfig {
+  return config.type === 'stdio';
 }
 
 /**
- * Type guard: Check if config is stdio-based
- */
-export const isStdioConfig = (config: MCPServerConfigUnion): config is MCPServerConfig =>
-  config.type === 'stdio';
-
-/**
- * Type guard: Check if config is HTTP-based
+ * Type guard for HTTP config
  */
-export const isHttpConfig = (config: MCPServerConfigUnion): config is MCPServerConfigHTTP =>
-  config.type === 'http';
+export function isHttpConfig(config: MCPServerConfigUnion): config is MCPServerConfigHTTP {
+  return config.type === 'http';
+}
 
 /**
- * Type guard: Check if config is CLI command-based (stdio)
- * Alias for isStdioConfig for backward compatibility
+ * Type guard for CLI command config (stdio)
  */
-export const isCLICommandConfig = (config: MCPServerConfigUnion): config is MCPServerConfig =>
-  isStdioConfig(config);
+export function isCLICommandConfig(config: MCPServerConfigUnion): config is MCPServerConfig {
+  return isStdioConfig(config);
+}

package/src/types/target.types.ts

@@ -69,8 +69,6 @@ export interface Target {
   // Configuration
   /** Target-specific configuration */
   readonly config: TargetConfig;
-  /** MCP server configuration for this target */
-  readonly mcpServerConfig?: MCPServerConfigFlags;
 
   // Required transformation methods
   /** Transform agent content for the target */

package/src/types.ts

@@ -24,7 +24,6 @@ export type {
 } from './types/common.types.js';
 export type {
   MCPServerConfig,
-  MCPServerConfigFlags,
   MCPServerConfigHTTP,
   MCPServerConfigUnion,
   OpenCodeConfig,

package/src/utils/sync-utils.ts

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import chalk from 'chalk';
 import type { Target } from '../types.js';
+import { MCP_SERVER_REGISTRY } from '../config/servers.js';
 
 /**
  * Files to delete during sync for each target
@@ -157,3 +158,108 @@ export async function confirmSync(): Promise<boolean> {
   ]);
   return confirm;
 }
+
+/**
+ * Check MCP servers - find servers not in Flow registry
+ */
+export async function checkMCPServers(cwd: string): Promise<string[]> {
+  const mcpPath = path.join(cwd, '.mcp.json');
+
+  if (!fs.existsSync(mcpPath)) {
+    return [];
+  }
+
+  try {
+    const content = await fs.promises.readFile(mcpPath, 'utf-8');
+    const mcpConfig = JSON.parse(content);
+
+    if (!mcpConfig.mcpServers) {
+      return [];
+    }
+
+    const installedServers = Object.keys(mcpConfig.mcpServers);
+    const registryServers = Object.keys(MCP_SERVER_REGISTRY);
+
+    // Find servers not in registry
+    return installedServers.filter(id => !registryServers.includes(id));
+  } catch (error) {
+    console.warn(chalk.yellow('⚠ Failed to read .mcp.json'));
+    return [];
+  }
+}
+
+/**
+ * Show non-registry servers
+ */
+export function showNonRegistryServers(servers: string[]): void {
+  if (servers.length === 0) {
+    return;
+  }
+
+  console.log(chalk.cyan.bold('\n📋 MCP Registry Check\n'));
+  console.log(chalk.yellow('⚠️  以下 MCP servers 唔係 Flow registry 入面:\n'));
+
+  servers.forEach(server => {
+    console.log(chalk.dim(`    - ${server}`));
+  });
+
+  console.log(chalk.dim('\n可能原因:'));
+  console.log(chalk.dim('  1. Flow registry 已移除'));
+  console.log(chalk.dim('  2. 你自己手動安裝\n'));
+}
+
+/**
+ * Select servers to remove
+ */
+export async function selectServersToRemove(servers: string[]): Promise<string[]> {
+  const { default: inquirer } = await import('inquirer');
+  const { selected } = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'selected',
+      message: '選擇要刪除既 servers:',
+      choices: servers.map(s => ({ name: s, value: s })),
+    },
+  ]);
+  return selected;
+}
+
+/**
+ * Remove MCP servers from .mcp.json
+ */
+export async function removeMCPServers(cwd: string, serversToRemove: string[]): Promise<number> {
+  if (serversToRemove.length === 0) {
+    return 0;
+  }
+
+  const mcpPath = path.join(cwd, '.mcp.json');
+
+  try {
+    const content = await fs.promises.readFile(mcpPath, 'utf-8');
+    const mcpConfig = JSON.parse(content);
+
+    if (!mcpConfig.mcpServers) {
+      return 0;
+    }
+
+    let removedCount = 0;
+    for (const server of serversToRemove) {
+      if (mcpConfig.mcpServers[server]) {
+        delete mcpConfig.mcpServers[server];
+        removedCount++;
+      }
+    }
+
+    // Write back
+    await fs.promises.writeFile(
+      mcpPath,
+      JSON.stringify(mcpConfig, null, 2) + '\n',
+      'utf-8'
+    );
+
+    return removedCount;
+  } catch (error) {
+    console.warn(chalk.yellow('⚠ Failed to update .mcp.json'));
+    return 0;
+  }
+}

package/src/commands/codebase-command.ts

@@ -1,168 +0,0 @@
-import chalk from 'chalk';
-import { Command } from 'commander';
-import ora from 'ora';
-import { ReindexMonitor } from '../components/reindex-progress.js';
-import { CodebaseIndexer } from '../services/search/codebase-indexer.js';
-import { getDefaultEmbeddingProvider } from '../services/search/embeddings.js';
-import { getSearchService } from '../services/search/unified-search-service.js';
-import { CLIError } from '../utils/error-handler.js';
-
-export const codebaseSearchCommand = new Command('search')
-  .description('Search codebase files and source code')
-  .argument('<query>', 'Search query - use natural language, function names, or technical terms')
-  .option('-l, --limit <number>', 'Maximum number of results to return', '10')
-  .option('--include-content', 'Include file content snippets in results', true)
-  .option('--extensions <exts...>', 'Filter by file extensions (e.g., .ts .tsx .js)')
-  .option('--path <pattern>', 'Filter by path pattern (e.g., src/components)')
-  .option('--exclude <patterns...>', 'Exclude paths containing these patterns')
-  .action(async (query, options) => {
-    try {
-      console.log('');
-      console.log(chalk.cyan.bold('▸ Search Codebase'));
-      console.log(chalk.gray(`  Query: "${query}"`));
-
-      const spinner = ora('Searching...').start();
-      const searchService = getSearchService();
-      await searchService.initialize();
-
-      const result = await searchService.searchCodebase(query, {
-        limit: Number.parseInt(String(options.limit), 10) || 10,
-        include_content: options.includeContent !== false,
-        file_extensions: options.extensions,
-        path_filter: options.path,
-        exclude_paths: options.exclude,
-      });
-
-      spinner.stop();
-
-      const output = searchService.formatResultsForCLI(result.results, query, result.totalIndexed);
-      console.log(output);
-      console.log('');
-    } catch (error) {
-      console.error(chalk.red(`\n✗ Error: ${(error as Error).message}\n`));
-      process.exit(1);
-    }
-  });
-
-export const codebaseReindexCommand = new Command('reindex')
-  .description('Reindex all codebase files')
-  .action(async () => {
-    try {
-      const indexer = new CodebaseIndexer();
-
-      // Check if API key exists - only use embeddings if key is present
-      const hasApiKey = !!process.env.OPENAI_API_KEY;
-      const embeddingProvider = hasApiKey ? await getDefaultEmbeddingProvider() : undefined;
-      const mode: 'tfidf-only' | 'semantic' = hasApiKey ? 'semantic' : 'tfidf-only';
-
-      // Create monitor for progress display
-      const monitor = new ReindexMonitor();
-
-      // Start the UI
-      monitor.start(0); // Will update total when we know file count
-
-      let totalFiles = 0;
-      let phase: 'tokenizing' | 'calculating' | 'completed' = 'tokenizing';
-
-      // Set initial mode
-      monitor.updateProgress({ mode });
-
-      const result = await indexer.indexCodebase({
-        force: true, // Reindex should always force rebuild
-        embeddingProvider,
-        onProgress: (progress) => {
-          // Track total files on first progress update
-          if (totalFiles === 0 && progress.total > 0) {
-            totalFiles = progress.total;
-          }
-
-          // Update Ink UI only (stderr output was interfering with Ink rendering)
-          monitor.updateProgress({
-            current: progress.current,
-            total: progress.total,
-            fileName: progress.fileName,
-            status: progress.status,
-            phase,
-          });
-        },
-      });
-
-      // Handle cache hit - simulate progress to show 100%
-      if (result.stats.cacheHit) {
-        monitor.updateProgress({
-          current: result.stats.totalFiles,
-          total: result.stats.totalFiles,
-          fileName: '',
-          status: 'completed',
-          phase: 'tokenizing',
-        });
-
-        // Small delay
-        await new Promise((resolve) => setTimeout(resolve, 300));
-      } else {
-        // Update to calculating phase
-        phase = 'calculating';
-        monitor.updateProgress({ phase: 'calculating' });
-
-        // Small delay to show calculating phase
-        await new Promise((resolve) => setTimeout(resolve, 500));
-      }
-
-      // Show completion with stats
-      monitor.updateProgress({
-        phase: 'completed',
-        stats: {
-          documentsProcessed: result.stats.totalFiles,
-          uniqueTerms: result.tfidfIndex.idf.size,
-        },
-      });
-
-      // Give time to see the completion message
-      await new Promise((resolve) => setTimeout(resolve, 2000));
-
-      monitor.stop();
-    } catch (error) {
-      throw new CLIError(`Codebase reindex failed: ${(error as Error).message}`);
-    }
-  });
-
-export const codebaseStatusCommand = new Command('status')
-  .description('Get codebase search system status')
-  .action(async () => {
-    try {
-      console.log('');
-      console.log(chalk.cyan.bold('▸ Codebase Status'));
-
-      const searchService = getSearchService();
-      await searchService.initialize();
-      const status = await searchService.getStatus();
-
-      if (status.codebase.indexed) {
-        console.log(chalk.green('\n✓ Indexed and ready'));
-        console.log(chalk.gray(`  Files: ${status.codebase.fileCount}`));
-        if (status.codebase.indexedAt) {
-          console.log(
-            chalk.gray(`  Last indexed: ${new Date(status.codebase.indexedAt).toLocaleString()}`)
-          );
-        }
-      } else {
-        console.log(chalk.yellow('\n⚠ Not indexed'));
-        console.log(chalk.gray('  Run: sylphx-flow codebase reindex'));
-      }
-
-      console.log(chalk.cyan('\n▸ Available Commands'));
-      console.log(chalk.gray('  • codebase search <query>'));
-      console.log(chalk.gray('  • codebase reindex'));
-      console.log(chalk.gray('  • codebase status'));
-      console.log('');
-    } catch (error) {
-      console.error(chalk.red(`\n✗ Error: ${(error as Error).message}\n`));
-      process.exit(1);
-    }
-  });
-
-export const codebaseCommand = new Command('codebase')
-  .description('Manage codebase indexing and search')
-  .addCommand(codebaseSearchCommand)
-  .addCommand(codebaseReindexCommand)
-  .addCommand(codebaseStatusCommand);

package/src/commands/knowledge-command.ts

@@ -1,161 +0,0 @@
-/**
- * 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/composables/useTargetConfig.ts

@@ -1,45 +0,0 @@
-import { getTarget, getDefaultTargetUnsafe } from '../config/targets.js';
-import { projectSettings } from '../utils/settings.js';
-import type { MCPServerConfigFlags } from '../types.js';
-
-/**
- * Get the current target's MCP server configuration
- * Follows the same resolution pattern as targetManager.resolveTarget()
- * Returns undefined if no target is set or target has no mcpServerConfig
- */
-export async function useTargetConfig(): Promise<MCPServerConfigFlags | undefined> {
-  try {
-    // Try to get target from project settings first
-    const settings = await projectSettings.load();
-    const targetId = settings?.target;
-
-    if (targetId) {
-      const targetOption = getTarget(targetId);
-      if (targetOption._tag === 'Some') {
-        return targetOption.value.mcpServerConfig;
-      }
-    }
-
-    // Fall back to default target
-    const defaultTarget = getDefaultTargetUnsafe();
-    return defaultTarget.mcpServerConfig;
-  } catch {
-    // If no target can be resolved, return undefined
-    return undefined;
-  }
-}
-
-/**
- * Get a specific target's MCP server configuration by ID
- */
-export function useTargetConfigById(targetId: string): MCPServerConfigFlags | undefined {
-  try {
-    const targetOption = getTarget(targetId);
-    if (targetOption._tag === 'None') {
-      return undefined;
-    }
-    return targetOption.value.mcpServerConfig;
-  } catch {
-    return undefined;
-  }
-}