@sk8metal/michi-cli 0.0.8 → 0.0.9

package/scripts/setup-existing.sh

@@ -2,19 +2,143 @@
 #
 # 既存プロジェクトにMichiワークフローを追加（簡易版）
 #
+# ⚠️  非推奨: このスクリプトは非推奨です
+#    代わりに以下を使用してください:
+#    npx @sk8metal/michi-cli setup-existing --cursor --lang ja
+#
 # 使い方:
 #   cd /path/to/existing-repo
-#   bash /path/to/michi/scripts/setup-existing.sh
+#   bash /path/to/michi/scripts/setup-existing.sh [options]
+#
+# オプション:
+#   --claude        Claude Code環境を使用（デフォルト）
+#   --claude-agent  Claude Code Subagents環境を使用
+#   --cursor        Cursor IDE環境を使用
+#   --lang <code>   言語コード（デフォルト: ja）
+#   --help          ヘルプメッセージを表示
 #
 
 set -e
 
+# 非推奨警告を表示
+echo ""
+echo "⚠️  Warning: This script is deprecated."
+echo "   Please use: npx @sk8metal/michi-cli setup-existing --cursor --lang ja"
+echo ""
+echo "   Benefits of the new command:"
+echo "   - No git clone required"
+echo "   - Always uses the latest version"
+echo "   - Cross-platform support"
+echo "   - Templates included in NPM package"
+echo ""
+read -p "Continue with this deprecated script? [y/N]: " -n 1 -r
+echo
+if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+    echo "Cancelled. Please use: npx @sk8metal/michi-cli setup-existing"
+    exit 0
+fi
+echo ""
+
 # 色付きメッセージ
 GREEN='\033[0;32m'
 YELLOW='\033[1;33m'
 BLUE='\033[0;34m'
+RED='\033[0;31m'
 NC='\033[0m' # No Color
 
+# デフォルト値
+ENVIRONMENT="claude"
+LANG_CODE="ja"
+
+# v0.0.9 サポート環境
+SUPPORTED_ENVIRONMENTS=("claude" "claude-agent" "cursor")
+# v0.0.9 サポート言語
+SUPPORTED_LANGUAGES=("ja")
+
+# ヘルプメッセージを表示
+show_help() {
+  echo "Usage: bash setup-existing.sh [options]"
+  echo ""
+  echo "Options:"
+  echo "  --claude        Use Claude Code environment (default)"
+  echo "  --claude-agent  Use Claude Code Subagents environment"
+  echo "  --cursor        Use Cursor IDE environment"
+  echo "  --lang <code>   Language code (default: ja)"
+  echo "  --help          Show this help message"
+  echo ""
+  echo "Supported in v0.0.9:"
+  echo "  Environments: claude, claude-agent, cursor"
+  echo "  Languages: ja"
+  echo ""
+  echo "Examples:"
+  echo "  bash setup-existing.sh                      # Default (Claude Code, Japanese)"
+  echo "  bash setup-existing.sh --cursor             # Cursor IDE, Japanese"
+  echo "  bash setup-existing.sh --claude-agent --lang ja  # Claude Subagents, Japanese"
+}
+
+# 環境のバリデーション
+validate_environment() {
+  local env=$1
+  for supported in "${SUPPORTED_ENVIRONMENTS[@]}"; do
+    if [[ "$env" == "$supported" ]]; then
+      return 0
+    fi
+  done
+  
+  echo -e "${RED}❌ Error: Environment '${env}' is not yet supported in v0.0.9${NC}"
+  echo "Supported environments: ${SUPPORTED_ENVIRONMENTS[*]}"
+  exit 1
+}
+
+# 言語のバリデーション
+validate_language() {
+  local lang=$1
+  for supported in "${SUPPORTED_LANGUAGES[@]}"; do
+    if [[ "$lang" == "$supported" ]]; then
+      return 0
+    fi
+  done
+  
+  echo -e "${RED}❌ Error: Language '${lang}' is not yet supported in v0.0.9${NC}"
+  echo "Supported languages: ${SUPPORTED_LANGUAGES[*]}"
+  exit 1
+}
+
+# 引数解析
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --claude)
+      ENVIRONMENT="claude"
+      shift
+      ;;
+    --claude-agent)
+      ENVIRONMENT="claude-agent"
+      shift
+      ;;
+    --cursor)
+      ENVIRONMENT="cursor"
+      shift
+      ;;
+    --lang)
+      LANG_CODE="$2"
+      shift 2
+      ;;
+    --help)
+      show_help
+      exit 0
+      ;;
+    *)
+      echo -e "${RED}❌ Unknown option: $1${NC}"
+      echo "Run 'bash setup-existing.sh --help' for usage information."
+      exit 1
+      ;;
+  esac
+done
+
+# バリデーション
+validate_environment "$ENVIRONMENT"
+validate_language "$LANG_CODE"
+
 echo -e "${BLUE}🚀 既存プロジェクトにMichiワークフローを追加${NC}"
 echo ""
 
