@sk8metal/michi-cli 0.0.8 → 0.1.0

package/scripts/constants/__tests__/environments.test.ts

@@ -0,0 +1,146 @@
+import { describe, it, expect } from 'vitest';
+import {
+  ENV_CONFIG,
+  getEnvironmentConfig,
+  isSupportedEnvironment,
+  getSupportedEnvironments,
+  type Environment,
+  type EnvironmentConfig,
+} from '../environments.js';
+
+describe('environments', () => {
+  describe('ENV_CONFIG', () => {
+    it('should have entries for all environments', () => {
+      expect(ENV_CONFIG.claude).toBeDefined();
+      expect(ENV_CONFIG['claude-agent']).toBeDefined();
+      expect(ENV_CONFIG.cursor).toBeDefined();
+      expect(ENV_CONFIG.gemini).toBeDefined();
+      expect(ENV_CONFIG.codex).toBeDefined();
+      expect(ENV_CONFIG.cline).toBeDefined();
+    });
+
+    it('should have correct structure for claude', () => {
+      const config = ENV_CONFIG.claude;
+      expect(config.rulesDir).toBe('.claude/rules');
+      expect(config.commandsDir).toBe('.claude/commands/kiro');
+      expect(config.templateSource).toBe('claude');
+    });
+
+    it('should have correct structure for claude-agent', () => {
+      const config = ENV_CONFIG['claude-agent'];
+      expect(config.rulesDir).toBe('.claude/agents');
+      expect(config.commandsDir).toBe('.claude/commands/kiro');
+      expect(config.templateSource).toBe('claude-agent');
+    });
+
+    it('should have correct structure for cursor', () => {
+      const config = ENV_CONFIG.cursor;
+      expect(config.rulesDir).toBe('.cursor/rules');
+      expect(config.commandsDir).toBe('.cursor/commands/kiro');
+      expect(config.templateSource).toBe('cursor');
+    });
+
+    it('should have correct structure for gemini', () => {
+      const config = ENV_CONFIG.gemini;
+      expect(config.rulesDir).toBe('.gemini');
+      expect(config.commandsDir).toBe('.gemini/extensions');
+      expect(config.templateSource).toBe('gemini');
+    });
+
+    it('should have correct structure for codex', () => {
+      const config = ENV_CONFIG.codex;
+      expect(config.rulesDir).toBe('.codex/docs');
+      expect(config.commandsDir).toBe('.codex/docs');
+      expect(config.templateSource).toBe('codex');
+    });
+
+    it('should have correct structure for cline', () => {
+      const config = ENV_CONFIG.cline;
+      expect(config.rulesDir).toBe('.clinerules/rules');
+      expect(config.commandsDir).toBe('.clinerules/commands');
+      expect(config.templateSource).toBe('cline');
+    });
+
+    it('should have all required properties for each environment', () => {
+      for (const env of Object.keys(ENV_CONFIG) as Environment[]) {
+        const config = ENV_CONFIG[env];
+        expect(config).toHaveProperty('rulesDir');
+        expect(config).toHaveProperty('commandsDir');
+        expect(config).toHaveProperty('templateSource');
+        expect(typeof config.rulesDir).toBe('string');
+        expect(typeof config.commandsDir).toBe('string');
+        expect(typeof config.templateSource).toBe('string');
+      }
+    });
+  });
+
+  describe('getEnvironmentConfig', () => {
+    it('should return config for valid environment', () => {
+      const config = getEnvironmentConfig('claude');
+      expect(config).toBe(ENV_CONFIG.claude);
+    });
+
+    it('should return config for all supported environments', () => {
+      const environments: Environment[] = [
+        'claude',
+        'claude-agent',
+        'cursor',
+        'gemini',
+        'codex',
+        'cline',
+      ];
+      for (const env of environments) {
+        const config = getEnvironmentConfig(env);
+        expect(config).toBeDefined();
+        expect(config).toBe(ENV_CONFIG[env]);
+      }
+    });
+  });
+
+  describe('isSupportedEnvironment', () => {
+    it('should return true for supported environments', () => {
+      expect(isSupportedEnvironment('claude')).toBe(true);
+      expect(isSupportedEnvironment('claude-agent')).toBe(true);
+      expect(isSupportedEnvironment('cursor')).toBe(true);
+      expect(isSupportedEnvironment('gemini')).toBe(true);
+      expect(isSupportedEnvironment('codex')).toBe(true);
+      expect(isSupportedEnvironment('cline')).toBe(true);
+    });
+
+    it('should return false for unsupported environments', () => {
+      expect(isSupportedEnvironment('invalid')).toBe(false);
+      expect(isSupportedEnvironment('vscode')).toBe(false);
+      expect(isSupportedEnvironment('')).toBe(false);
+    });
+
+    it('should work as type guard', () => {
+      const env: string = 'cursor';
+      if (isSupportedEnvironment(env)) {
+        // TypeScript should recognize env as Environment here
+        const config: EnvironmentConfig = ENV_CONFIG[env];
+        expect(config).toBeDefined();
+      }
+    });
+  });
+
+  describe('getSupportedEnvironments', () => {
+    it('should return all supported environments', () => {
+      const environments = getSupportedEnvironments();
+      expect(environments).toHaveLength(6);
+      expect(environments).toContain('claude');
+      expect(environments).toContain('claude-agent');
+      expect(environments).toContain('cursor');
+      expect(environments).toContain('gemini');
+      expect(environments).toContain('codex');
+      expect(environments).toContain('cline');
+    });
+
+    it('should return array with correct type', () => {
+      const environments = getSupportedEnvironments();
+      expect(Array.isArray(environments)).toBe(true);
+      environments.forEach((env) => {
+        expect(isSupportedEnvironment(env)).toBe(true);
+      });
+    });
+  });
+});

