@sylphx/flow 1.0.1 → 1.0.3

package/src/targets/opencode.ts

@@ -0,0 +1,529 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import chalk from 'chalk';
+import { getRulesPath, ruleFileExists } from '../config/rules.js';
+import { MCP_SERVER_REGISTRY } from '../config/servers.js';
+import { FileInstaller } from '../core/installers/file-installer.js';
+import { MCPInstaller } from '../core/installers/mcp-installer.js';
+import type { AgentMetadata } from '../types/target-config.types.js';
+import type { CommonOptions, MCPServerConfigUnion, SetupResult, Target } from '../types.js';
+import { getAgentsDir, getOutputStylesDir, getSlashCommandsDir } from '../utils/paths.js';
+import { secretUtils } from '../utils/secret-utils.js';
+import { fileUtils, generateHelpText, yamlUtils } from '../utils/target-utils.js';
+import { CLIError } from '../utils/error-handler.js';
+
+/**
+ * OpenCode target - composition approach with all original functionality
+ */
+export const opencodeTarget: Target = {
+  id: 'opencode',
+  name: 'OpenCode',
+  description: 'OpenCode IDE with YAML front matter agents (.opencode/agent/*.md)',
+  category: 'ide',
+  isImplemented: true,
+  isDefault: true,
+
+  mcpServerConfig: {
+    disableTime: false,
+    disableKnowledge: false,
+    disableCodebase: false,
+  },
+
+  config: {
+    agentDir: '.opencode/agent',
+    agentExtension: '.md',
+    agentFormat: 'yaml-frontmatter',
+    stripYaml: false,
+    flatten: false,
+    configFile: 'opencode.jsonc',
+    configSchema: 'https://opencode.ai/config.json',
+    mcpConfigPath: 'mcp',
+    rulesFile: 'AGENTS.md',
+    outputStylesDir: undefined, // OpenCode doesn't support output styles as separate files
+    slashCommandsDir: '.opencode/command', // OpenCode uses singular 'command', not 'commands'
+    installation: {
+      createAgentDir: true,
+      createConfigFile: true,
+      useSecretFiles: true,
+    },
+  },
+
+  /**
+   * Transform agent content for OpenCode
+   * OpenCode uses YAML front matter, but removes name field as it doesn't use it
+   */
+  async transformAgentContent(
+    content: string,
+    metadata?: AgentMetadata,
+    _sourcePath?: string
+  ): Promise<string> {
+    // For OpenCode, we preserve YAML front matter but remove unsupported fields
+    const { metadata: existingMetadata, content: baseContent } =
+      await yamlUtils.extractFrontMatter(content);
+
+    // Remove fields that OpenCode doesn't support:
+    // - name: not used by OpenCode
+    // - mode: OpenCode doesn't support 'both' mode (only 'primary')
+    // - rules: OpenCode doesn't use rule references
+    const { name, mode, rules, ...cleanMetadata } = existingMetadata;
+
+    // If additional metadata is provided, merge it (but exclude unsupported fields)
+    if (metadata) {
+      const { name: additionalName, mode: additionalMode, rules: additionalRules, ...additionalCleanMetadata } = metadata;
+      const mergedMetadata = { ...cleanMetadata, ...additionalCleanMetadata };
+      return yamlUtils.addFrontMatter(baseContent, mergedMetadata);
+    }
+
+    // Return content with only OpenCode-supported fields
+    return yamlUtils.addFrontMatter(baseContent, cleanMetadata);
+  },
+
+  /**
+   * Transform MCP server configuration for OpenCode
+   * Convert from Claude Code's optimal format to OpenCode's format
+   */
+  transformMCPConfig(config: MCPServerConfigUnion, _serverId?: string): Record<string, unknown> {
+    // Handle new Claude Code stdio format
+    if (config.type === 'stdio') {
+      // Convert Claude Code format to OpenCode format
+      const openCodeConfig: Record<string, unknown> = {
+        type: 'local',
+        command: [config.command],
+      };
+
+      if (config.args && config.args.length > 0) {
+        openCodeConfig.command.push(...config.args);
+      }
+
+      if (config.env) {
+        openCodeConfig.environment = config.env;
+      }
+
+      return openCodeConfig;
+    }
+
+    // Handle new Claude Code http format
+    if (config.type === 'http') {
+      // Claude Code http format is compatible with OpenCode remote format
+      return {
+        type: 'remote',
+        url: config.url,
+        ...(config.headers && { headers: config.headers }),
+      };
+    }
+
+    // Handle legacy OpenCode formats (pass through)
+    if (config.type === 'local' || config.type === 'remote') {
+      return config;
+    }
+
+    return config;
+  },
+
+  getConfigPath: (cwd: string) =>
+    Promise.resolve(fileUtils.getConfigPath(opencodeTarget.config, cwd)),
+
+  /**
+   * Read OpenCode configuration with structure normalization
+   */
+  async readConfig(cwd: string): Promise<any> {
+    const config = await fileUtils.readConfig(opencodeTarget.config, cwd);
+
+    // Resolve any file references in the configuration
+    const resolvedConfig = await secretUtils.resolveFileReferences(cwd, config);
+
+    // Ensure the config has the expected structure
+    if (!resolvedConfig.mcp) {
+      resolvedConfig.mcp = {};
+    }
+
+    return resolvedConfig;
+  },
+
+  /**
+   * Write OpenCode configuration with structure normalization
+   */
+  async writeConfig(cwd: string, config: Record<string, unknown>): Promise<void> {
+    // Ensure the config has the expected structure for OpenCode
+    if (!config.mcp) {
+      config.mcp = {};
+    }
+
+    // Convert secrets to file references if secret files are enabled
+    if (opencodeTarget.config.installation?.useSecretFiles) {
+      // Process each MCP server's environment variables
+      for (const [serverId, serverConfig] of Object.entries(config.mcp || {})) {
+        if (serverConfig && typeof serverConfig === 'object' && 'environment' in serverConfig) {
+          const envVars = serverConfig.environment as Record<string, string>;
+          if (envVars && typeof envVars === 'object') {
+            // Find the corresponding server definition to get secret env vars
+            const serverDef = Object.values(MCP_SERVER_REGISTRY).find((s) => s.name === serverId);
+            if (serverDef?.envVars) {
+              // Separate secret and non-secret variables
+              const secretEnvVars: Record<string, string> = {};
+              const nonSecretEnvVars: Record<string, string> = {};
+
+              for (const [key, value] of Object.entries(envVars)) {
+                const envConfig = serverDef.envVars[key];
+                if (envConfig?.secret && value && !secretUtils.isFileReference(value)) {
+                  secretEnvVars[key] = value;
+                } else {
+                  nonSecretEnvVars[key] = value;
+                }
+              }
+
+              // Convert only secret variables
+              const convertedSecrets = await secretUtils.convertSecretsToFileReferences(
+                cwd,
+                secretEnvVars
+              );
+
+              // Merge back
+              serverConfig.environment = { ...nonSecretEnvVars, ...convertedSecrets };
+            }
+          }
+        }
+      }
+    }
+
+    await fileUtils.writeConfig(opencodeTarget.config, cwd, config);
+  },
+
+  validateRequirements: (cwd: string) => fileUtils.validateRequirements(opencodeTarget.config, cwd),
+
+  /**
+   * Get detailed OpenCode-specific help text
+   */
+  getHelpText(): string {
+    let help = generateHelpText(opencodeTarget.config);
+
+    help += 'OpenCode-Specific Information:\n';
+    help += '  Configuration File: opencode.jsonc\n';
+    help += '  Schema: https://opencode.ai/config.json\n';
+    help += '  Agent Format: Markdown with YAML front matter\n';
+    help += '  MCP Integration: Automatic server discovery\n\n';
+
+    help += 'Example Agent Structure:\n';
+    help += '  ---\n';
+    help += `  name: "My Agent"\n`;
+    help += `  description: "Agent description"\n`;
+    help += '  ---\n\n';
+    help += '  Agent content here...\n\n';
+
+    return help;
+  },
+
+  /**
+   * Detect if this target is being used in the current environment
+   */
+  detectFromEnvironment(): boolean {
+    try {
+      const cwd = process.cwd();
+      return fs.existsSync(path.join(cwd, 'opencode.jsonc'));
+    } catch {
+      return false;
+    }
+  },
+
+  /**
+   * Transform rules content for OpenCode
+   * OpenCode doesn't need front matter in rules files (AGENTS.md)
+   */
+  async transformRulesContent(content: string): Promise<string> {
+    return yamlUtils.stripFrontMatter(content);
+  },
+
+  /**
+   * Setup agents for OpenCode
+   * Install agents to .opencode/agent/ directory
+   */
+  async setupAgents(cwd: string, options: CommonOptions): Promise<SetupResult> {
+    // Clean up old 'commands' directory if it exists (migration from old structure)
+    // This ensures OpenCode won't crash with ConfigDirectoryTypoError
+    const oldCommandsDir = path.join(cwd, '.opencode/commands');
+    try {
+      await fs.rm(oldCommandsDir, { recursive: true, force: true });
+    } catch {
+      // Ignore if doesn't exist
+    }
+
+    const installer = new FileInstaller();
+    const agentsDir = path.join(cwd, this.config.agentDir);
+
+    const results = await installer.installToDirectory(
+      getAgentsDir(),
+      agentsDir,
+      async (content, sourcePath) => {
+        return await this.transformAgentContent(content, undefined, sourcePath);
+      },
+      {
+        ...options,
+        showProgress: false, // UI handled by init-command
+      }
+    );
+
+    return { count: results.length };
+  },
+
+  /**
+   * Setup output styles for OpenCode
+   * Append output styles to AGENTS.md (OpenCode doesn't support separate output style files)
+   */
+  async setupOutputStyles(cwd: string, _options: CommonOptions): Promise<SetupResult> {
+    if (!this.config.rulesFile) {
+      return { count: 0 };
+    }
+
+    const rulesFilePath = path.join(cwd, this.config.rulesFile);
+
+    // Read existing rules file content if it exists
+    let existingContent = '';
+    if (fs.existsSync(rulesFilePath)) {
+      existingContent = fs.readFileSync(rulesFilePath, 'utf8');
+    }
+
+    // Build output styles section
+    const outputStylesSourceDir = getOutputStylesDir();
+    if (!fs.existsSync(outputStylesSourceDir)) {
+      return { count: 0 }; // No output styles available
+    }
+
+    let outputStylesContent = '\n\n---\n\n# Output Styles\n\n';
+
+    // Collect output style files
+    const files = fs
+      .readdirSync(outputStylesSourceDir, { withFileTypes: true })
+      .filter((dirent) => dirent.isFile() && dirent.name.endsWith('.md'))
+      .map((dirent) => dirent.name);
+
+    if (files.length === 0) {
+      return { count: 0 };
+    }
+
+    for (const styleFile of files) {
+      const sourcePath = path.join(outputStylesSourceDir, styleFile);
+      let content = fs.readFileSync(sourcePath, 'utf8');
+
+      // Strip YAML front matter for system prompt
+      if (this.transformRulesContent) {
+        content = await this.transformRulesContent(content);
+      }
+
+      outputStylesContent += `${content}\n\n`;
+    }
+
+    // Check if output styles section already exists
+    const outputStylesMarker = '# Output Styles';
+    if (existingContent.includes(outputStylesMarker)) {
+      // Replace existing output styles section
+      const startIndex = existingContent.indexOf('---\n\n# Output Styles');
+      if (startIndex !== -1) {
+        existingContent = existingContent.substring(0, startIndex);
+      }
+    }
+
+    // Append output styles section
+    fs.writeFileSync(rulesFilePath, existingContent + outputStylesContent, 'utf8');
+
+    return { count: files.length };
+  },
+
+  /**
+   * Setup rules for OpenCode
+   * Install rules to AGENTS.md in project root
+   */
+  async setupRules(cwd: string, options: CommonOptions): Promise<SetupResult> {
+    if (!this.config.rulesFile) {
+      return { count: 0 };
+    }
+
+    // Check if core rules file exists
+    if (!ruleFileExists('core')) {
+      throw new Error('Core rules file not found');
+    }
+
+    const installer = new FileInstaller();
+    const rulesDestPath = path.join(cwd, this.config.rulesFile);
+    const rulePath = getRulesPath('core');
+
+    await installer.installFile(
+      rulePath,
+      rulesDestPath,
+      async (content) => {
+        // Transform rules content if transformation is available
+        if (this.transformRulesContent) {
+          return await this.transformRulesContent(content);
+        }
+        return content;
+      },
+      {
+        ...options,
+        showProgress: false, // UI handled by init-command
+      }
+    );
+
+    return { count: 1 };
+  },
+
+  /**
+   * Setup MCP servers for OpenCode
+   * Select, configure, install, and setup secrets directory
+   */
+  async setupMCP(cwd: string, options: CommonOptions): Promise<SetupResult> {
+    // Setup secrets directory first (OpenCode-specific)
+    if (!options.dryRun) {
+      await secretUtils.ensureSecretsDir(cwd);
+      await secretUtils.addToGitignore(cwd);
+    }
+
+    // Install MCP servers
+    const installer = new MCPInstaller(this);
+    const result = await installer.setupMCP({ ...options, quiet: true });
+
+    return { count: result.selectedServers.length };
+  },
+
+  /**
+   * Setup slash commands for OpenCode
+   * Install slash command templates to .opencode/command/ directory
+   */
+  async setupSlashCommands(cwd: string, options: CommonOptions): Promise<SetupResult> {
+    if (!this.config.slashCommandsDir) {
+      return { count: 0 };
+    }
+
+    // Clean up old 'commands' directory if it exists (migration from old structure)
+    const oldCommandsDir = path.join(cwd, '.opencode/commands');
+    try {
+      await fs.rm(oldCommandsDir, { recursive: true, force: true });
+    } catch {
+      // Ignore if doesn't exist
+    }
+
+    const installer = new FileInstaller();
+    const slashCommandsDir = path.join(cwd, this.config.slashCommandsDir);
+
+    const results = await installer.installToDirectory(
+      getSlashCommandsDir(),
+      slashCommandsDir,
+      async (content) => {
+        // Slash commands are plain markdown with front matter - no transformation needed
+        return content;
+      },
+      {
+        ...options,
+        showProgress: false, // UI handled by init-command
+      }
+    );
+
+    return { count: results.length };
+  },
+
+  /**
+   * Execute OpenCode CLI
+   */
+  async executeCommand(
+    systemPrompt: string,
+    userPrompt: string,
+    options: { verbose?: boolean; dryRun?: boolean; print?: boolean; continue?: boolean; agent?: string } = {}
+  ): Promise<void> {
+    if (options.dryRun) {
+      // Build the command for display
+      const dryRunArgs = ['opencode'];
+      if (options.print) {
+        // Don't use --agent with 'run' (OpenCode bug)
+        dryRunArgs.push('run');
+        if (options.continue) {
+          dryRunArgs.push('-c');
+        }
+        if (userPrompt && userPrompt.trim() !== '') {
+          dryRunArgs.push(`"${userPrompt}"`);
+        }
+      } else {
+        if (options.agent) {
+          dryRunArgs.push('--agent', options.agent);
+        }
+        if (userPrompt && userPrompt.trim() !== '') {
+          dryRunArgs.push('-p', `"${userPrompt}"`);
+        }
+      }
+
+      console.log(chalk.cyan('Dry run - Would execute:'));
+      console.log(chalk.bold(dryRunArgs.join(' ')));
+      console.log(chalk.dim(`Agent: ${options.agent || 'coder'}`));
+      console.log(chalk.dim(`User prompt: ${userPrompt.length} characters`));
+      console.log('✓ Dry run completed successfully');
+      return;
+    }
+
+    try {
+      const { spawn } = await import('node:child_process');
+
+      const args = [];
+
+      // Handle print mode (headless)
+      if (options.print) {
+        // Note: Don't use --agent flag with 'run' command - OpenCode has a bug
+        // TypeError: undefined is not an object (evaluating 'input.agent.model')
+        // Default agent is 'coder' anyway
+        args.push('run');
+        // Use -c flag to continue last session (stdin is closed to prevent hanging)
+        if (options.continue) {
+          args.push('-c');
+        }
+        if (userPrompt && userPrompt.trim() !== '') {
+          args.push(userPrompt);
+        }
+      } else {
+        // Add agent flag for normal mode (TUI)
+        if (options.agent) {
+          args.push('--agent', options.agent);
+        }
+        // Normal mode with -p flag for prompt
+        if (userPrompt && userPrompt.trim() !== '') {
+          args.push('-p', userPrompt);
+        }
+      }
+
+      // Always print command for debugging in loop/headless mode
+      if (options.verbose || options.print) {
+        console.log(chalk.dim(`$ opencode ${args.join(' ')}`));
+      }
+
+      await new Promise<void>((resolve, reject) => {
+        const child = spawn('opencode', args, {
+          // In print mode (headless), close stdin to prevent waiting for input
+          // In normal mode, inherit all stdio for interactive TUI
+          stdio: options.print ? ['ignore', 'inherit', 'inherit'] : 'inherit',
+          shell: true,
+          env: process.env, // Pass environment variables
+        });
+
+        child.on('spawn', () => {
+          if (options.verbose) {
+            console.log('✓ OpenCode process started');
+          }
+        });
+
+        child.on('error', (error) => {
+          console.error('✗ Error spawning OpenCode:', error);
+          reject(error);
+        });
+
+        child.on('close', (code) => {
+          if (code !== 0) {
+            reject(new Error(`OpenCode exited with code ${code}`));
+          } else {
+            resolve();
+          }
+        });
+      });
+
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new CLIError(`Failed to execute OpenCode: ${error.message}`, 'OPENCODE_ERROR');
+      }
+      throw error;
+    }
+  },
+};

