@sk8metal/michi-cli 0.10.1 → 0.12.0

package/scripts/__tests__/create-project.test.ts

@@ -17,23 +17,23 @@ describe('create-project.ts パス問題', () => {
     vi.clearAllMocks();
   });
 
-  it('.cursor, .kiro, scripts が actualProjectDir にコピーされる', () => {
+  it('.claude, .kiro, scripts が actualProjectDir にコピーされる', () => {
     const projectDir = '/test/repo';
     const actualProjectDir = '/test/repo/projects/test-project';
 
-    // .cursor/rules のコピー先パスを検証
-    const cursorRulesPath = join(actualProjectDir, '.cursor/rules', 'test.mdc');
-    expect(cursorRulesPath).toContain('projects/test-project/.cursor/rules');
-    expect(cursorRulesPath).not.toContain(join(projectDir, '.cursor'));
+    // .claude/rules のコピー先パスを検証
+    const claudeRulesPath = join(actualProjectDir, '.claude/rules', 'test.mdc');
+    expect(claudeRulesPath).toContain('projects/test-project/.claude/rules');
+    expect(claudeRulesPath).not.toContain(join(projectDir, '.claude'));
 
-    // .cursor/commands のコピー先パスを検証
-    const cursorCommandsPath = join(
+    // .claude/commands のコピー先パスを検証
+    const claudeCommandsPath = join(
       actualProjectDir,
-      '.cursor/commands/kiro',
+      '.claude/commands',
       'test.md',
     );
-    expect(cursorCommandsPath).toContain(
-      'projects/test-project/.cursor/commands',
+    expect(claudeCommandsPath).toContain(
+      'projects/test-project/.claude/commands',
     );
 
     // .kiro/steering のコピー先パスを検証
@@ -63,8 +63,8 @@ describe('create-project.ts パス問題', () => {
     const actualProjectDir = '/test/repo/projects/test-project';
 
     const directories = [
-      join(actualProjectDir, '.cursor/rules'),
-      join(actualProjectDir, '.cursor/commands/kiro'),
+      join(actualProjectDir, '.claude/rules'),
+      join(actualProjectDir, '.claude/commands'),
       join(actualProjectDir, '.kiro/steering'),
       join(actualProjectDir, '.kiro/settings/templates'),
       join(actualProjectDir, 'scripts/utils'),

package/scripts/__tests__/setup-existing-project.test.ts

@@ -21,9 +21,9 @@ vi.mock('../utils/project-finder.js', () => ({
 }));
 vi.mock('../constants/environments.js', () => ({
   getEnvironmentConfig: vi.fn(() => ({
-    rulesDir: '.cursor/rules',
-    commandsDir: '.cursor/commands/kiro',
-    templateSource: 'cursor'
+    rulesDir: '.claude/rules',
+    commandsDir: '.claude/commands',
+    templateSource: 'claude'
   })),
   isSupportedEnvironment: vi.fn(() => true)
 }));
@@ -35,7 +35,7 @@ vi.mock('../template/renderer.js', () => ({
     LANG_CODE: 'ja',
     DEV_GUIDELINES: '- Think in English, but generate responses in Japanese',
     KIRO_DIR: '.kiro',
-    AGENT_DIR: '.cursor'
+    AGENT_DIR: '.claude'
   })),
   renderTemplate: vi.fn((content: string) => content)
 }));
@@ -143,18 +143,18 @@ ATLASSIAN_API_TOKEN=existing_token
 
   it('ディレクトリがコピー前に作成される', () => {
     const projectDir = '/test/repo/projects/test-project';
-    
-    // .cursor/rules ディレクトリの作成
-    const rulesDir = join(projectDir, '.cursor/rules');
+
+    // .claude/rules ディレクトリの作成
+    const rulesDir = join(projectDir, '.claude/rules');
     mkdirSync(rulesDir, { recursive: true });
-    
-    // .cursor/commands/kiro ディレクトリの作成
-    const commandsDir = join(projectDir, '.cursor/commands/kiro');
+
+    // .claude/commands ディレクトリの作成
+    const commandsDir = join(projectDir, '.claude/commands');
     mkdirSync(commandsDir, { recursive: true });
-    
+
     // ディレクトリが正しく作成されることを確認
-    expect(rulesDir).toContain('.cursor/rules');
-    expect(commandsDir).toContain('.cursor/commands/kiro');
+    expect(rulesDir).toContain('.claude/rules');
+    expect(commandsDir).toContain('.claude/commands');
   });
 
   it('パッケージ名が @sk8metal/michi-cli に統一されている', () => {
@@ -177,8 +177,8 @@ ATLASSIAN_API_TOKEN=existing_token
   it('完了メッセージに scripts/ ディレクトリが含まれていない', () => {
     const projectDir = '/test/repo/projects/test-project';
     const repoRoot = '/test/repo';
-    const envConfigRulesDir = '.cursor/rules';
-    const envConfigCommandsDir = '.cursor/commands/kiro';
+    const envConfigRulesDir = '.claude/rules';
+    const envConfigCommandsDir = '.claude/commands';
     
     // 実際に作成されるファイルのリスト（環境別）
     const createdFiles = [
@@ -217,14 +217,14 @@ ATLASSIAN_API_TOKEN=existing_token
 
   it('環境別のディレクトリマッピングが正しい', () => {
     const envConfig = {
-      rulesDir: '.cursor/rules',
-      commandsDir: '.cursor/commands/kiro',
-      templateSource: 'cursor'
+      rulesDir: '.claude/rules',
+      commandsDir: '.claude/commands',
+      templateSource: 'claude'
     };
 
-    expect(envConfig.rulesDir).toBe('.cursor/rules');
-    expect(envConfig.commandsDir).toBe('.cursor/commands/kiro');
-    expect(envConfig.templateSource).toBe('cursor');
+    expect(envConfig.rulesDir).toBe('.claude/rules');
+    expect(envConfig.commandsDir).toBe('.claude/commands');
+    expect(envConfig.templateSource).toBe('claude');
   });
 
   it('テンプレートコンテキストが正しく作成される', () => {
@@ -232,7 +232,7 @@ ATLASSIAN_API_TOKEN=existing_token
       LANG_CODE: 'ja',
       DEV_GUIDELINES: '- Think in English, but generate responses in Japanese',
       KIRO_DIR: '.kiro',
-      AGENT_DIR: '.cursor'
+      AGENT_DIR: '.claude'
     };
 
     expect(context).toHaveProperty('LANG_CODE');

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

@@ -13,10 +13,6 @@ describe('environments', () => {
     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', () => {
@@ -33,34 +29,6 @@ describe('environments', () => {
       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');
-      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];
@@ -81,14 +49,7 @@ describe('environments', () => {
     });
 
     it('should return config for all supported environments', () => {
-      const environments: Environment[] = [
-        'claude',
-        'claude-agent',
-        'cursor',
-        'gemini',
-        'codex',
-        'cline',
-      ];
+      const environments: Environment[] = ['claude', 'claude-agent'];
       for (const env of environments) {
         const config = getEnvironmentConfig(env);
         expect(config).toBeDefined();
@@ -101,20 +62,20 @@ describe('environments', () => {
     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);
+      expect(isSupportedEnvironment('cursor')).toBe(false);
+      expect(isSupportedEnvironment('gemini')).toBe(false);
+      expect(isSupportedEnvironment('codex')).toBe(false);
+      expect(isSupportedEnvironment('cline')).toBe(false);
     });
 
     it('should work as type guard', () => {
-      const env: string = 'cursor';
+      const env: string = 'claude';
       if (isSupportedEnvironment(env)) {
         // TypeScript should recognize env as Environment here
         const config: EnvironmentConfig = ENV_CONFIG[env];
@@ -126,13 +87,9 @@ describe('environments', () => {
   describe('getSupportedEnvironments', () => {
     it('should return all supported environments', () => {
       const environments = getSupportedEnvironments();
-      expect(environments).toHaveLength(6);
+      expect(environments).toHaveLength(2);
       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', () => {

package/scripts/constants/environments.ts

@@ -10,13 +10,7 @@ export interface EnvironmentConfig {
   templateSource: string;
 }
 
-export type Environment =
-  | 'claude'
-  | 'claude-agent'
-  | 'cursor'
-  | 'gemini'
-  | 'codex'
-  | 'cline';
+export type Environment = 'claude' | 'claude-agent';
 
 export const ENV_CONFIG: Record<Environment, EnvironmentConfig> = {
   claude: {
@@ -29,26 +23,6 @@ export const ENV_CONFIG: Record<Environment, EnvironmentConfig> = {
     commandsDir: '.claude/commands',
     templateSource: 'claude-agent',
   },
-  cursor: {
-    rulesDir: '.cursor/rules',
-    commandsDir: '.cursor/commands',
-    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',
-  },
 };
 
 /**

package/scripts/phase-runner.ts

@@ -229,7 +229,7 @@ async function checkTasksPrerequisites(
   const tasksPath = join(process.cwd(), '.kiro', 'specs', feature, 'tasks.md');
   if (!existsSync(tasksPath)) {
     errors.push(
-      'tasks.mdが存在しません。先に/kiro:spec-tasks を実行してください',
+      'tasks.mdが存在しません。先に/michi:spec-tasks を実行してください',
     );
     return { valid: false, errors };
   }

package/scripts/template/__tests__/renderer.test.ts

@@ -9,7 +9,7 @@ import {
 describe('renderer', () => {
   describe('createTemplateContext', () => {
     it('should create context with all required fields', () => {
-      const context = createTemplateContext('ja', '.kiro', '.cursor');
+      const context = createTemplateContext('ja', '.kiro', '.claude');
       
       expect(context).toHaveProperty('LANG_CODE');
       expect(context).toHaveProperty('DEV_GUIDELINES');
@@ -17,14 +17,14 @@ describe('renderer', () => {
       expect(context).toHaveProperty('AGENT_DIR');
       expect(context.LANG_CODE).toBe('ja');
       expect(context.KIRO_DIR).toBe('.kiro');
-      expect(context.AGENT_DIR).toBe('.cursor');
+      expect(context.AGENT_DIR).toBe('.claude');
     });
 
     it('should include language-specific guidelines', () => {
-      const contextJa = createTemplateContext('ja', '.kiro', '.cursor');
+      const contextJa = createTemplateContext('ja', '.kiro', '.claude');
       expect(contextJa.DEV_GUIDELINES).toContain('日本語');
       
-      const contextEn = createTemplateContext('en', '.kiro', '.cursor');
+      const contextEn = createTemplateContext('en', '.kiro', '.claude');
       expect(contextEn.DEV_GUIDELINES).toContain('English');
     });
   });
@@ -32,7 +32,7 @@ describe('renderer', () => {
   describe('renderTemplate', () => {
     it('should replace single placeholder', () => {
       const template = 'Language: {{LANG_CODE}}';
-      const context = createTemplateContext('ja', '.kiro', '.cursor');
+      const context = createTemplateContext('ja', '.kiro', '.claude');
       const result = renderTemplate(template, context);
       
       expect(result).toBe('Language: ja');
@@ -48,7 +48,7 @@ describe('renderer', () => {
 
     it('should replace same placeholder multiple times', () => {
       const template = '{{LANG_CODE}} is {{LANG_CODE}}';
-      const context = createTemplateContext('ja', '.kiro', '.cursor');
+      const context = createTemplateContext('ja', '.kiro', '.claude');
       const result = renderTemplate(template, context);
       
       expect(result).toBe('ja is ja');
@@ -56,7 +56,7 @@ describe('renderer', () => {
 
     it('should leave unknown placeholders unchanged', () => {
       const template = 'Known: {{LANG_CODE}}, Unknown: {{UNKNOWN}}';
-      const context = createTemplateContext('ja', '.kiro', '.cursor');
+      const context = createTemplateContext('ja', '.kiro', '.claude');
       const result = renderTemplate(template, context);
       
       expect(result).toBe('Known: ja, Unknown: {{UNKNOWN}}');
@@ -64,7 +64,7 @@ describe('renderer', () => {
 
     it('should handle DEV_GUIDELINES placeholder', () => {
       const template = '{{DEV_GUIDELINES}}';
-      const context = createTemplateContext('ja', '.kiro', '.cursor');
+      const context = createTemplateContext('ja', '.kiro', '.claude');
       const result = renderTemplate(template, context);
       
       expect(result).toContain('Think in English');
@@ -73,7 +73,7 @@ describe('renderer', () => {
 
     it('should handle empty template', () => {
       const template = '';
-      const context = createTemplateContext('ja', '.kiro', '.cursor');
+      const context = createTemplateContext('ja', '.kiro', '.claude');
       const result = renderTemplate(template, context);
       
       expect(result).toBe('');
@@ -81,7 +81,7 @@ describe('renderer', () => {
 
     it('should handle template with no placeholders', () => {
       const template = 'No placeholders here';
-      const context = createTemplateContext('ja', '.kiro', '.cursor');
+      const context = createTemplateContext('ja', '.kiro', '.claude');
       const result = renderTemplate(template, context);
       
       expect(result).toBe('No placeholders here');
@@ -91,19 +91,19 @@ describe('renderer', () => {
       const template = `Line 1: {{LANG_CODE}}
 Line 2: {{KIRO_DIR}}
 Line 3: {{AGENT_DIR}}`;
-      const context = createTemplateContext('en', '.kiro', '.cursor');
+      const context = createTemplateContext('en', '.kiro', '.claude');
       const result = renderTemplate(template, context);
       
       expect(result).toBe(`Line 1: en
 Line 2: .kiro
-Line 3: .cursor`);
+Line 3: .claude`);
     });
   });
 
   describe('renderJsonTemplate', () => {
     it('should render and parse JSON template', () => {
       const template = '{"lang": "{{LANG_CODE}}", "dir": "{{KIRO_DIR}}"}';
-      const context = createTemplateContext('ja', '.kiro', '.cursor');
+      const context = createTemplateContext('ja', '.kiro', '.claude');
       const result = renderJsonTemplate(template, context);
       
       expect(result).toEqual({ lang: 'ja', dir: '.kiro' });
@@ -126,22 +126,22 @@ Line 3: .cursor`);
 
     it('should handle JSON arrays', () => {
       const template = '["{{LANG_CODE}}", "{{KIRO_DIR}}", "{{AGENT_DIR}}"]';
-      const context = createTemplateContext('ja', '.kiro', '.cursor');
+      const context = createTemplateContext('ja', '.kiro', '.claude');
       const result = renderJsonTemplate(template, context);
       
-      expect(result).toEqual(['ja', '.kiro', '.cursor']);
+      expect(result).toEqual(['ja', '.kiro', '.claude']);
     });
 
     it('should throw on invalid JSON', () => {
       const template = 'invalid json {{LANG_CODE}}';
-      const context = createTemplateContext('ja', '.kiro', '.cursor');
+      const context = createTemplateContext('ja', '.kiro', '.claude');
       
       expect(() => renderJsonTemplate(template, context)).toThrow();
     });
 
     it('should throw with descriptive error for invalid JSON', () => {
       const template = '{"incomplete": {{LANG_CODE}}';
-      const context = createTemplateContext('ja', '.kiro', '.cursor');
+      const context = createTemplateContext('ja', '.kiro', '.claude');
       
       try {
         renderJsonTemplate(template, context);
@@ -162,7 +162,7 @@ Line 3: .cursor`);
 
     it('should preserve original error stack', () => {
       const template = '{invalid json}';
-      const context = createTemplateContext('en', '.kiro', '.cursor');
+      const context = createTemplateContext('en', '.kiro', '.claude');
       
       try {
         renderJsonTemplate(template, context);
@@ -184,19 +184,19 @@ Line 3: .cursor`);
         template2: 'Dir: {{KIRO_DIR}}',
         template3: 'Agent: {{AGENT_DIR}}'
       };
-      const context = createTemplateContext('ja', '.kiro', '.cursor');
+      const context = createTemplateContext('ja', '.kiro', '.claude');
       const results = renderTemplates(templates, context);
       
       expect(results).toEqual({
         template1: 'Lang: ja',
         template2: 'Dir: .kiro',
-        template3: 'Agent: .cursor'
+        template3: 'Agent: .claude'
       });
     });
 
     it('should handle empty templates object', () => {
       const templates = {};
-      const context = createTemplateContext('ja', '.kiro', '.cursor');
+      const context = createTemplateContext('ja', '.kiro', '.claude');
       const results = renderTemplates(templates, context);
       
       expect(results).toEqual({});

package/scripts/utils/__tests__/multi-repo-validator.test.ts

@@ -3,12 +3,19 @@
  * Task 1.2: バリデーション関数の実装
  */
 
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import {
   validateProjectName,
   validateJiraKey,
   validateRepositoryUrl,
+  hasMichiSetup,
+  getMichiSetupCommand,
+  validateLocalPath,
 } from '../multi-repo-validator';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import type { Repository } from '../../config/config-schema';
 
 describe('validateProjectName', () => {
   describe('正常ケース', () => {
@@ -333,3 +340,154 @@ describe('validateRepositoryUrl', () => {
     });
   });
 });
+
+describe('hasMichiSetup', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    // 一時ディレクトリを作成
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'michi-test-'));
+  });
+
+  afterEach(() => {
+    // 一時ディレクトリを削除
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('Michi導入済みの場合', () => {
+    it('.kiro/project.json が存在する場合はtrueを返す', () => {
+      // .kiro ディレクトリを作成
+      const kiroDir = path.join(tempDir, '.kiro');
+      fs.mkdirSync(kiroDir);
+
+      // project.json を作成
+      const projectJson = path.join(kiroDir, 'project.json');
+      fs.writeFileSync(projectJson, '{}');
+
+      const result = hasMichiSetup(tempDir);
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('Michi未導入の場合', () => {
+    it('.kiro/project.json が存在しない場合はfalseを返す', () => {
+      // .kiro ディレクトリのみ作成（project.jsonなし）
+      const kiroDir = path.join(tempDir, '.kiro');
+      fs.mkdirSync(kiroDir);
+
+      const result = hasMichiSetup(tempDir);
+      expect(result).toBe(false);
+    });
+
+    it('.kiro ディレクトリ自体が存在しない場合はfalseを返す', () => {
+      // .kiro ディレクトリを作成しない
+      const result = hasMichiSetup(tempDir);
+      expect(result).toBe(false);
+    });
+  });
+});
+
+describe('getMichiSetupCommand', () => {
+  it('正しいセットアップコマンドを生成する（シングルクォートでラップ）', () => {
+    const localPath = '/path/to/repo';
+    const command = getMichiSetupCommand(localPath);
+    expect(command).toBe(
+      "cd '/path/to/repo' && npx @sk8metal/michi-cli@latest init",
+    );
+  });
+
+  it('スペースを含むパスを正しくエスケープする', () => {
+    const localPath = '/path/to/my repo';
+    const command = getMichiSetupCommand(localPath);
+    expect(command).toBe(
+      "cd '/path/to/my repo' && npx @sk8metal/michi-cli@latest init",
+    );
+  });
+
+  it('シングルクォートを含むパスを正しくエスケープする', () => {
+    const localPath = "/path/to/user's repo";
+    const command = getMichiSetupCommand(localPath);
+    expect(command).toBe(
+      "cd '/path/to/user'\\''s repo' && npx @sk8metal/michi-cli@latest init",
+    );
+  });
+
+  it('複数のシングルクォートを含むパスを正しくエスケープする', () => {
+    const localPath = "/path/to/'test'/repo's/dir";
+    const command = getMichiSetupCommand(localPath);
+    expect(command).toBe(
+      "cd '/path/to/'\\''test'\\''/repo'\\''s/dir' && npx @sk8metal/michi-cli@latest init",
+    );
+  });
+
+  it('スペースとシングルクォート両方を含むパスを正しくエスケープする', () => {
+    const localPath = "/path/to/user's test repo";
+    const command = getMichiSetupCommand(localPath);
+    expect(command).toBe(
+      "cd '/path/to/user'\\''s test repo' && npx @sk8metal/michi-cli@latest init",
+    );
+  });
+});
+
+describe('validateLocalPath - Michi導入チェック', () => {
+  let tempDir: string;
+  let repository: Repository;
+
+  beforeEach(() => {
+    // 一時ディレクトリを作成
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'michi-test-'));
+
+    // リポジトリオブジェクトを作成
+    repository = {
+      name: 'test-repo',
+      url: 'https://github.com/test/repo',
+      branch: 'main',
+      localPath: tempDir,
+    };
+  });
+
+  afterEach(() => {
+    // 一時ディレクトリを削除
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('Michi導入済みリポジトリの場合、hasMichiSetupがtrueになる', () => {
+    // .git ディレクトリを作成（Gitリポジトリとして認識させる）
+    fs.mkdirSync(path.join(tempDir, '.git'));
+
+    // .kiro/project.json を作成（Michi導入済み）
+    const kiroDir = path.join(tempDir, '.kiro');
+    fs.mkdirSync(kiroDir);
+    fs.writeFileSync(path.join(kiroDir, 'project.json'), '{}');
+
+    const result = validateLocalPath(repository);
+    expect(result.hasMichiSetup).toBe(true);
+    expect(result.michiSetupCommand).toBeNull();
+  });
+
+  it('Michi未導入リポジトリの場合、hasMichiSetupがfalseになり警告が追加される', () => {
+    // .git ディレクトリを作成（Gitリポジトリとして認識させる）
+    fs.mkdirSync(path.join(tempDir, '.git'));
+
+    // .kiro/project.json は作成しない（Michi未導入）
+
+    const result = validateLocalPath(repository);
+    expect(result.hasMichiSetup).toBe(false);
+    expect(result.michiSetupCommand).not.toBeNull();
+    expect(result.warnings).toContain(
+      `Repository 'test-repo' does not have Michi setup (.kiro/project.json not found)`,
+    );
+  });
+
+  it('Gitリポジトリでない場合、hasMichiSetupはfalseでmichiSetupCommandはnull', () => {
+    // .git ディレクトリを作成しない（Gitリポジトリでない）
+
+    const result = validateLocalPath(repository);
+    expect(result.isValid).toBe(false);
+    expect(result.hasMichiSetup).toBe(false);
+    expect(result.michiSetupCommand).toBeNull();
+    expect(result.errors).toContain(
+      `localPath '${tempDir}' is not a Git repository (no .git directory)`,
+    );
+  });
+});