package/scripts/constants/__tests__/languages.test.ts

@@ -0,0 +1,100 @@
+import { describe, it, expect } from 'vitest';
+import {
+  supportedLanguages,
+  DEV_GUIDELINES_MAP,
+  getDevGuidelines,
+  isSupportedLanguage,
+  type SupportedLanguage
+} from '../languages.js';
+
+describe('languages', () => {
+  describe('supportedLanguages', () => {
+    it('should contain 12 languages', () => {
+      expect(supportedLanguages).toHaveLength(12);
+    });
+
+    it('should include expected languages', () => {
+      expect(supportedLanguages).toContain('ja');
+      expect(supportedLanguages).toContain('en');
+      expect(supportedLanguages).toContain('zh-TW');
+      expect(supportedLanguages).toContain('zh');
+      expect(supportedLanguages).toContain('es');
+      expect(supportedLanguages).toContain('pt');
+      expect(supportedLanguages).toContain('de');
+      expect(supportedLanguages).toContain('fr');
+      expect(supportedLanguages).toContain('ru');
+      expect(supportedLanguages).toContain('it');
+      expect(supportedLanguages).toContain('ko');
+      expect(supportedLanguages).toContain('ar');
+    });
+  });
+
+  describe('DEV_GUIDELINES_MAP', () => {
+    it('should have entries for all supported languages', () => {
+      for (const lang of supportedLanguages) {
+        expect(DEV_GUIDELINES_MAP[lang]).toBeDefined();
+        expect(DEV_GUIDELINES_MAP[lang]).not.toBe('');
+      }
+    });
+
+    it('should have English guideline', () => {
+      expect(DEV_GUIDELINES_MAP.en).toBe('- Think in English, generate responses in English');
+    });
+
+    it('should have Japanese guideline with bilingual instruction', () => {
+      expect(DEV_GUIDELINES_MAP.ja).toContain('Think in English');
+      expect(DEV_GUIDELINES_MAP.ja).toContain('日本語');
+    });
+
+    it('should contain bilingual instructions', () => {
+      // Most languages should mention "Think in English" in some form
+      const languagesWithEnglishInstruction = ['ja', 'en', 'es', 'pt', 'de', 'fr', 'ru', 'it', 'ko', 'ar'];
+      for (const lang of languagesWithEnglishInstruction) {
+        expect(DEV_GUIDELINES_MAP[lang as SupportedLanguage]).toContain('Think in English');
+      }
+      
+      // Chinese languages have their own format
+      expect(DEV_GUIDELINES_MAP['zh-TW']).toContain('以英文思考');
+      expect(DEV_GUIDELINES_MAP.zh).toContain('以英文思考');
+    });
+  });
+
+  describe('getDevGuidelines', () => {
+    it('should return guidelines for valid language', () => {
+      const guidelines = getDevGuidelines('ja');
+      expect(guidelines).toBe(DEV_GUIDELINES_MAP.ja);
+    });
+
+    it('should return guidelines for all supported languages', () => {
+      for (const lang of supportedLanguages) {
+        const guidelines = getDevGuidelines(lang);
+        expect(guidelines).toBeDefined();
+        expect(guidelines).toBe(DEV_GUIDELINES_MAP[lang]);
+      }
+    });
+  });
+
+  describe('isSupportedLanguage', () => {
+    it('should return true for supported languages', () => {
+      expect(isSupportedLanguage('ja')).toBe(true);
+      expect(isSupportedLanguage('en')).toBe(true);
+      expect(isSupportedLanguage('zh-TW')).toBe(true);
+    });
+
+    it('should return false for unsupported languages', () => {
+      expect(isSupportedLanguage('xx')).toBe(false);
+      expect(isSupportedLanguage('invalid')).toBe(false);
+      expect(isSupportedLanguage('')).toBe(false);
+    });
+
+    it('should work as type guard', () => {
+      const lang: string = 'ja';
+      if (isSupportedLanguage(lang)) {
+        // TypeScript should recognize lang as SupportedLanguage here
+        const guidelines: string = DEV_GUIDELINES_MAP[lang];
+        expect(guidelines).toBeDefined();
+      }
+    });
+  });
+});
+