package/src/types/agent.types.ts

@@ -0,0 +1,32 @@
+/**
+ * Agent Types
+ * Defines agents with custom system prompts and metadata
+ */
+
+/**
+ * Agent metadata from front matter
+ */
+export interface AgentMetadata {
+  name: string;
+  description: string;
+  rules?: string[]; // Optional list of rule files to include (e.g., ['core', 'code-standards'])
+}
+
+/**
+ * Agent definition
+ */
+export interface Agent {
+  id: string; // File name without extension (e.g., 'coder', 'planner')
+  metadata: AgentMetadata;
+  systemPrompt: string;
+  isBuiltin: boolean; // Whether this is a system-provided agent
+  filePath?: string; // Path to the agent file (for user-defined agents)
+}
+
+/**
+ * Agent source location
+ */
+export interface AgentSource {
+  type: 'global' | 'project' | 'builtin';
+  path: string;
+}

package/src/types/api/batch.ts

@@ -0,0 +1,108 @@
+import { z } from 'zod';
+import type { ApiError } from './errors.js';
+
+// ============================================================================
+// BATCH API INTERFACES
+// ============================================================================
+
+/**
+ * Batch API result for processing multiple operations
+ */
+export interface BatchApiResult<T = unknown> {
+  /** Batch operation ID */
+  batchId: string;
+  /** Total number of operations */
+  total: number;
+  /** Number of successful operations */
+  successful: number;
+  /** Number of failed operations */
+  failed: number;
+  /** Results for individual operations */
+  results: BatchOperationResult<T>[];
+  /** Batch operation metadata */
+  metadata?: {
+    /** Batch start timestamp */
+    startedAt: string;
+    /** Batch completion timestamp */
+    completedAt?: string;
+    /** Total processing time in milliseconds */
+    duration?: number;
+    /** Processing batch size */
+    batchSize?: number;
+    /** Number of concurrent operations */
+    concurrency?: number;
+  };
+}
+
+/**
+ * Individual batch operation result
+ */
+export interface BatchOperationResult<T = unknown> {
+  /** Operation index in the batch */
+  index: number;
+  /** Operation ID */
+  id: string;
+  /** Operation success status */
+  success: boolean;
+  /** Operation result data */
+  data?: T;
+  /** Operation error (if failed) */
+  error?: ApiError;
+  /** Operation processing time in milliseconds */
+  processingTime?: number;
+  /** Operation retry attempts */
+  retryCount?: number;
+}
+
+// ============================================================================
+// ZOD SCHEMAS
+// ============================================================================
+
+export const BatchOperationResultSchema = z.object({
+  index: z.number().min(0),
+  id: z.string(),
+  success: z.boolean(),
+  data: z.unknown().optional(),
+  error: z
+    .object({
+      code: z.string(),
+      message: z.string(),
+      statusCode: z.number().optional(),
+      type: z.enum([
+        'validation',
+        'authentication',
+        'authorization',
+        'not_found',
+        'conflict',
+        'rate_limit',
+        'server_error',
+        'network',
+        'timeout',
+      ]),
+      description: z.string().optional(),
+      fieldErrors: z.record(z.array(z.string())).optional(),
+      stack: z.string().optional(),
+      context: z.record(z.unknown()).optional(),
+      suggestions: z.array(z.string()).optional(),
+    })
+    .optional(),
+  processingTime: z.number().min(0).optional(),
+  retryCount: z.number().min(0).optional(),
+});
+
+export const BatchApiResultSchema = z.object({
+  batchId: z.string(),
+  total: z.number().min(0),
+  successful: z.number().min(0),
+  failed: z.number().min(0),
+  results: z.array(BatchOperationResultSchema),
+  metadata: z
+    .object({
+      startedAt: z.string(),
+      completedAt: z.string().optional(),
+      duration: z.number().min(0).optional(),
+      batchSize: z.number().positive().optional(),
+      concurrency: z.number().positive().optional(),
+    })
+    .optional(),
+});