@@ -24,6 +148,8 @@ MICHI_PATH="$(cd "${SCRIPT_DIR}/.." && pwd)"
 
 echo -e "${BLUE}📂 Michiパス: ${MICHI_PATH}${NC}"
 echo -e "${BLUE}📂 現在のディレクトリ: $(pwd)${NC}"
+echo -e "${BLUE}🔧 環境: ${ENVIRONMENT}${NC}"
+echo -e "${BLUE}🌐 言語: ${LANG_CODE}${NC}"
 echo ""
 
 # プロジェクト情報を入力
@@ -74,7 +200,9 @@ echo -e "${BLUE}🔧 セットアップスクリプトを実行...${NC}"
 if ! npx tsx "${SETUP_SCRIPT}" \
   --michi-path "${MICHI_PATH}" \
   --project-name "${PROJECT_NAME}" \
-  --jira-key "${JIRA_KEY}"; then
+  --jira-key "${JIRA_KEY}" \
+  --environment "${ENVIRONMENT}" \
+  --lang "${LANG_CODE}"; then
   echo ""
   echo -e "${YELLOW}❌ セットアップスクリプトが失敗しました${NC}"
   exit 1
@@ -149,4 +277,3 @@ echo "   - クイックリファレンス: ${MICHI_PATH}/docs/quick-reference.md
 echo ""
 echo -e "${GREEN}✨ 準備完了！開発を始めましょう！${NC}"
 echo ""
-

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