package/scripts/constants/environments.ts

@@ -0,0 +1,81 @@
+/**
+ * Environment configuration mapping for cc-sdd environments
+ *
+ * Issue #37: 環境別コピー実装
+ */
+
+export interface EnvironmentConfig {
+  rulesDir: string;
+  commandsDir: string;
+  templateSource: string;
+}
+
+export type Environment =
+  | 'claude'
+  | 'claude-agent'
+  | 'cursor'
+  | 'gemini'
+  | 'codex'
+  | 'cline';
+
+export const ENV_CONFIG: Record<Environment, EnvironmentConfig> = {
+  claude: {
+    rulesDir: '.claude/rules',
+    commandsDir: '.claude/commands/kiro',
+    templateSource: 'claude',
+  },
+  'claude-agent': {
+    rulesDir: '.claude/agents',
+    commandsDir: '.claude/commands/kiro',
+    templateSource: 'claude-agent',
+  },
+  cursor: {
+    rulesDir: '.cursor/rules',
+    commandsDir: '.cursor/commands/kiro',
+    templateSource: 'cursor',
+  },
+  gemini: {
+    rulesDir: '.gemini',
+    commandsDir: '.gemini/extensions',
+    templateSource: 'gemini',
+  },
+  codex: {
+    rulesDir: '.codex/docs',
+    commandsDir: '.codex/docs',
+    templateSource: 'codex',
+  },
+  cline: {
+    rulesDir: '.clinerules/rules',
+    commandsDir: '.clinerules/commands',
+    templateSource: 'cline',
+  },
+};
+
+/**
+ * Get environment configuration
+ *
+ * @param env - Environment name
+ * @returns Environment configuration
+ */
+export const getEnvironmentConfig = (env: Environment): EnvironmentConfig => {
+  return ENV_CONFIG[env];
+};
+
+/**
+ * Validate if an environment is supported
+ *
+ * @param env - Environment name to validate
+ * @returns True if supported, false otherwise
+ */
+export const isSupportedEnvironment = (env: string): env is Environment => {
+  return env in ENV_CONFIG;
+};
+
+/**
+ * Get all supported environments
+ *
+ * @returns Array of supported environment names
+ */
+export const getSupportedEnvironments = (): Environment[] => {
+  return Object.keys(ENV_CONFIG) as Environment[];
+};

