@sk8metal/michi-cli 0.0.7 → 0.0.9

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/__tests__/config-validator.test.ts

@@ -231,6 +231,12 @@ describe('config-validator', () => {
   });
 
   describe('validateForJiraSync', () => {
+    beforeEach(() => {
+      // 環境変数をクリア
+      delete process.env.JIRA_ISSUE_TYPE_STORY;
+      delete process.env.JIRA_ISSUE_TYPE_SUBTASK;
+    });
+
     it('issueTypes.story設定がない場合はエラー', () => {
       const configPath = join(testProjectRoot, '.michi/config.json');
       writeFileSync(configPath, JSON.stringify({

package/scripts/utils/__tests__/spec-updater.test.ts

@@ -0,0 +1,220 @@
+/**
+ * spec-updater のテスト
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, rmSync, existsSync, readFileSync, writeFileSync } from 'fs';
+import { resolve } from 'path';
+import {
+  loadSpecJson,
+  saveSpecJson,
+  updateSpecJsonAfterConfluenceSync,
+  updateSpecJsonAfterJiraSync,
+  type SpecJson
+} from '../spec-updater.js';
+
+const testDir = resolve(__dirname, '../../../.test-tmp');
+const testFeatureName = 'test-feature';
+
+describe('spec-updater', () => {
+  beforeEach(() => {
+    // テスト用ディレクトリを作成
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true });
+    }
+    mkdirSync(resolve(testDir, '.kiro/specs', testFeatureName), { recursive: true });
+  });
+
+  afterEach(() => {
+    // テスト用ディレクトリを削除
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true });
+    }
+  });
+
+  describe('loadSpecJson', () => {
+    it('spec.jsonが存在しない場合、最小限の構造を返す', () => {
+      const spec = loadSpecJson(testFeatureName, testDir);
+
+      expect(spec).toEqual({
+        featureName: testFeatureName,
+        confluence: {},
+        jira: {},
+        milestones: {}
+      });
+    });
+
+    it('spec.jsonが存在する場合、その内容を返す', () => {
+      const specPath = resolve(testDir, '.kiro/specs', testFeatureName, 'spec.json');
+      const testSpec: SpecJson = {
+        featureName: testFeatureName,
+        projectName: 'Test Project',
+        confluence: {
+          spaceKey: 'TEST'
+        },
+        jira: {},
+        milestones: {}
+      };
+
+      writeFileSync(specPath, JSON.stringify(testSpec, null, 2));
+
+      const spec = loadSpecJson(testFeatureName, testDir);
+      expect(spec).toEqual(testSpec);
+    });
+  });
+
+  describe('saveSpecJson', () => {
+    it('spec.jsonを保存し、lastUpdatedを追加する', () => {
+      const spec: SpecJson = {
+        featureName: testFeatureName,
+        confluence: {},
+        jira: {},
+        milestones: {}
+      };
+
+      saveSpecJson(testFeatureName, spec, testDir);
+
+      const specPath = resolve(testDir, '.kiro/specs', testFeatureName, 'spec.json');
+      expect(existsSync(specPath)).toBe(true);
+
+      const saved = JSON.parse(readFileSync(specPath, 'utf-8'));
+      expect(saved.featureName).toBe(testFeatureName);
+      expect(saved.lastUpdated).toBeDefined();
+    });
+  });
+
+  describe('updateSpecJsonAfterConfluenceSync', () => {
+    it('Confluence同期後にspec.jsonを正しく更新する（requirements）', () => {
+      updateSpecJsonAfterConfluenceSync(
+        testFeatureName,
+        'requirements',
+        {
+          pageId: 'page123',
+          url: 'https://example.atlassian.net/wiki/spaces/TEST/pages/page123',
+          title: 'Test Requirements',
+          spaceKey: 'TEST'
+        },
+        testDir
+      );
+
+      const spec = loadSpecJson(testFeatureName, testDir);
+
+      expect(spec.confluence?.spaceKey).toBe('TEST');
+      expect(spec.confluence?.requirements).toEqual({
+        pageId: 'page123',
+        url: 'https://example.atlassian.net/wiki/spaces/TEST/pages/page123',
+        title: 'Test Requirements'
+      });
+      expect(spec.milestones?.requirementsCompleted).toBe(true);
+    });
+
+    it('Confluence同期後にspec.jsonを正しく更新する（design）', () => {
+      updateSpecJsonAfterConfluenceSync(
+        testFeatureName,
+        'design',
+        {
+          pageId: 'page456',
+          url: 'https://example.atlassian.net/wiki/spaces/TEST/pages/page456',
+          title: 'Test Design',
+          spaceKey: 'TEST'
+        },
+        testDir
+      );
+
+      const spec = loadSpecJson(testFeatureName, testDir);
+
+      expect(spec.confluence?.design).toEqual({
+        pageId: 'page456',
+        url: 'https://example.atlassian.net/wiki/spaces/TEST/pages/page456',
+        title: 'Test Design'
+      });
+      expect(spec.milestones?.designCompleted).toBe(true);
+    });
+
+    it('Confluence同期後にspec.jsonを正しく更新する（tasks）', () => {
+      updateSpecJsonAfterConfluenceSync(
+        testFeatureName,
+        'tasks',
+        {
+          pageId: 'page789',
+          url: 'https://example.atlassian.net/wiki/spaces/TEST/pages/page789',
+          title: 'Test Tasks',
+          spaceKey: 'TEST'
+        },
+        testDir
+      );
+
+      const spec = loadSpecJson(testFeatureName, testDir);
+
+      expect(spec.confluence?.tasks).toEqual({
+        pageId: 'page789',
+        url: 'https://example.atlassian.net/wiki/spaces/TEST/pages/page789',
+        title: 'Test Tasks'
+      });
+      expect(spec.milestones?.tasksCompleted).toBe(true);
+    });
+  });
+
+  describe('updateSpecJsonAfterJiraSync', () => {
+    it('JIRA同期後にspec.jsonを正しく更新する', () => {
+      updateSpecJsonAfterJiraSync(
+        testFeatureName,
+        {
+          projectKey: 'TEST',
+          epicKey: 'TEST-123',
+          epicUrl: 'https://example.atlassian.net/browse/TEST-123',
+          storyKeys: ['TEST-124', 'TEST-125', 'TEST-126']
+        },
+        testDir
+      );
+
+      const spec = loadSpecJson(testFeatureName, testDir);
+
+      expect(spec.jira).toEqual({
+        projectKey: 'TEST',
+        epicKey: 'TEST-123',
+        epicUrl: 'https://example.atlassian.net/browse/TEST-123',
+        storyKeys: ['TEST-124', 'TEST-125', 'TEST-126']
+      });
+      expect(spec.milestones?.jiraSyncCompleted).toBe(true);
+    });
+  });
+
+  describe('統合シナリオ', () => {
+    it('Confluence → JIRA の順に同期した場合、両方の情報が保持される', () => {
+      // 1. Confluence 同期（requirements）
+      updateSpecJsonAfterConfluenceSync(
+        testFeatureName,
+        'requirements',
+        {
+          pageId: 'page123',
+          url: 'https://example.atlassian.net/wiki/spaces/TEST/pages/page123',
+          title: 'Test Requirements',
+          spaceKey: 'TEST'
+        },
+        testDir
+      );
+
+      // 2. JIRA 同期
+      updateSpecJsonAfterJiraSync(
+        testFeatureName,
+        {
+          projectKey: 'TEST',
+          epicKey: 'TEST-123',
+          epicUrl: 'https://example.atlassian.net/browse/TEST-123',
+          storyKeys: ['TEST-124']
+        },
+        testDir
+      );
+
+      // 両方の情報が保持されているか確認
+      const spec = loadSpecJson(testFeatureName, testDir);
+
+      expect(spec.confluence?.spaceKey).toBe('TEST');
+      expect(spec.confluence?.requirements).toBeDefined();
+      expect(spec.jira?.epicKey).toBe('TEST-123');
+      expect(spec.milestones?.requirementsCompleted).toBe(true);
+      expect(spec.milestones?.jiraSyncCompleted).toBe(true);
+    });
+  });
+});

package/scripts/utils/confluence-hierarchy.ts

@@ -14,8 +14,9 @@ import type { ConfluenceConfig, ConfluencePageCreationGranularity } from '../con
  * ページ作成結果
  */
 export interface PageCreationResult {
+  id: string;      // ページID（idとpageIdの両方をサポート）
+  pageId: string;  // ページID（後方互換性のため）
   url: string;
-  pageId: string;
   title: string;
 }
 
@@ -281,6 +282,7 @@ export async function createSinglePage(
   const baseUrl = process.env.ATLASSIAN_URL || '';
   return {
     pages: [{
+      id: page.id,
       url: `${baseUrl}/wiki${page._links.webui}`,
       pageId: page.id,
       title: pageTitle
@@ -351,6 +353,7 @@ export async function createBySectionPages(
     
     const baseUrl = process.env.ATLASSIAN_URL || '';
     pages.push({
+      id: page.id,
       url: `${baseUrl}/wiki${page._links.webui}`,
       pageId: page.id,
       title: pageTitle
@@ -474,6 +477,7 @@ export async function createByHierarchySimplePages(
   const baseUrl = process.env.ATLASSIAN_URL || '';
   return {
     pages: [{
+      id: childPage.id,
       url: `${baseUrl}/wiki${childPage._links.webui}`,
       pageId: childPage.id,
       title: childPageTitle
@@ -609,6 +613,7 @@ export async function createByHierarchyNestedPages(
     
     const baseUrl = process.env.ATLASSIAN_URL || '';
     pages.push({
+      id: sectionPage.id,
       url: `${baseUrl}/wiki${sectionPage._links.webui}`,
       pageId: sectionPage.id,
       title: sectionPageTitle
@@ -756,6 +761,7 @@ export async function createManualPages(
       
       const baseUrl = process.env.ATLASSIAN_URL || '';
       pages.push({
+        id: page.id,
         url: `${baseUrl}/wiki${page._links.webui}`,
         pageId: page.id,
         title: pageTitle