@@ -0,0 +1,207 @@
+import { describe, it, expect } from 'vitest';
+import {
+  createTemplateContext,
+  renderTemplate,
+  renderJsonTemplate,
+  renderTemplates,
+  type TemplateContext
+} from '../renderer.js';
+
+describe('renderer', () => {
+  describe('createTemplateContext', () => {
+    it('should create context with all required fields', () => {
+      const context = createTemplateContext('ja', '.kiro', '.cursor');
+      
+      expect(context).toHaveProperty('LANG_CODE');
+      expect(context).toHaveProperty('DEV_GUIDELINES');
+      expect(context).toHaveProperty('KIRO_DIR');
+      expect(context).toHaveProperty('AGENT_DIR');
+      expect(context.LANG_CODE).toBe('ja');
+      expect(context.KIRO_DIR).toBe('.kiro');
+      expect(context.AGENT_DIR).toBe('.cursor');
+    });
+
+    it('should include language-specific guidelines', () => {
+      const contextJa = createTemplateContext('ja', '.kiro', '.cursor');
+      expect(contextJa.DEV_GUIDELINES).toContain('日本語');
+      
+      const contextEn = createTemplateContext('en', '.kiro', '.cursor');
+      expect(contextEn.DEV_GUIDELINES).toContain('English');
+    });
+  });
+
+  describe('renderTemplate', () => {
+    it('should replace single placeholder', () => {
+      const template = 'Language: {{LANG_CODE}}';
+      const context = createTemplateContext('ja', '.kiro', '.cursor');
+      const result = renderTemplate(template, context);
+      
+      expect(result).toBe('Language: ja');
+    });
+
+    it('should replace multiple placeholders', () => {
+      const template = 'Lang: {{LANG_CODE}}, Kiro: {{KIRO_DIR}}, Agent: {{AGENT_DIR}}';
+      const context = createTemplateContext('en', '.kiro', '.claude');
+      const result = renderTemplate(template, context);
+      
+      expect(result).toBe('Lang: en, Kiro: .kiro, Agent: .claude');
+    });
+
+    it('should replace same placeholder multiple times', () => {
+      const template = '{{LANG_CODE}} is {{LANG_CODE}}';
+      const context = createTemplateContext('ja', '.kiro', '.cursor');
+      const result = renderTemplate(template, context);
+      
+      expect(result).toBe('ja is ja');
+    });
+
+    it('should leave unknown placeholders unchanged', () => {
+      const template = 'Known: {{LANG_CODE}}, Unknown: {{UNKNOWN}}';
+      const context = createTemplateContext('ja', '.kiro', '.cursor');
+      const result = renderTemplate(template, context);
+      
+      expect(result).toBe('Known: ja, Unknown: {{UNKNOWN}}');
+    });
+
+    it('should handle DEV_GUIDELINES placeholder', () => {
+      const template = '{{DEV_GUIDELINES}}';
+      const context = createTemplateContext('ja', '.kiro', '.cursor');
+      const result = renderTemplate(template, context);
+      
+      expect(result).toContain('Think in English');
+      expect(result).toContain('日本語');
+    });
+
+    it('should handle empty template', () => {
+      const template = '';
+      const context = createTemplateContext('ja', '.kiro', '.cursor');
+      const result = renderTemplate(template, context);
+      
+      expect(result).toBe('');
+    });
+
+    it('should handle template with no placeholders', () => {
+      const template = 'No placeholders here';
+      const context = createTemplateContext('ja', '.kiro', '.cursor');
+      const result = renderTemplate(template, context);
+      
+      expect(result).toBe('No placeholders here');
+    });
+
+    it('should handle multiline template', () => {
+      const template = `Line 1: {{LANG_CODE}}
+Line 2: {{KIRO_DIR}}
+Line 3: {{AGENT_DIR}}`;
+      const context = createTemplateContext('en', '.kiro', '.cursor');
+      const result = renderTemplate(template, context);
+      
+      expect(result).toBe(`Line 1: en
+Line 2: .kiro
+Line 3: .cursor`);
+    });
+  });
+
+  describe('renderJsonTemplate', () => {
+    it('should render and parse JSON template', () => {
+      const template = '{"lang": "{{LANG_CODE}}", "dir": "{{KIRO_DIR}}"}';
+      const context = createTemplateContext('ja', '.kiro', '.cursor');
+      const result = renderJsonTemplate(template, context);
+      
+      expect(result).toEqual({ lang: 'ja', dir: '.kiro' });
+    });
+
+    it('should handle nested JSON', () => {
+      const template = '{"config": {"lang": "{{LANG_CODE}}", "paths": {"kiro": "{{KIRO_DIR}}"}}}';
+      const context = createTemplateContext('en', '.kiro', '.claude');
+      const result = renderJsonTemplate(template, context);
+      
+      expect(result).toEqual({
+        config: {
+          lang: 'en',
+          paths: {
+            kiro: '.kiro'
+          }
+        }
+      });
+    });
+
+    it('should handle JSON arrays', () => {
+      const template = '["{{LANG_CODE}}", "{{KIRO_DIR}}", "{{AGENT_DIR}}"]';
+      const context = createTemplateContext('ja', '.kiro', '.cursor');
+      const result = renderJsonTemplate(template, context);
+      
+      expect(result).toEqual(['ja', '.kiro', '.cursor']);
+    });
+
+    it('should throw on invalid JSON', () => {
+      const template = 'invalid json {{LANG_CODE}}';
+      const context = createTemplateContext('ja', '.kiro', '.cursor');
+      
+      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');
+      
+      try {
+        renderJsonTemplate(template, context);
+        expect.fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        const errorMessage = (error as Error).message;
+        
+        // Should contain descriptive information
+        expect(errorMessage).toContain('Failed to parse rendered JSON template');
+        expect(errorMessage).toContain('Original error:');
+        expect(errorMessage).toContain('Rendered output');
+        expect(errorMessage).toContain('Template context');
+        expect(errorMessage).toContain('LANG_CODE=ja');
+        expect(errorMessage).toContain('KIRO_DIR=.kiro');
+      }
+    });
+
+    it('should preserve original error stack', () => {
+      const template = '{invalid json}';
+      const context = createTemplateContext('en', '.kiro', '.cursor');
+      
+      try {
+        renderJsonTemplate(template, context);
+        expect.fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        const errorStack = (error as Error).stack;
+        
+        // Should contain original error stack
+        expect(errorStack).toContain('Original error stack:');
+      }
+    });
+  });
+
+  describe('renderTemplates', () => {
+    it('should render multiple templates', () => {
+      const templates = {
+        template1: 'Lang: {{LANG_CODE}}',
+        template2: 'Dir: {{KIRO_DIR}}',
+        template3: 'Agent: {{AGENT_DIR}}'
+      };
+      const context = createTemplateContext('ja', '.kiro', '.cursor');
+      const results = renderTemplates(templates, context);
+      
+      expect(results).toEqual({
+        template1: 'Lang: ja',
+        template2: 'Dir: .kiro',
+        template3: 'Agent: .cursor'
+      });
+    });
+
+    it('should handle empty templates object', () => {
+      const templates = {};
+      const context = createTemplateContext('ja', '.kiro', '.cursor');
+      const results = renderTemplates(templates, context);
+      
+      expect(results).toEqual({});
+    });
+  });
+});
+