package/scripts/constants/languages.ts

@@ -0,0 +1,70 @@
+/**
+ * Supported languages and development guidelines map
+ * 
+ * Issue #37: 環境別コピー実装
+ */
+
+export const supportedLanguages = [
+  'ja', 'en', 'zh-TW', 'zh', 'es', 'pt', 
+  'de', 'fr', 'ru', 'it', 'ko', 'ar'
+] as const;
+
+export type SupportedLanguage = typeof supportedLanguages[number];
+
+export const DEV_GUIDELINES_MAP: Record<SupportedLanguage, string> = {
+  en: '- Think in English, generate responses in English',
+    
+  ja: '- Think in English, but generate responses in Japanese ' +
+        '(思考は英語、回答の生成は日本語で行うように)',
+    
+  'zh-TW': '- 以英文思考,但以繁體中文生成回應' +
+             '(Think in English, generate in Traditional Chinese)',
+    
+  zh: '- 以英文思考,但以简体中文生成回复' +
+        '(Think in English, generate in Simplified Chinese)',
+    
+  es: '- Think in English, generate responses in Spanish ' +
+        '(Piensa en inglés, genera respuestas en español)',
+    
+  pt: '- Think in English, generate responses in Portuguese ' +
+        '(Pense em inglês, gere respostas em português)',
+    
+  de: '- Think in English, generate responses in German ' +
+        '(Denke auf Englisch, formuliere Antworten auf Deutsch)',
+    
+  fr: '- Think in English, generate responses in French ' +
+        '(Pensez en anglais, générez des réponses en français)',
+    
+  ru: '- Think in English, generate responses in Russian ' +
+        '(Думай по-английски, отвечай по-русски)',
+    
+  it: '- Think in English, generate responses in Italian ' +
+        '(Pensa in inglese, genera risposte in italiano)',
+    
+  ko: '- Think in English, generate responses in Korean ' +
+        '(영어로 사고하고, 한국어로 응답을 생성하세요)',
+    
+  ar: '- Think in English, generate responses in Arabic ' +
+        '(فكر بالإنجليزية وأجب بالعربية)',
+};
+
+/**
+ * Get development guidelines for a specific language
+ * 
+ * @param lang - Language code
+ * @returns Development guidelines string
+ */
+export const getDevGuidelines = (lang: SupportedLanguage): string => {
+  return DEV_GUIDELINES_MAP[lang];
+};
+
+/**
+ * Validate if a language code is supported
+ * 
+ * @param lang - Language code to validate
+ * @returns True if supported, false otherwise
+ */
+export const isSupportedLanguage = (lang: string): lang is SupportedLanguage => {
+  return (supportedLanguages as readonly string[]).includes(lang);
+};
+

package/scripts/constants/test-commands.ts

