@sylphx/flow 1.1.1 → 1.2.0

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

package/src/core/formatting/bytes.test.ts

@@ -1,115 +0,0 @@
-/**
- * Tests for Byte Formatting Utilities
- */
-
-import { describe, expect, it } from 'bun:test';
-import { formatBytes, formatFileSize } from './bytes.js';
-
-describe('formatBytes', () => {
-  describe('default options (decimals: 2, longUnits)', () => {
-    it('formats 0 bytes', () => {
-      expect(formatBytes(0)).toBe('0 Bytes');
-    });
-
-    it('formats bytes', () => {
-      expect(formatBytes(500)).toBe('500 Bytes');
-    });
-
-    it('formats kilobytes', () => {
-      expect(formatBytes(1024)).toBe('1 KB');
-      expect(formatBytes(1536)).toBe('1.5 KB');
-    });
-
-    it('formats megabytes', () => {
-      expect(formatBytes(1048576)).toBe('1 MB');
-      expect(formatBytes(1572864)).toBe('1.5 MB');
-    });
-
-    it('formats gigabytes', () => {
-      expect(formatBytes(1073741824)).toBe('1 GB');
-      expect(formatBytes(1610612736)).toBe('1.5 GB');
-    });
-
-    it('formats terabytes', () => {
-      expect(formatBytes(1099511627776)).toBe('1 TB');
-    });
-
-    it('rounds to 2 decimal places', () => {
-      expect(formatBytes(1587)).toBe('1.55 KB');
-      expect(formatBytes(1638400)).toBe('1.56 MB');
-    });
-  });
-
-  describe('with decimals option', () => {
-    it('formats with 0 decimals', () => {
-      expect(formatBytes(1536, { decimals: 0 })).toBe('2 KB');
-      expect(formatBytes(1024, { decimals: 0 })).toBe('1 KB');
-    });
-
-    it('formats with 1 decimal', () => {
-      expect(formatBytes(1536, { decimals: 1 })).toBe('1.5 KB');
-      expect(formatBytes(1587, { decimals: 1 })).toBe('1.5 KB');
-    });
-
-    it('formats with 3 decimals', () => {
-      expect(formatBytes(1587, { decimals: 3 })).toBe('1.55 KB'); // toFixed trims to 1.550, then trimmed
-    });
-  });
-
-  describe('with shortUnits option', () => {
-    it('uses short unit for 0 bytes', () => {
-      expect(formatBytes(0, { shortUnits: true })).toBe('0 B');
-    });
-
-    it('uses short unit for bytes', () => {
-      expect(formatBytes(500, { shortUnits: true })).toBe('500 B');
-    });
-
-    it('uses short units for kilobytes', () => {
-      expect(formatBytes(1024, { shortUnits: true })).toBe('1 KB');
-    });
-
-    it('uses short units for megabytes', () => {
-      expect(formatBytes(1048576, { shortUnits: true })).toBe('1 MB');
-    });
-  });
-
-  describe('combined options', () => {
-    it('uses short units with 1 decimal', () => {
-      expect(formatBytes(1536, { decimals: 1, shortUnits: true })).toBe('1.5 KB');
-    });
-
-    it('uses short units with 0 decimals', () => {
-      expect(formatBytes(1536, { decimals: 0, shortUnits: true })).toBe('2 KB');
-    });
-  });
-
-  describe('edge cases', () => {
-    it('handles 1 byte', () => {
-      expect(formatBytes(1)).toBe('1 Bytes');
-    });
-
-    it('handles very large numbers', () => {
-      const result = formatBytes(1099511627776 * 1024); // 1 PB
-      expect(result).toContain('TB'); // Will show in TB since we only go up to TB
-    });
-
-    it('handles fractional KB', () => {
-      expect(formatBytes(1500)).toBe('1.46 KB');
-    });
-  });
-});
-
-describe('formatFileSize', () => {
-  it('formats with 1 decimal and short units', () => {
-    expect(formatFileSize(0)).toBe('0 B');
-    expect(formatFileSize(1024)).toBe('1 KB'); // toFixed(1) gives "1.0", trimmed to "1"
-    expect(formatFileSize(1536)).toBe('1.5 KB');
-    expect(formatFileSize(1048576)).toBe('1 MB'); // toFixed(1) gives "1.0", trimmed to "1"
-  });
-
-  it('is an alias for formatBytes with specific options', () => {
-    const bytes = 1572864;
-    expect(formatFileSize(bytes)).toBe(formatBytes(bytes, { decimals: 1, shortUnits: true }));
-  });
-});