package/scripts/template/renderer.ts

@@ -0,0 +1,133 @@
+/**
+ * Template renderer with placeholder replacement
+ * 
+ * Issue #37: 環境別コピー実装
+ */
+
+import { SupportedLanguage, getDevGuidelines } from '../constants/languages.js';
+
+export interface TemplateContext {
+  LANG_CODE: SupportedLanguage;
+  DEV_GUIDELINES: string;
+  KIRO_DIR: string;
+  AGENT_DIR: string;
+  PROJECT_ID?: string;
+  FEATURE_NAME?: string;
+  TIMESTAMP?: string;
+}
+
+/**
+ * Create template context for rendering
+ * 
+ * @param lang - Language code
+ * @param kiroDir - .kiro directory name
+ * @param agentDir - Agent directory name (e.g., .cursor, .claude)
+ * @returns Template context object
+ */
+export const createTemplateContext = (
+  lang: SupportedLanguage,
+  kiroDir: string,
+  agentDir: string
+): TemplateContext => ({
+  LANG_CODE: lang,
+  DEV_GUIDELINES: getDevGuidelines(lang),
+  KIRO_DIR: kiroDir,
+  AGENT_DIR: agentDir,
+});
+
+/**
+ * Render template with placeholder replacement
+ * 
+ * Replaces {{KEY}} patterns with values from context
+ * 
+ * @param template - Template string with {{PLACEHOLDER}} patterns
+ * @param context - Template context with replacement values
+ * @returns Rendered template string
+ * 
+ * @example
+ * ```typescript
+ * const template = "Hello {{NAME}}, welcome to {{PLACE}}!";
+ * const context = { NAME: "Alice", PLACE: "Wonderland" };
+ * const result = renderTemplate(template, context);
+ * // Result: "Hello Alice, welcome to Wonderland!"
+ * ```
+ */
+export const renderTemplate = (
+  template: string,
+  context: TemplateContext
+): string => {
+  return template.replace(/\{\{([A-Z_]+)\}\}/g, (match, key) => {
+    const value = context[key as keyof TemplateContext];
+    return value !== undefined ? String(value) : match;
+  });
+};
+
+/**
+ * Render JSON template with placeholder replacement
+ * 
+ * Parses the template as JSON after placeholder replacement
+ * 
+ * @param template - JSON template string with {{PLACEHOLDER}} patterns
+ * @param context - Template context with replacement values
+ * @returns Parsed JSON object
+ * @throws {Error} If the rendered template is not valid JSON
+ * 
+ * @example
+ * ```typescript
+ * const template = '{"lang": "{{LANG_CODE}}", "dir": "{{KIRO_DIR}}"}';
+ * const context = { LANG_CODE: "ja", KIRO_DIR: ".kiro" };
+ * const result = renderJsonTemplate(template, context);
+ * // Result: { lang: "ja", dir: ".kiro" }
+ * ```
+ */
+export const renderJsonTemplate = <T = any>(
+  template: string,
+  context: TemplateContext
+): T => {
+  const rendered = renderTemplate(template, context);
+  
+  try {
+    return JSON.parse(rendered);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const errorStack = error instanceof Error ? error.stack : undefined;
+    
+    // Create descriptive error with context for debugging
+    const debugInfo = [
+      'Failed to parse rendered JSON template',
+      `Original error: ${errorMessage}`,
+      `Rendered output (first 500 chars): ${rendered.substring(0, 500)}${rendered.length > 500 ? '...' : ''}`,
+      `Template context: LANG_CODE=${context.LANG_CODE}, KIRO_DIR=${context.KIRO_DIR}, AGENT_DIR=${context.AGENT_DIR}`
+    ].join('\n');
+    
+    const detailedError = new Error(debugInfo);
+    
+    // Preserve original error stack for diagnostics
+    if (errorStack) {
+      detailedError.stack = `${detailedError.stack}\n\nOriginal error stack:\n${errorStack}`;
+    }
+    
+    throw detailedError;
+  }
+};
+
+/**
+ * Batch render multiple templates
+ * 
+ * @param templates - Map of template names to template strings
+ * @param context - Template context with replacement values
+ * @returns Map of template names to rendered strings
+ */
+export const renderTemplates = (
+  templates: Record<string, string>,
+  context: TemplateContext
+): Record<string, string> => {
+  const rendered: Record<string, string> = {};
+  
+  for (const [name, template] of Object.entries(templates)) {
+    rendered[name] = renderTemplate(template, context);
+  }
+  
+  return rendered;
+};
+