@@ -0,0 +1,96 @@
+/**
+ * テストコマンド定数定義
+ *
+ * 各言語のテストコマンドをCI/CDテンプレートから取得
+ * Reference: templates/ci/github-actions/*.yml
+ */
+
+/**
+ * プロジェクト言語の型定義
+ */
+export type ProjectLanguage =
+  | 'Node.js/TypeScript'
+  | 'Java'
+  | 'PHP'
+  | 'Python'
+  | 'Go'
+  | 'Rust';
+
+/**
+ * テストコマンドの型定義
+ */
+export interface TestCommands {
+  test: string;
+  lint: string;
+  build: string;
+}
+
+/**
+ * 言語別テストコマンドマッピング
+ * CI/CDテンプレート（templates/ci/github-actions/*.yml）から取得
+ */
+export const TEST_COMMANDS_MAP: Record<ProjectLanguage, TestCommands> = {
+  'Node.js/TypeScript': {
+    test: 'npm test',
+    lint: 'npm run lint',
+    build: 'npm run build'
+  },
+  'Java': {
+    test: './gradlew test',
+    lint: './gradlew checkstyleMain checkstyleTest',
+    build: './gradlew build'
+  },
+  'PHP': {
+    test: 'composer test',
+    lint: 'composer phpstan',
+    build: 'composer install --no-dev --optimize-autoloader'
+  },
+  'Python': {
+    test: 'pytest',
+    lint: 'flake8 src tests',
+    build: 'python -m build'
+  },
+  'Go': {
+    test: 'go test ./...',
+    lint: 'golangci-lint run',
+    build: 'go build ./...'
+  },
+  'Rust': {
+    test: 'cargo test',
+    lint: 'cargo clippy -- -D warnings',
+    build: 'cargo build --release'
+  }
+};
+
+/**
+ * 言語に対応するテストコマンドを取得
+ *
+ * @param language - プロジェクト言語
+ * @returns テストコマンド一式
+ *
+ * @example
+ * getTestCommands('Java') // => { test: './gradlew test', ... }
+ * getTestCommands('Node.js') // => { test: 'npm test', ... } (部分一致)
+ * getTestCommands('Unknown') // => Node.js/TypeScript のコマンド (デフォルト)
+ */
+export function getTestCommands(language: string): TestCommands {
+  // 完全一致
+  if (language in TEST_COMMANDS_MAP) {
+    return TEST_COMMANDS_MAP[language as ProjectLanguage];
+  }
+
+  // 部分一致フォールバック（"Node.js" → "Node.js/TypeScript"）
+  const partialMatch = Object.keys(TEST_COMMANDS_MAP).find(key =>
+    key.toLowerCase().includes(language.toLowerCase()) ||
+    language.toLowerCase().includes(key.toLowerCase())
+  );
+
+  if (partialMatch) {
+    console.warn(`⚠️  言語 "${language}" は部分一致で "${partialMatch}" として扱います`);
+    return TEST_COMMANDS_MAP[partialMatch as ProjectLanguage];
+  }
+
+  // デフォルト: Node.js/TypeScript
+  console.warn(`⚠️  未知の言語 "${language}"。デフォルト（Node.js/TypeScript）を使用します`);
+  return TEST_COMMANDS_MAP['Node.js/TypeScript'];
+}

package/scripts/create-project.ts

