config.yamlを読むように変更

sakastudio · sakastudio · commit e260b21a873c · 2025-07-04T19:06:33.000+09:00
diff --git a/.claude/settings.local.json b/.claude/settings.local.json
@@ -6,7 +6,6 @@
       "Bash(npm run dev:*)",
       "Bash(npm run tauri:build:*)",
       "Bash(npm run build:*)",
-      "Bash(npm:*)",
       "mcp__playwright__browser_navigate",
       "mcp__playwright__browser_click",
       "mcp__playwright__browser_snapshot",
@@ -22,9 +21,9 @@
       "Bash(npx c8 report:*)",
       "Bash(rg:*)",
       "Bash(npx tsc:*)",
-      "Bash(git add:*)"
-      "mcp__playwright__browser_take_screenshot"
-    ]
-  },
-  "enableAllProjectMcpServers": false
+      "Bash(git add:*)",
+      "mcp__playwright__browser_take_screenshot",
+    ],
+    "deny": []
+  }
 }
diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
@@ -12,7 +12,8 @@ import {
 } from './utils/fileSystem';
 import {
   loadSampleCommandsYaml,
-  loadSampleSkit
+  loadSampleSkit,
+  loadSampleConfig
 } from './utils/devFileSystem';
 import { Toaster } from 'sonner';
 import { DndProvider } from './components/dnd/DndProvider';
