@sk8metal/michi-cli 0.0.7 → 0.0.9

package/scripts/__tests__/setup-interactive.test.ts

@@ -0,0 +1,199 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { basename } from 'path';
+
+// validateProjectId関数のロジックを再現
+function validateProjectId(projectId: string): boolean {
+  // 空文字、空白のみを拒否
+  if (!projectId.trim() || /^\s+$/.test(projectId)) {
+    return false;
+  }
+  // パストラバーサル文字を拒否
+  if (projectId.includes('..') || projectId.includes('/') || projectId.includes('\\')) {
+    return false;
+  }
+  // 許可する文字のみ（英数字、ハイフン、アンダースコア）
+  return /^[A-Za-z0-9_-]+$/.test(projectId);
+}
+
+describe('setup-interactive.ts 修正内容のテスト', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('validateProjectId の呼び出し', () => {
+    it('getProjectMetadata 内で validateProjectId が呼び出される', () => {
+      const projectIdDefault = 'test-project';
+      const projectId = projectIdDefault;
+      
+      // バリデーション（getProjectMetadata内のロジックを再現）
+      if (!validateProjectId(projectId)) {
+        throw new Error('無効なプロジェクトIDです。英数字、ハイフン、アンダースコアのみ使用できます。');
+      }
+      
+      // 有効なプロジェクトIDはエラーを投げない
+      expect(projectId).toBe('test-project');
+    });
+
+    it('無効なプロジェクトID（パストラバーサル）は拒否される', () => {
+      const invalidIds = ['../test', 'test/../', 'test\\..', '../../'];
+      
+      invalidIds.forEach(id => {
+        expect(validateProjectId(id)).toBe(false);
+      });
+    });
+
+    it('無効なプロジェクトID（特殊文字）は拒否される', () => {
+      const invalidIds = ['test@project', 'test#project', 'test$project', 'test project'];
+      
+      invalidIds.forEach(id => {
+        expect(validateProjectId(id)).toBe(false);
+      });
+    });
+
+    it('有効なプロジェクトIDは受け入れられる', () => {
+      const validIds = ['test-project', 'test_project', 'test123', 'Test-Project_123'];
+      
+      validIds.forEach(id => {
+        expect(validateProjectId(id)).toBe(true);
+      });
+    });
+  });
+
+  describe('main 関数の戻り値', () => {
+    it('main 関数は Promise<number> を返す', async () => {
+      // main関数のシグネチャを再現
+      async function main(): Promise<number> {
+        // 正常終了
+        return 0;
+      }
+      
+      const result = await main();
+      expect(typeof result).toBe('number');
+      expect(result).toBe(0);
+    });
+
+    it('エラー時は 1 を返す', async () => {
+      // main関数のエラーハンドリングを再現
+      async function main(): Promise<number> {
+        try {
+          throw new Error('テストエラー');
+        } catch (error) {
+          return 1;
+        }
+      }
+      
+      const result = await main();
+      expect(result).toBe(1);
+    });
+
+    it('早期終了時は 0 を返す', async () => {
+      // 早期終了のロジックを再現
+      async function main(): Promise<number> {
+        // 設定する項目がない場合
+        const configureProject = false;
+        const configureEnv = false;
+        
+        if (!configureProject && !configureEnv) {
+          return 0;
+        }
+        
+        return 0;
+      }
+      
+      const result = await main();
+      expect(result).toBe(0);
+    });
+  });
+
+  describe('process.exit の削除', () => {
+    it('process.exit の代わりに return を使用する', () => {
+      // 修正前: process.exit(0)
+      // 修正後: return 0
+      
+      function oldStyle(): void {
+        // process.exit(0); // 削除
+      }
+      
+      function newStyle(): number {
+        return 0; // 新しいスタイル
+      }
+      
+      const result = newStyle();
+      expect(result).toBe(0);
+      expect(typeof result).toBe('number');
+    });
+
+    it('エラー時も process.exit の代わりに return を使用する', () => {
+      // 修正前: process.exit(1)
+      // 修正後: return 1
+      
+      function oldStyle(): void {
+        // process.exit(1); // 削除
+      }
+      
+      function newStyle(): number {
+        return 1; // 新しいスタイル
+      }
+      
+      const result = newStyle();
+      expect(result).toBe(1);
+      expect(typeof result).toBe('number');
+    });
+  });
+
+  describe('CLIエントリーポイントでの process.exit 呼び出し', () => {
+    it('main() の戻り値を受け取って process.exit を呼び出す', async () => {
+      // CLIエントリーポイントのロジックを再現
+      let exitCode: number | null = null;
+      
+      const mockProcessExit = (code: number) => {
+        exitCode = code;
+      };
+      
+      async function main(): Promise<number> {
+        return 0;
+      }
+      
+      // CLIエントリーポイント
+      main()
+        .then(code => {
+          mockProcessExit(code);
+        })
+        .catch(() => {
+          mockProcessExit(1);
+        });
+      
+      // 非同期処理を待つ
+      await new Promise(resolve => setTimeout(resolve, 10));
+      
+      expect(exitCode).toBe(0);
+    });
+
+    it('エラー時は 1 で終了する', async () => {
+      let exitCode: number | null = null;
+      
+      const mockProcessExit = (code: number) => {
+        exitCode = code;
+      };
+      
+      async function main(): Promise<number> {
+        throw new Error('テストエラー');
+      }
+      
+      // CLIエントリーポイント
+      main()
+        .then(code => {
+          mockProcessExit(code);
+        })
+        .catch(() => {
+          mockProcessExit(1);
+        });
+      
+      // 非同期処理を待つ
+      await new Promise(resolve => setTimeout(resolve, 10));
+      
+      expect(exitCode).toBe(1);
+    });
+  });
+});
+