package/scripts/utils/template-finder.ts

@@ -0,0 +1,75 @@
+/**
+ * テンプレートファイル検索ユーティリティ
+ * 
+ * Issue #35: cc-sdd準拠のテンプレート検索
+ * Cursor/Claude両環境のテンプレートを優先順位付きで検索
+ */
+
+import { existsSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * templates/ディレクトリからファイルを検索
+ * 
+ * @param michiPath - Michiリポジトリのルートパス
+ * @param relativePath - templates/配下の相対パス（例: 'rules/github-ssot.mdc'）
+ * @returns 見つかったファイルの絶対パス、見つからない場合はnull
+ * 
+ * @example
+ * ```typescript
+ * const path = findTemplateFile('/path/to/michi', 'rules/github-ssot.mdc');
+ * // returns: '/path/to/michi/templates/cursor/rules/github-ssot.mdc'
+ * ```
+ */
+export function findTemplateFile(michiPath: string, relativePath: string): string | null {
+  // 優先順位1: templates/cursor/
+  const cursorPath = join(michiPath, 'templates/cursor', relativePath);
+  if (existsSync(cursorPath)) {
+    return cursorPath;
+  }
+  
+  // 優先順位2: templates/claude/
+  const claudePath = join(michiPath, 'templates/claude', relativePath);
+  if (existsSync(claudePath)) {
+    return claudePath;
+  }
+  
+  return null;
+}
+
+/**
+ * 必須テンプレートファイルのバリデーション
+ * 
+ * @param michiPath - Michiリポジトリのルートパス
+ * @param requiredFiles - 必須ファイルのリスト
+ * @throws Error - 必須ファイルが見つからない場合
+ * 
+ * @example
+ * ```typescript
+ * validateRequiredTemplates('/path/to/michi', [
+ *   'rules/github-ssot.mdc',
+ *   'commands/michi/confluence-sync.md'
+ * ]);
+ * ```
+ */
+export function validateRequiredTemplates(
+  michiPath: string,
+  requiredFiles: string[]
+): void {
+  const missingFiles: string[] = [];
+  
+  for (const file of requiredFiles) {
+    const path = findTemplateFile(michiPath, file);
+    if (!path) {
+      missingFiles.push(file);
+    }
+  }
+  
+  if (missingFiles.length > 0) {
+    throw new Error(
+      `Missing required template files:\n  - ${missingFiles.join('\n  - ')}\n\n` +
+      `Please check that Michi templates are properly installed at: ${michiPath}/templates/`
+    );
+  }
+}
+

package/templates/claude/commands/michi/confluence-sync.md

@@ -0,0 +1,38 @@
+---
+name: /michi:confluence-sync
+description: Sync specifications to Confluence
+---
+
+# Confluence Sync Command
+
+**Important**: Generate output in language specified in {{KIRO_DIR}}/project.json.
+
+## Usage
+
+```
+/michi:confluence-sync <feature_name>
+```
+
+**Parameters**:
+- `feature_name`: Feature name (e.g., user-auth, payment-api)
+
+## Execution Steps
+
+1. Read specifications from {{KIRO_DIR}}/specs/{{FEATURE_NAME}}/
+2. Load project metadata from {{KIRO_DIR}}/project.json
+3. Sync requirements.md to Confluence
+4. Sync design.md to Confluence
+5. Create/update Confluence pages with proper labels
+6. Link pages to JIRA Epic (if exists)
+
+## Language Handling
+
+- Read language from {{KIRO_DIR}}/project.json
+- Generate all output in the specified language
+- Use Confluence labels from project.json for page organization
+
+## Project Metadata
+
+- Project ID: {{PROJECT_ID}}
+- Kiro directory: {{KIRO_DIR}}
+- Agent directory: {{AGENT_DIR}}

package/templates/claude/commands/michi/project-switch.md

@@ -0,0 +1,36 @@
+---
+name: /michi:project-switch
+description: Switch between projects
+---
+
+# Project Switch Command
+
+**Important**: Generate output in language specified in {{KIRO_DIR}}/project.json.
+
+## Usage
+
+```
+/michi:project-switch <project_id>
+```
+
+**Parameters**:
+- `project_id`: Project ID (e.g., customer-a-service-1, michi)
+
+**Examples**:
+```
+/michi:project-switch michi
+/michi:project-switch customer-a-service-1
+```
+
+## Execution Steps
+
+1. Identify GitHub repository corresponding to project ID
+2. Clone locally (if not cloned) or checkout
+3. Load and display {{KIRO_DIR}}/project.json
+4. Display corresponding Confluence project page URL
+
+## Language Handling
+
+- Read language from {{KIRO_DIR}}/project.json
+- Generate all output in the specified language
+- Default to English if language field is missing

package/templates/claude/rules/atlassian-integration.md

@@ -0,0 +1,35 @@
+---
+title: Atlassian Integration
+description: Integration rules for Confluence and JIRA via MCP
+---
+
+# Atlassian Integration
+
+## Development Guidelines
+{{DEV_GUIDELINES}}
+
+## Language
+All generated documents should be in: **{{LANG_CODE}}**
+
+## MCP Integration
+
+### Confluence Sync
+- Sync specifications from {{KIRO_DIR}}/specs/ to Confluence
+- Use MCP server for Confluence operations
+- Project labels: Check {{KIRO_DIR}}/project.json
+
+### JIRA Sync
+- Create Epic and Stories from {{KIRO_DIR}}/specs/{{FEATURE_NAME}}/tasks.md
+- Use JIRA project key: {{PROJECT_ID}}
+- Link Confluence pages automatically
+
+## Project Metadata
+- Project ID: {{PROJECT_ID}}
+- Kiro directory: {{KIRO_DIR}}
+- Agent directory: {{AGENT_DIR}}
+
+## Workflow
+1. Create spec in {{KIRO_DIR}}/specs/{{FEATURE_NAME}}/
+2. Sync to Confluence via MCP
+3. Create JIRA Epic/Stories
+4. Link Confluence pages to JIRA