@@ -2,6 +2,10 @@
 /**
  * 新規プロジェクト自動セットアップスクリプト
  * 
+ * Issue #35: cc-sdd準拠の多環境対応基盤
+ * - templates/ディレクトリから読み込み
+ * - プレースホルダーはそのまま（実行時にAIが解釈）
+ * 
  * 使い方:
  * npm run create-project -- \
  *   --name "20240115-payment-api" \
@@ -11,9 +15,10 @@
 
 import { execSync } from 'child_process';
 import { writeFileSync, mkdirSync, cpSync, existsSync } from 'fs';
-import { resolve, join, dirname } from 'path';
+import { resolve, join, dirname, basename } from 'path';
 import { fileURLToPath } from 'url';
 import { config as loadDotenv } from 'dotenv';
+import { findTemplateFile, validateRequiredTemplates } from './utils/template-finder.js';
 
 // ESモジュール対応: __dirnameの代替
 const __filename = fileURLToPath(import.meta.url);
@@ -203,46 +208,71 @@ async function createProject(config: ProjectConfig): Promise<void> {
     writeFileSync('.kiro/project.json', JSON.stringify(projectJson, null, 2));
     console.log('   ✅ project.json created');
 
-    // Step 8: Michiから共通ファイルをコピー
-    console.log('\n📋 Step 8: Copying common files from Michi...');
+    // Step 8: Michiから共通ファイルをコピー（templates/から）
+    console.log('\n📋 Step 8: Copying common files from Michi templates...');
+    console.log('   ℹ️  Issue #35: cc-sdd compliant approach (placeholders preserved)');
     const michiPath = resolve(__dirname, '..');
     
+    // 必須テンプレートのバリデーション
+    const requiredTemplates = [
+      'rules/github-ssot.mdc',
+      'rules/multi-project.mdc',
+      'commands/michi/confluence-sync.md',
+      'commands/michi/project-switch.md'
+    ];
+    
+    try {
+      validateRequiredTemplates(michiPath, requiredTemplates);
+    } catch (error) {
+      console.error('\n❌ Template validation failed:');
+      console.error(`   ${error instanceof Error ? error.message : String(error)}`);
+      process.exit(1);
+    }
+    
     // コピー先ディレクトリを事前に作成（actualProjectDir 配下に作成）
     console.log(`   📂 Copying to: ${actualProjectDir}`);
     mkdirSync(join(actualProjectDir, '.cursor/rules'), { recursive: true });
-    mkdirSync(join(actualProjectDir, '.cursor/commands/kiro'), { recursive: true });
+    mkdirSync(join(actualProjectDir, '.cursor/commands/michi'), { recursive: true });
     mkdirSync(join(actualProjectDir, '.kiro/steering'), { recursive: true });
     mkdirSync(join(actualProjectDir, '.kiro/settings/templates'), { recursive: true });
     mkdirSync(join(actualProjectDir, 'scripts/utils'), { recursive: true });
     
-    // ルールファイル
+    // ルールファイル（templates/から）
     const rulesToCopy = [
-      'multi-project.mdc',
-      'github-ssot.mdc',
-      'atlassian-mcp.mdc'
+      'rules/multi-project.mdc',
+      'rules/github-ssot.mdc',
+      'rules/atlassian-mcp.mdc'
     ];
     
-    for (const rule of rulesToCopy) {
-      const src = join(michiPath, '.cursor/rules', rule);
-      const dest = join(actualProjectDir, '.cursor/rules', rule);
-      if (existsSync(src)) {
+    for (const rulePath of rulesToCopy) {
+      const src = findTemplateFile(michiPath, rulePath);
+      const fileName = basename(rulePath);
+      const dest = join(actualProjectDir, '.cursor/rules', fileName);
+      
+      if (src) {
         cpSync(src, dest);
-        console.log(`   ✅ Copied: .cursor/rules/${rule}`);
+        console.log(`   ✅ Copied: .cursor/rules/${fileName} (from templates/)`);
+      } else {
+        console.log(`   ⚠️  ${fileName} not found in templates/`);
       }
     }
     
-    // カスタムコマンド
+    // カスタムコマンド（templates/から）
     const commandsToCopy = [
-      'confluence-sync.md',
-      'project-switch.md'
+      'commands/michi/confluence-sync.md',
+      'commands/michi/project-switch.md'
     ];
     
-    for (const cmd of commandsToCopy) {
-      const src = join(michiPath, '.cursor/commands/kiro', cmd);
-      const dest = join(actualProjectDir, '.cursor/commands/kiro', cmd);
-      if (existsSync(src)) {
+    for (const cmdPath of commandsToCopy) {
+      const src = findTemplateFile(michiPath, cmdPath);
+      const fileName = basename(cmdPath);
+      const dest = join(actualProjectDir, '.cursor/commands/michi', fileName);
+      
+      if (src) {
         cpSync(src, dest);
-        console.log(`   ✅ Copied: .cursor/commands/kiro/${cmd}`);
+        console.log(`   ✅ Copied: .cursor/commands/michi/${fileName} (from templates/)`);
+      } else {
+        console.log(`   ⚠️  ${fileName} not found in templates/`);
       }
     }
     
@@ -339,7 +369,7 @@ async function createProject(config: ProjectConfig): Promise<void> {
     console.log('  4. Cursor で開く: cursor .');
     console.log('  5. /kiro:spec-init <機能説明> で開発開始');
     console.log('');
-    console.log('詳細: docs/new-repository-setup.md');
+    console.log('詳細: docs/getting-started/new-repository-setup.md');
     
   } finally {
     // 元の作業ディレクトリに戻る