package/scripts/confluence-sync.ts

@@ -3,16 +3,16 @@
  * GitHub の Markdown ファイルを Confluence に同期
  */
 
-import { readFileSync, existsSync } from 'fs';
-import { resolve, join } from 'path';
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
 import axios from 'axios';
 import { config } from 'dotenv';
-import { loadProjectMeta, type ProjectMetadata } from './utils/project-meta.js';
-import { convertMarkdownToConfluence, createConfluencePage } from './markdown-to-confluence.js';
+import { loadProjectMeta } from './utils/project-meta.js';
 import { validateFeatureNameOrThrow } from './utils/feature-name-validator.js';
 import { getConfig, getConfigPath } from './utils/config-loader.js';
 import { createPagesByGranularity } from './utils/confluence-hierarchy.js';
 import { validateForConfluenceSync } from './utils/config-validator.js';
+import { updateSpecJsonAfterConfluenceSync, loadSpecJson } from './utils/spec-updater.js';
 
 // 環境変数読み込み
 config();
@@ -42,7 +42,7 @@ interface ConfluenceConfig {
 /**
  * Confluence設定を環境変数から取得
  */
-function getConfluenceConfig(): ConfluenceConfig {
+export function getConfluenceConfig(): ConfluenceConfig {
   const url = process.env.ATLASSIAN_URL;
   const email = process.env.ATLASSIAN_EMAIL;
   const apiToken = process.env.ATLASSIAN_API_TOKEN;
@@ -312,27 +312,6 @@ class ConfluenceClient {
   }
 }
 
-/**
- * spec.jsonを読み込む
- * @param featureName 機能名
- * @param projectRoot プロジェクトルート（デフォルト: process.cwd()）
- * @returns spec.jsonの内容、存在しない場合はnull
- */
-function loadSpecJson(featureName: string, projectRoot: string = process.cwd()): any | null {
-  const specPath = resolve(projectRoot, `.kiro/specs/${featureName}/spec.json`);
-  
-  if (!existsSync(specPath)) {
-    return null;
-  }
-  
-  try {
-    const content = readFileSync(specPath, 'utf-8');
-    return JSON.parse(content);
-  } catch (error) {
-    console.warn(`⚠️  Failed to load spec.json from ${specPath}: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    return null;
-  }
-}
 
 /**
  * Markdownファイルを Confluence に同期
@@ -408,7 +387,7 @@ async function syncToConfluence(
   let spaceKey: string;
   let spaceKeySource: string;
   
-  if (specJson?.confluence?.spaceKey) {
+  if (specJson.confluence?.spaceKey) {
     spaceKey = specJson.confluence.spaceKey;
     spaceKeySource = 'spec.json';
   } else if (confluenceConfig.spaces?.[docType]) {
@@ -444,14 +423,23 @@ async function syncToConfluence(
   
   const firstPageUrl = result.pages[0].url;
   console.log(`✅ Sync completed: ${result.pages.length} page(s) created/updated`);
-  
+
   if (result.pages.length > 1) {
     console.log('📄 Created pages:');
     result.pages.forEach((page, index) => {
       console.log(`   ${index + 1}. ${page.title} - ${page.url}`);
     });
   }
-  
+
+  // spec.json を更新
+  const firstPage = result.pages[0];
+  updateSpecJsonAfterConfluenceSync(featureName, docType, {
+    pageId: firstPage.id,
+    url: firstPage.url,
+    title: firstPage.title,
+    spaceKey: spaceKey
+  });
+
   return firstPageUrl;
 }
 

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

@@ -0,0 +1,110 @@
+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();
+    });
+
+    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/rules');
+      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 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'];
+      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);
+    });
+
+    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(3);
+      expect(environments).toContain('claude');
+      expect(environments).toContain('claude-agent');
+      expect(environments).toContain('cursor');
+    });
+
+    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,61 @@
+/**
+ * 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';
+
+export const ENV_CONFIG: Record<Environment, EnvironmentConfig> = {
+  'claude': {
+    rulesDir: '.claude/rules',
+    commandsDir: '.claude/commands/kiro',
+    templateSource: 'claude'
+  },
+  'claude-agent': {
+    rulesDir: '.claude/rules',
+    commandsDir: '.claude/commands/kiro',
+    templateSource: 'claude-agent'
+  },
+  'cursor': {
+    rulesDir: '.cursor/rules',
+    commandsDir: '.cursor/commands/kiro',
+    templateSource: 'cursor'
+  }
+};
+
+/**
+ * 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/copy-static-assets.js

@@ -0,0 +1,50 @@
+/**
+ * ビルド時に静的アセット（JSON等）をdistディレクトリにコピー
+ * tscはTypeScriptのトランスパイルのみで、JSONファイルは自動コピーされないため
+ */
+
+import { copyFileSync, mkdirSync, existsSync } from 'fs';
+import { dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const projectRoot = resolve(__dirname, '..');
+
+/**
+ * ファイルをコピーし、ディレクトリが存在しない場合は作成
+ */
+function copyFile(src, dest) {
+  const srcPath = resolve(projectRoot, src);
+  const destPath = resolve(projectRoot, dest);
+
+  if (!existsSync(srcPath)) {
+    console.error(`❌ Source file not found: ${srcPath}`);
+    process.exit(1);
+  }
+
+  // コピー先のディレクトリを作成
+  const destDir = dirname(destPath);
+  if (!existsSync(destDir)) {
+    mkdirSync(destDir, { recursive: true });
+  }
+
+  try {
+    copyFileSync(srcPath, destPath);
+    console.log(`✅ Copied: ${src} → ${dest}`);
+  } catch (error) {
+    console.error(`❌ Failed to copy ${src}:`, error.message);
+    process.exit(1);
+  }
+}
+
+// コピー対象のファイル一覧
+const filesToCopy = [
+  {
+    src: 'scripts/config/default-config.json',
+    dest: 'dist/scripts/config/default-config.json'
+  }
+];
+
+console.log('📦 Copying static assets...');
+filesToCopy.forEach(({ src, dest }) => copyFile(src, dest));
+console.log('✅ All static assets copied successfully.');