@@ -53,6 +54,9 @@ function App() {
           }
           
           try {
+            // 設定ファイルを読み込み、そこからcommands.yamlのパスを取得
+            await loadSampleConfig();
+            // 開発環境では設定に関係なく直接commands.yamlを読み込む
             const commandsYaml = await loadSampleCommandsYaml();
             loadCommandsYaml(commandsYaml);
           } catch (e) {
diff --git a/frontend/src/sample/commandForgeEditor.config.yml b/frontend/src/sample/commandForgeEditor.config.yml
@@ -0,0 +1,3 @@
+version: 1
+projectName: "Sample Project"
+commandsSchema: "commands2.yaml"
diff --git a/frontend/src/types/index.ts b/frontend/src/types/index.ts
@@ -64,3 +64,9 @@ export interface Skit {
   meta: SkitMeta;
   commands: SkitCommand[];
 }
+
+export interface CommandForgeConfig {
+  version: number;
+  projectName?: string;
+  commandsSchema: string;
+}
diff --git a/frontend/src/utils/configLoader.ts b/frontend/src/utils/configLoader.ts
@@ -0,0 +1,64 @@
+import { readTextFile, exists } from '@tauri-apps/api/fs';
+import { join } from '@tauri-apps/api/path';
+import { parse } from 'yaml';
+import Ajv from 'ajv';
+import { CommandForgeConfig } from '../types';
+
+const ajv = new Ajv();
+
+const configSchema = {
+  type: 'object',
+  required: ['version', 'commandsSchema'],
+  properties: {
+    version: { type: 'number' },
+    projectName: { type: 'string' },
+    commandsSchema: { type: 'string' }
+  }
+};
+
+const validateConfig = ajv.compile(configSchema);
+
+/**
+ * Loads and validates the commandForgeEditor.config.yml file
+ * @param projectPath The project path
+ * @returns Promise with the configuration
+ */
+export async function loadConfigFile(projectPath: string): Promise<CommandForgeConfig> {
+  try {
+    // Web環境の場合は例外をスロー
+    if (import.meta.env.DEV && typeof window !== 'undefined' && !((window as unknown) as { __TAURI__: unknown }).__TAURI__) {
+      throw new Error('Running in web environment, Tauri API not available');
+    }
+
+    const configPath = await join(projectPath, 'commandForgeEditor.config.yml');
+    
+    if (!(await exists(configPath))) {
+      throw new Error(`Configuration file not found at ${configPath}`);
+    }
+
+    const configContent = await readTextFile(configPath);
+    const config = parse(configContent) as CommandForgeConfig;
+
+    if (!validateConfig(config)) {
+      const errors = validateConfig.errors?.map(err => `${err.instancePath} ${err.message}`).join(', ');
+      throw new Error(`Invalid configuration: ${errors}`);
+    }
+
+    return config;
+  } catch (error) {
+    console.error('Failed to load configuration file:', error);
+    throw error;
+  }
+}
+
+/**
+ * Validates a configuration object
+ * @param config The configuration to validate
+ * @returns Array of validation errors, empty if valid
+ */
+export function validateCommandForgeConfig(config: unknown): string[] {
+  if (!validateConfig(config)) {
+    return validateConfig.errors?.map(err => `${err.instancePath} ${err.message}`) || ['Unknown validation error'];
+  }
+  return [];
+}
diff --git a/frontend/src/utils/devFileSystem.ts b/frontend/src/utils/devFileSystem.ts
@@ -1,4 +1,5 @@
-import { Skit } from '../types';
+import { Skit, CommandForgeConfig } from '../types';
+import { parse } from 'yaml';
 
 /**
  * 開発環境用: サンプルcommands.yamlファイルを読み込む
@@ -43,4 +44,27 @@ export async function loadSampleSkit(): Promise<Record<string, Skit>> {
     console.error('Failed to load sample-skit.json:', error);
     throw error;
   }
+}
+
+/**
+ * 開発環境用: サンプルcommandForgeEditor.config.ymlファイルを読み込む
+ * @returns Promise with the configuration
+ */
+export async function loadSampleConfig(): Promise<CommandForgeConfig> {
+  try {
+    console.log('Loading commandForgeEditor.config.yml for web environment');
+    
+    // Web環境でfetchを使用してファイルをロード
+    const response = await fetch('/src/sample/commandForgeEditor.config.yml');
+    if (!response.ok) {
+      throw new Error(`Failed to fetch commandForgeEditor.config.yml: ${response.status}`);
+    }
+    const content = await response.text();
+    const config = parse(content) as CommandForgeConfig;
+    console.log('Successfully loaded commandForgeEditor.config.yml');
+    return config;
+  } catch (error) {
+    console.error('Failed to load commandForgeEditor.config.yml:', error);
+    throw error;
+  }
 }
diff --git a/frontend/src/utils/fileSystem.test.ts b/frontend/src/utils/fileSystem.test.ts
@@ -11,12 +11,14 @@ import {
   createNewSkit
 } from './fileSystem';
 import * as validation from './validation';
+import * as configLoader from './configLoader';
 import { Skit } from '../types';
 
 vi.mock('@tauri-apps/api/fs');
 vi.mock('@tauri-apps/api/path');
 vi.mock('@tauri-apps/api/dialog');
 vi.mock('./validation');
+vi.mock('./configLoader');
 
 describe('fileSystem', () => {
   beforeEach(() => {
@@ -77,38 +79,37 @@ describe('fileSystem', () => {
 
   describe('loadCommandsYaml', () => {
     it('should load from project path when available', async () => {
+      vi.mocked(configLoader.loadConfigFile).mockResolvedValue({
+        version: 1,
+        commandsSchema: 'commands.yaml'
+      });
       vi.mocked(path.join).mockResolvedValue('/project/commands.yaml');
       vi.mocked(fs.exists).mockResolvedValue(true);
       vi.mocked(fs.readTextFile).mockResolvedValue('version: 1\ncommands: []');
 
       const result = await loadCommandsYaml('/project');
       expect(result).toBe('version: 1\ncommands: []');
+      expect(configLoader.loadConfigFile).toHaveBeenCalledWith('/project');
       expect(path.join).toHaveBeenCalledWith('/project', 'commands.yaml');
     });
 
-    it('should fall back to resource path when project path not found', async () => {
-      vi.mocked(path.join).mockResolvedValue('/project/commands.yaml');
-      vi.mocked(fs.exists).mockResolvedValue(false);
-      vi.mocked(path.resolveResource).mockResolvedValue('/resources/commands.yaml');
-      vi.mocked(fs.readTextFile).mockResolvedValue('default commands');
+    it('should fail when config file not found', async () => {
+      vi.mocked(configLoader.loadConfigFile).mockRejectedValue(
+        new Error('Configuration file not found')
+      );
 
-      const result = await loadCommandsYaml('/project');
-      expect(result).toBe('default commands');
-      expect(path.resolveResource).toHaveBeenCalledWith('commands.yaml');
+      await expect(loadCommandsYaml('/project')).rejects.toThrow('Configuration file not found');
+      expect(configLoader.loadConfigFile).toHaveBeenCalledWith('/project');
     });
 
-    it('should load from resource path when no project path', async () => {
-      vi.mocked(path.resolveResource).mockResolvedValue('/resources/commands.yaml');
-      vi.mocked(fs.readTextFile).mockResolvedValue('default commands');
-
-      const result = await loadCommandsYaml();
-      expect(result).toBe('default commands');
+    it('should throw error when no project path', async () => {
+      await expect(loadCommandsYaml()).rejects.toThrow('Project path is required to load commands.yaml');
     });
 
     it('should throw error on failure', async () => {
-      vi.mocked(path.resolveResource).mockRejectedValue(new Error('File not found'));
+      vi.mocked(configLoader.loadConfigFile).mockRejectedValue(new Error('File not found'));
 
-      await expect(loadCommandsYaml()).rejects.toThrow('File not found');
+      await expect(loadCommandsYaml('/project')).rejects.toThrow('File not found');
     });
 
     it('should throw error in web environment', async () => {
@@ -202,6 +203,11 @@ describe('fileSystem', () => {
     it('should apply default background colors from commands.yaml', async () => {
       const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
       
+      vi.mocked(configLoader.loadConfigFile).mockResolvedValue({
+        version: 1,
+        commandsSchema: 'commands.yaml'
+      });
+      
       vi.mocked(validation.validateCommandsYaml).mockReturnValue({
         config: {
           version: 1,
diff --git a/frontend/src/utils/fileSystem.ts b/frontend/src/utils/fileSystem.ts
@@ -3,6 +3,7 @@ import { join, resolveResource } from '@tauri-apps/api/path';
 import { open } from '@tauri-apps/api/dialog';
 import { Skit, CommandDefinition, SkitCommand } from '../types';
 import { validateSkitData, validateCommandsYaml } from './validation';
+import { loadConfigFile } from './configLoader';
 // 未使用のimportを削除
 
 /**
@@ -29,7 +30,7 @@ export async function selectProjectFolder(): Promise<string | null> {
 }
 
 /**
- * Loads commands.yaml file from either project path or resources
+ * Loads commands.yaml file based on configuration
  * @param projectPath Optional project path
  * @returns Promise with the commands.yaml content
  */
@@ -40,16 +41,20 @@ export async function loadCommandsYaml(projectPath: string | null = null): Promi
       throw new Error('Running in web environment, Tauri API not available');
     }
     
-    let commandsYamlPath;
+    if (!projectPath) {
+      throw new Error('Project path is required to load commands.yaml');
+    }
     
-    if (projectPath) {
-      commandsYamlPath = await join(projectPath, 'commands.yaml');
-      if (await exists(commandsYamlPath)) {
-        return await readTextFile(commandsYamlPath);
-      }
+    // Load configuration file first
+    const config = await loadConfigFile(projectPath);
+    
+    // Get commands.yaml path from config
+    const commandsYamlPath = await join(projectPath, config.commandsSchema);
+    
+    if (!(await exists(commandsYamlPath))) {
+      throw new Error(`Commands schema file not found at ${commandsYamlPath}`);
     }
     
-    commandsYamlPath = await resolveResource('commands.yaml');
     return await readTextFile(commandsYamlPath);
   } catch (error) {
     console.error('Failed to load commands.yaml:', error);
@@ -81,12 +86,12 @@ export async function loadSkits(projectPath: string | null = null): Promise<Reco
         return {}; // Return empty object since directory was just created
       }
       
-      return await loadSkitsFromPath(skitsPath);
+      return await loadSkitsFromPath(skitsPath, projectPath);
     }
     
     skitsPath = await resolveResource('skits');
     // as it should be part of the bundled resources
-    return await loadSkitsFromPath(skitsPath);
+    return await loadSkitsFromPath(skitsPath, null);
   } catch (error) {
     console.error('Failed to load skits:', error);
     return {}; // Return empty object on error instead of throwing
@@ -96,22 +101,36 @@ export async function loadSkits(projectPath: string | null = null): Promise<Reco
 /**
  * Helper function to load skits from a specific path
  * @param skitsPath Path to the skits directory
+ * @param projectPath Optional project path for loading config
  * @returns Promise with a record of skits
  */
-async function loadSkitsFromPath(skitsPath: string): Promise<Record<string, Skit>> {
+async function loadSkitsFromPath(skitsPath: string, projectPath: string | null): Promise<Record<string, Skit>> {
   try {
     const skitFiles = await readDir(skitsPath);
     const skits: Record<string, Skit> = {};
     
     // Load commands.yaml to get defaultBackgroundColor for each command type
     let commandsConfig;
     try {
-      const commandsYamlPath = await join(skitsPath, '../commands.yaml');
-      if (await exists(commandsYamlPath)) {
-        const commandsYaml = await readTextFile(commandsYamlPath);
-        const { validateCommandsYaml } = await import('./validation');
-        const { config } = validateCommandsYaml(commandsYaml);
-        commandsConfig = config;
+      if (projectPath) {
+        // Load config to get commands.yaml path
+        const config = await loadConfigFile(projectPath);
+        const commandsYamlPath = await join(projectPath, config.commandsSchema);
+        if (await exists(commandsYamlPath)) {
+          const commandsYaml = await readTextFile(commandsYamlPath);
+          const { validateCommandsYaml } = await import('./validation');
+          const { config: yamlConfig } = validateCommandsYaml(commandsYaml);
+          commandsConfig = yamlConfig;
+        }
+      } else {
+        // Fallback for bundled resources
+        const commandsYamlPath = await join(skitsPath, '../commands.yaml');
+        if (await exists(commandsYamlPath)) {
+          const commandsYaml = await readTextFile(commandsYamlPath);
+          const { validateCommandsYaml } = await import('./validation');
+          const { config: yamlConfig } = validateCommandsYaml(commandsYaml);
+          commandsConfig = yamlConfig;
+        }
       }
     } catch (error) {
       console.error('Failed to load commands.yaml for background colors:', error);

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+version: 1`
	`2`	`+projectName: "Sample Project"`
	`3`	`+commandsSchema: "commands2.yaml"`