@sylphx/flow 2.1.3 → 2.1.5

package/src/core/state-detector.ts

@@ -1,9 +1,9 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { projectSettings } from '../utils/config/settings.js';
-import { targetManager } from './target-manager.js';
 import { ConfigService } from '../services/config-service.js';
+import type { Target } from '../types/target.types.js';
+import { targetManager } from './target-manager.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -28,7 +28,13 @@ export interface ProjectState {
   lastUpdated: Date | null;
 }
 
-export type RecommendedAction = 'FULL_INIT' | 'RUN_ONLY' | 'REPAIR' | 'UPGRADE' | 'UPGRADE_TARGET' | 'CLEAN_INIT';
+export type RecommendedAction =
+  | 'FULL_INIT'
+  | 'RUN_ONLY'
+  | 'REPAIR'
+  | 'UPGRADE'
+  | 'UPGRADE_TARGET'
+  | 'CLEAN_INIT';
 
 export class StateDetector {
   private projectPath: string;
@@ -37,6 +43,17 @@ export class StateDetector {
     this.projectPath = projectPath;
   }
 
+  /**
+   * Resolve target from ID string to Target object
+   */
+  private resolveTarget(targetId: string): Target | null {
+    const targetOption = targetManager.getTarget(targetId);
+    if (targetOption._tag === 'None') {
+      return null;
+    }
+    return targetOption.value;
+  }
+
   async detect(): Promise<ProjectState> {
     const state: ProjectState = {
       initialized: false,
@@ -77,37 +94,16 @@ export class StateDetector {
         state.outdated = this.isVersionOutdated(state.version, state.latestVersion);
       }
 
-      // Check components based on target
-      if (state.target === 'opencode') {
-        // OpenCode uses different directory structure
-        await this.checkComponent('agents', '.opencode/agent', '*.md', state);
-        // OpenCode uses AGENTS.md for rules
-        await this.checkFileComponent('rules', 'AGENTS.md', state);
-        // OpenCode doesn't have separate hooks directory (hooks config in opencode.jsonc)
-        state.components.hooks.installed = false;
-        // OpenCode appends output styles to AGENTS.md
-        state.components.outputStyles.installed = await this.checkOutputStylesInAGENTS();
-        await this.checkComponent('slashCommands', '.opencode/command', '*.md', state);
-      } else {
-        // Claude Code (default)
-        await this.checkComponent('agents', '.claude/agents', '*.md', state);
-
-        // Claude Code includes rules and output styles in agent files
-        // So we mark them as installed if agents are installed
-        state.components.rules.installed = state.components.agents.installed;
-        state.components.rules.count = state.components.agents.count;
-
-        state.components.outputStyles.installed = state.components.agents.installed;
-
-        // Check hooks (optional for Claude Code)
-        await this.checkComponent('hooks', '.claude/hooks', '*.js', state);
-
-        // Check slash commands
-        await this.checkComponent('slashCommands', '.claude/commands', '*.md', state);
+      // Resolve target to get config
+      const target = state.target ? this.resolveTarget(state.target) : null;
+
+      // Check components based on target config
+      if (target) {
+        await this.checkComponentsForTarget(target, state);
       }
 
       // Check MCP
-      const mcpConfig = await this.checkMCPConfig(state.target);
+      const mcpConfig = await this.checkMCPConfig(target);
       state.components.mcp.installed = mcpConfig.exists;
       state.components.mcp.serverCount = mcpConfig.serverCount;
       state.components.mcp.version = mcpConfig.version;
@@ -121,14 +117,45 @@ export class StateDetector {
 
       // Check corruption
       state.corrupted = await this.checkCorruption(state);
-
-    } catch (error) {
+    } catch (_error) {
       state.corrupted = true;
     }
 
     return state;
   }
 
+  /**
+   * Check components based on target configuration
+   */
+  private async checkComponentsForTarget(target: Target, state: ProjectState): Promise<void> {
+    // Check agents using target's agentDir
+    await this.checkComponent('agents', target.config.agentDir, '*.md', state);
+
+    // Check rules based on target config
+    if (target.config.rulesFile) {
+      // Target has separate rules file (e.g., OpenCode's AGENTS.md)
+      await this.checkFileComponent('rules', target.config.rulesFile, state);
+      // Check output styles in rules file
+      state.components.outputStyles.installed = await this.checkOutputStylesInFile(
+        target.config.rulesFile
+      );
+    } else {
+      // Rules are included in agent files (e.g., Claude Code)
+      state.components.rules.installed = state.components.agents.installed;
+      state.components.rules.count = state.components.agents.count;
+      state.components.outputStyles.installed = state.components.agents.installed;
+    }
+
+    // Check hooks - look for hooks directory in configDir
+    const hooksDir = path.join(target.config.configDir, 'hooks');
+    await this.checkComponent('hooks', hooksDir, '*.js', state);
+
+    // Check slash commands using target's slashCommandsDir
+    if (target.config.slashCommandsDir) {
+      await this.checkComponent('slashCommands', target.config.slashCommandsDir, '*.md', state);
+    }
+  }
+
   recommendAction(state: ProjectState): RecommendedAction {
     if (!state.initialized) {
       return 'FULL_INIT';
@@ -142,8 +169,11 @@ export class StateDetector {
       return 'UPGRADE';
     }
 
-    if (state.targetVersion && state.targetLatestVersion &&
-        this.isVersionOutdated(state.targetVersion, state.targetLatestVersion)) {
+    if (
+      state.targetVersion &&
+      state.targetLatestVersion &&
+      this.isVersionOutdated(state.targetVersion, state.targetLatestVersion)
+    ) {
       return 'UPGRADE_TARGET';
     }
 
@@ -170,8 +200,11 @@ export class StateDetector {
       explanations.push('Run `bun dev:flow upgrade` to upgrade');
     }
 
-    if (state.targetVersion && state.targetLatestVersion &&
-        this.isVersionOutdated(state.targetVersion, state.targetLatestVersion)) {
+    if (
+      state.targetVersion &&
+      state.targetLatestVersion &&
+      this.isVersionOutdated(state.targetVersion, state.targetLatestVersion)
+    ) {
       explanations.push(`${state.target} update available`);
       explanations.push(`Run \`bun dev:flow upgrade-target\` to upgrade`);
     }
@@ -210,7 +243,10 @@ export class StateDetector {
   ): Promise<void> {
     try {
       const fullPath = path.join(this.projectPath, componentPath);
-      const exists = await fs.access(fullPath).then(() => true).catch(() => false);
+      const exists = await fs
+        .access(fullPath)
+        .then(() => true)
+        .catch(() => false);
 
       if (!exists) {
         state.components[componentName].installed = false;
@@ -219,19 +255,30 @@ export class StateDetector {
 
       // 计算文件数量
       const files = await fs.readdir(fullPath).catch(() => []);
-      const count = pattern === '*.js' ? files.filter(f => f.endsWith('.js')).length :
-                   pattern === '*.md' ? files.filter(f => f.endsWith('.md')).length : files.length;
+      const count =
+        pattern === '*.js'
+          ? files.filter((f) => f.endsWith('.js')).length
+          : pattern === '*.md'
+            ? files.filter((f) => f.endsWith('.md')).length
+            : files.length;
 
       // Component is only installed if it has files
       state.components[componentName].installed = count > 0;
 
-      if (componentName === 'agents' || componentName === 'slashCommands' || componentName === 'rules') {
+      if (
+        componentName === 'agents' ||
+        componentName === 'slashCommands' ||
+        componentName === 'rules'
+      ) {
         state.components[componentName].count = count;
       }
 
       // 这里可以读取版本信息（如果保存了的话）
       const versionPath = path.join(fullPath, '.version');
-      const versionExists = await fs.access(versionPath).then(() => true).catch(() => false);
+      const versionExists = await fs
+        .access(versionPath)
+        .then(() => true)
+        .catch(() => false);
       if (versionExists) {
         state.components[componentName].version = await fs.readFile(versionPath, 'utf-8');
       }
@@ -247,7 +294,10 @@ export class StateDetector {
   ): Promise<void> {
     try {
       const fullPath = path.join(this.projectPath, filePath);
-      const exists = await fs.access(fullPath).then(() => true).catch(() => false);
+      const exists = await fs
+        .access(fullPath)
+        .then(() => true)
+        .catch(() => false);
 
       state.components[componentName].installed = exists;
 
@@ -260,53 +310,53 @@ export class StateDetector {
     }
   }
 
-  private async checkOutputStylesInAGENTS(): Promise<boolean> {
+  private async checkOutputStylesInFile(filePath: string): Promise<boolean> {
     try {
-      const agentsPath = path.join(this.projectPath, 'AGENTS.md');
-      const exists = await fs.access(agentsPath).then(() => true).catch(() => false);
+      const fullPath = path.join(this.projectPath, filePath);
+      const exists = await fs
+        .access(fullPath)
+        .then(() => true)
+        .catch(() => false);
 
       if (!exists) {
         return false;
       }
 
-      // Check if AGENTS.md contains output styles section
-      const content = await fs.readFile(agentsPath, 'utf-8');
+      // Check if file contains output styles section
+      const content = await fs.readFile(fullPath, 'utf-8');
       return content.includes('# Output Styles');
     } catch {
       return false;
     }
   }
 
-  private async checkMCPConfig(target?: string | null): Promise<{ exists: boolean; serverCount: number; version: string | null }> {
+  private async checkMCPConfig(
+    target?: Target | null
+  ): Promise<{ exists: boolean; serverCount: number; version: string | null }> {
     try {
-      let mcpPath: string;
-      let serversKey: string;
-
-      if (target === 'opencode') {
-        // OpenCode uses opencode.jsonc with mcp key
-        mcpPath = path.join(this.projectPath, 'opencode.jsonc');
-        serversKey = 'mcp';
-      } else {
-        // Claude Code uses .mcp.json with mcpServers key
-        mcpPath = path.join(this.projectPath, '.mcp.json');
-        serversKey = 'mcpServers';
+      if (!target) {
+        return { exists: false, serverCount: 0, version: null };
       }
 
-      const exists = await fs.access(mcpPath).then(() => true).catch(() => false);
+      // Use target config for MCP file path and servers key
+      const mcpPath = path.join(this.projectPath, target.config.configFile);
+      const serversKey = target.config.mcpConfigPath;
+
+      const exists = await fs
+        .access(mcpPath)
+        .then(() => true)
+        .catch(() => false);
 
       if (!exists) {
         return { exists: false, serverCount: 0, version: null };
       }
 
-      // Use proper JSONC parser for OpenCode (handles comments)
+      // Use target's readConfig method for proper parsing (handles JSONC, etc.)
       let content: any;
-      if (target === 'opencode') {
-        // Import dynamically to avoid circular dependency
-        const { fileUtils } = await import('../utils/target-utils.js');
-        const { opencodeTarget } = await import('../targets/opencode.js');
-        content = await fileUtils.readConfig(opencodeTarget.config, this.projectPath);
-      } else {
-        // Claude Code uses plain JSON
+      try {
+        content = await target.readConfig(this.projectPath);
+      } catch {
+        // Fallback to plain JSON parsing
         content = JSON.parse(await fs.readFile(mcpPath, 'utf-8'));
       }
 
@@ -322,19 +372,24 @@ export class StateDetector {
     }
   }
 
-  private async checkTargetVersion(target: string): Promise<{ version: string | null; latestVersion: string | null }> {
+  private async checkTargetVersion(
+    targetId: string
+  ): Promise<{ version: string | null; latestVersion: string | null }> {
     try {
-      // 这里可以检查目标平台的版本
-      // 例如检查 claude CLI 版本或 opencode 版本
-      if (target === 'claude-code') {
-        // 检查 claude --version
+      const target = this.resolveTarget(targetId);
+      if (!target) {
+        return { version: null, latestVersion: null };
+      }
+
+      // Check if target has executeCommand (CLI-based target)
+      // Only CLI targets like claude-code have version checking capability
+      if (target.executeCommand && target.id === 'claude-code') {
         const { exec } = await import('node:child_process');
         const { promisify } = await import('node:util');
         const execAsync = promisify(exec);
 
         try {
           const { stdout } = await execAsync('claude --version');
-          // 解析版本号
           const match = stdout.match(/v?(\d+\.\d+\.\d+)/);
           return {
             version: match ? match[1] : null,
@@ -366,14 +421,18 @@ export class StateDetector {
   }
 
   private async checkCorruption(state: ProjectState): Promise<boolean> {
-    // 检查是否存在矛盾的状态
+    // Check for contradictory states
     if (state.initialized && !state.target) {
-      return true; // 初始化咗但冇 target
+      return true; // Initialized but no target
     }
 
-    // 检查必需组件 - only check agents for claude-code
-    if (state.initialized && state.target === 'claude-code' && !state.components.agents.installed) {
-      return true; // claude-code 初始化咗但冇 agents
+    // Check required components based on target
+    if (state.initialized && state.target) {
+      const target = this.resolveTarget(state.target);
+      // CLI-based targets (category: 'cli') require agents to be installed
+      if (target && target.category === 'cli' && !state.components.agents.installed) {
+        return true; // CLI target initialized but no agents
+      }
     }
 
     return false;

package/src/core/template-loader.ts

@@ -1,13 +1,14 @@
 /**
  * Template Loader
  * Loads Flow templates from assets directory
- * Supports both claude-code and opencode targets
+ * Supports any target with consistent template structure
  */
 
+import { existsSync } from 'node:fs';
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { existsSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
+import type { Target } from '../types/target.types.js';
 import type { FlowTemplates } from './attach-manager.js';
 
 export class TemplateLoader {
@@ -24,7 +25,7 @@ export class TemplateLoader {
    * Load all templates for target
    * Uses flat assets directory structure (no target-specific subdirectories)
    */
-  async loadTemplates(target: 'claude-code' | 'opencode'): Promise<FlowTemplates> {
+  async loadTemplates(_target: Target | string): Promise<FlowTemplates> {
     const templates: FlowTemplates = {
       agents: [],
       commands: [],
@@ -77,14 +78,14 @@ export class TemplateLoader {
   /**
    * Load agents from directory
    */
-  private async loadAgents(
-    agentsDir: string
-  ): Promise<Array<{ name: string; content: string }>> {
+  private async loadAgents(agentsDir: string): Promise<Array<{ name: string; content: string }>> {
     const agents = [];
     const files = await fs.readdir(agentsDir);
 
     for (const file of files) {
-      if (!file.endsWith('.md')) continue;
+      if (!file.endsWith('.md')) {
+        continue;
+      }
 
       const content = await fs.readFile(path.join(agentsDir, file), 'utf-8');
       agents.push({ name: file, content });
@@ -103,7 +104,9 @@ export class TemplateLoader {
     const files = await fs.readdir(commandsDir);
 
     for (const file of files) {
-      if (!file.endsWith('.md')) continue;
+      if (!file.endsWith('.md')) {
+        continue;
+      }
 
       const content = await fs.readFile(path.join(commandsDir, file), 'utf-8');
       commands.push({ name: file, content });
@@ -115,9 +118,7 @@ export class TemplateLoader {
   /**
    * Load MCP servers configuration
    */
-  private async loadMCPServers(
-    configPath: string
-  ): Promise<Array<{ name: string; config: any }>> {
+  private async loadMCPServers(configPath: string): Promise<Array<{ name: string; config: any }>> {
     const data = await fs.readFile(configPath, 'utf-8');
     const config = JSON.parse(data);
 
@@ -129,25 +130,6 @@ export class TemplateLoader {
     return servers;
   }
 
-  /**
-   * Load hooks from directory
-   */
-  private async loadHooks(
-    hooksDir: string
-  ): Promise<Array<{ name: string; content: string }>> {
-    const hooks = [];
-    const files = await fs.readdir(hooksDir);
-
-    for (const file of files) {
-      if (!file.endsWith('.js')) continue;
-
-      const content = await fs.readFile(path.join(hooksDir, file), 'utf-8');
-      hooks.push({ name: file, content });
-    }
-
-    return hooks;
-  }
-
   /**
    * Load single files (CLAUDE.md, .cursorrules, etc.)
    */
@@ -180,7 +162,7 @@ export class TemplateLoader {
   /**
    * Check if templates exist (uses flat directory structure)
    */
-  async hasTemplates(target: 'claude-code' | 'opencode'): Promise<boolean> {
+  async hasTemplates(_target: Target | string): Promise<boolean> {
     // Check if any template directories exist
     const agentsDir = path.join(this.assetsDir, 'agents');
     const commandsDir = path.join(this.assetsDir, 'slash-commands');