@sk8metal/michi-cli 0.4.0 → 0.7.0

package/scripts/template/multi-repo-renderer.ts

@@ -0,0 +1,172 @@
+/**
+ * Multi-Repo template renderer
+ *
+ * Provides template rendering functionality for Multi-Repo projects
+ */
+
+import { readFileSync } from 'fs';
+import { resolve, relative, isAbsolute } from 'path';
+import { renderTemplate, type TemplateContext } from './renderer.js';
+
+export interface MultiRepoTemplateContext {
+  PROJECT_NAME: string;
+  JIRA_KEY: string;
+  CONFLUENCE_SPACE: string;
+  CREATED_AT: string;
+}
+
+/**
+ * Create Multi-Repo template context
+ *
+ * @param projectName - Project name
+ * @param jiraKey - JIRA project key
+ * @param confluenceSpace - Confluence space key
+ * @param createdAt - Created timestamp (ISO 8601 format)
+ * @returns Multi-Repo template context
+ */
+export const createMultiRepoTemplateContext = (
+  projectName: string,
+  jiraKey: string,
+  confluenceSpace: string,
+  createdAt?: string
+): MultiRepoTemplateContext => ({
+  PROJECT_NAME: projectName,
+  JIRA_KEY: jiraKey,
+  CONFLUENCE_SPACE: confluenceSpace,
+  CREATED_AT: createdAt || new Date().toISOString(),
+});
+
+/**
+ * Load Multi-Repo template file
+ *
+ * Security: Path traversal prevention with three-layer validation:
+ * 1. Validate template name (no path separators)
+ * 2. Resolve absolute paths
+ * 3. Verify path containment
+ *
+ * @param templateName - Template name (e.g., "overview/requirements", "steering/multi-repo")
+ * @param projectRoot - Project root directory
+ * @returns Template content
+ * @throws {Error} If template file not found or path traversal detected
+ */
+export const loadMultiRepoTemplate = (
+  templateName: string,
+  projectRoot: string = process.cwd()
+): string => {
+  // Security Layer 1: Validate template name
+  // Reject path traversal characters (../, ..\, absolute paths)
+  if (templateName.includes('..') || templateName.includes('\\')) {
+    throw new Error(
+      `Invalid template name: ${templateName}\n` +
+      'Template name must not contain path traversal characters (\\, ..)'
+    );
+  }
+
+  // Security Layer 2: Resolve absolute paths
+  const templateDir = resolve(projectRoot, 'templates', 'multi-repo');
+  const templatePath = resolve(templateDir, `${templateName}.md`);
+
+  // Security Layer 3: Verify path containment
+  const relativePath = relative(templateDir, templatePath);
+  if (relativePath.startsWith('..') || isAbsolute(relativePath)) {
+    throw new Error(
+      `Invalid template path: ${templateName}\n` +
+      `Template path is outside template directory: ${templateDir}`
+    );
+  }
+
+  try {
+    return readFileSync(templatePath, 'utf-8');
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Multi-Repo template not found: ${templateName}.md\n` +
+      `Path: ${templatePath}\n` +
+      `Error: ${errorMessage}`
+    );
+  }
+};
+
+/**
+ * Render Multi-Repo template with placeholder replacement
+ *
+ * @param template - Template string
+ * @param context - Multi-Repo template context
+ * @returns Rendered template string
+ */
+export const renderMultiRepoTemplate = (
+  template: string,
+  context: MultiRepoTemplateContext
+): string => {
+  // Convert MultiRepoTemplateContext to TemplateContext
+  const templateContext: TemplateContext = {
+    LANG_CODE: 'ja', // Default language
+    DEV_GUIDELINES: '', // Not used for Multi-Repo templates
+    KIRO_DIR: '.kiro',
+    AGENT_DIR: '.claude',
+    PROJECT_NAME: context.PROJECT_NAME,
+    JIRA_KEY: context.JIRA_KEY,
+    CONFLUENCE_SPACE: context.CONFLUENCE_SPACE,
+    CREATED_AT: context.CREATED_AT,
+  };
+
+  return renderTemplate(template, templateContext);
+};
+
+/**
+ * Load and render Multi-Repo template
+ *
+ * @param templateName - Template name
+ * @param context - Multi-Repo template context
+ * @param projectRoot - Project root directory
+ * @returns Rendered template string
+ */
+export const loadAndRenderMultiRepoTemplate = (
+  templateName: string,
+  context: MultiRepoTemplateContext,
+  projectRoot: string = process.cwd()
+): string => {
+  const template = loadMultiRepoTemplate(templateName, projectRoot);
+  return renderMultiRepoTemplate(template, context);
+};
+
+/**
+ * Batch render multiple Multi-Repo templates
+ *
+ * @param templateNames - Array of template names
+ * @param context - Multi-Repo template context
+ * @param projectRoot - Project root directory
+ * @returns Map of template names to rendered strings
+ */
+export const renderMultiRepoTemplates = (
+  templateNames: string[],
+  context: MultiRepoTemplateContext,
+  projectRoot: string = process.cwd()
+): Record<string, string> => {
+  const rendered: Record<string, string> = {};
+
+  for (const templateName of templateNames) {
+    rendered[templateName] = loadAndRenderMultiRepoTemplate(
+      templateName,
+      context,
+      projectRoot
+    );
+  }
+
+  return rendered;
+};
+
+/**
+ * List of all Multi-Repo template names
+ */
+export const MULTI_REPO_TEMPLATES = [
+  'overview/requirements',
+  'overview/architecture',
+  'overview/sequence',
+  'steering/multi-repo',
+  'tests/strategy',
+  'docs/ci-status',
+  'docs/release-notes',
+] as const;
+
+export type MultiRepoTemplateName = typeof MULTI_REPO_TEMPLATES[number];

package/scripts/template/renderer.ts

@@ -14,6 +14,11 @@ export interface TemplateContext {
   PROJECT_ID?: string;
   FEATURE_NAME?: string;
   TIMESTAMP?: string;
+  // Multi-Repo specific placeholders
+  PROJECT_NAME?: string;
+  JIRA_KEY?: string;
+  CONFLUENCE_SPACE?: string;
+  CREATED_AT?: string;
 }
 
 /**

package/scripts/test-execution-generator.ts

@@ -6,6 +6,73 @@
 import { readFileSync, writeFileSync, existsSync, mkdirSync, chmodSync } from 'fs';
 import { join } from 'path';
 
+/**
+ * セキュリティ: URLバリデーション
+ * HTTP/HTTPS URLのみ許可、特殊文字やコマンドインジェクションを防ぐ
+ */
+function validateUrl(url: string): void {
+  // 基本的なURL形式チェック
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+      throw new Error(`Invalid protocol: ${parsed.protocol}. Only http: and https: are allowed.`);
+    }
+  } catch (_error) {
+    throw new Error(`Invalid URL format: ${url}`);
+  }
+
+  // コマンドインジェクション対策: 危険な文字を検出
+  const dangerousChars = /[;`$()&|<>]/;
+  if (dangerousChars.test(url)) {
+    throw new Error(`URL contains dangerous characters: ${url}`);
+  }
+}
+
+/**
+ * セキュリティ: Bash用文字列エスケープ
+ * シェルスクリプト内で安全に使用できる形式にエスケープ
+ */
+function escapeBash(str: string): string {
+  // シングルクォートで囲み、シングルクォート自体をエスケープ
+  return `'${str.replace(/'/g, '\'\\\'\'')}'`;
+}
+
+/**
+ * セキュリティ: Python用文字列エスケープ
+ * Pythonコード内で安全に使用できる形式にエスケープ
+ */
+function escapePython(str: string): string {
+  return str
+    .replace(/\\/g, '\\\\')  // バックスラッシュ
+    .replace(/"/g, '\\"')    // ダブルクォート
+    .replace(/\n/g, '\\n')   // 改行
+    .replace(/\r/g, '\\r')   // キャリッジリターン
+    .replace(/\t/g, '\\t');  // タブ
+}
+
+/**
+ * セキュリティ: Python識別子バリデーション
+ * Pythonのクラス名として有効な形式かチェック
+ */
+function validatePythonIdentifier(name: string): void {
+  // Python識別子のルール: 英字またはアンダースコアで始まり、英数字とアンダースコアのみ
+  const pythonIdentifierPattern = /^[A-Za-z_][A-Za-z0-9_]*$/;
+  if (!pythonIdentifierPattern.test(name)) {
+    throw new Error(`Invalid Python identifier: ${name}. Must start with letter or underscore, and contain only letters, numbers, and underscores.`);
+  }
+
+  // Pythonの予約語チェック
+  const pythonKeywords = [
+    'False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await',
+    'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except',
+    'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda',
+    'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'
+  ];
+  if (pythonKeywords.includes(name)) {
+    throw new Error(`Invalid Python identifier: ${name} is a reserved keyword.`);
+  }
+}
+
 /**
  * テスト実行ファイルの生成オプション
  */
@@ -151,28 +218,47 @@ function generateLocustFile(
   endpoint: { endpoint: string; method: string; baseUrl: string },
   perfReqs: { targetRps: string; targetResponseTime: string }
 ): string {
+  // セキュリティ: URLバリデーション
+  validateUrl(endpoint.baseUrl);
+
+  // セキュリティ: Pythonエスケープ
+  const escapedFeature = escapePython(feature);
+  const escapedEndpoint = escapePython(endpoint.endpoint);
+  const escapedMethod = escapePython(endpoint.method);
+  const escapedBaseUrl = escapePython(endpoint.baseUrl);
+  const escapedTargetRps = escapePython(perfReqs.targetRps);
+  const escapedTargetResponseTime = escapePython(perfReqs.targetResponseTime);
+
+  // セキュリティ: Pythonクラス名の生成と検証
+  let className = feature.replace(/[^a-zA-Z0-9]/g, '_');
+  // クラス名は大文字で始まる必要がある（Python慣例）
+  if (!/^[A-Z]/.test(className)) {
+    className = 'Test' + className.charAt(0).toUpperCase() + className.slice(1);
+  }
+  // Python識別子として有効かチェック
+  validatePythonIdentifier(className);
+
   const methodLower = endpoint.method.toLowerCase();
   const hasBody = ['post', 'put', 'patch'].includes(methodLower);
-  const className = feature.replace(/[^a-zA-Z0-9]/g, '');
 
   let taskCode = '';
   if (hasBody) {
     taskCode = `        self.client.${methodLower}(
-            "${endpoint.endpoint}",
+            "${escapedEndpoint}",
             json={},
             headers={"Content-Type": "application/json"}
         )`;
   } else {
-    taskCode = `        self.client.${methodLower}("${endpoint.endpoint}")`;
+    taskCode = `        self.client.${methodLower}("${escapedEndpoint}")`;
   }
 
   return `"""
-${feature} 負荷テスト
-自動生成: michi phase:run ${feature} phase-b
+${escapedFeature} 負荷テスト
+自動生成: michi phase:run ${escapedFeature} phase-b
 
 目標:
-- RPS: ${perfReqs.targetRps}
-- 応答時間: ${perfReqs.targetResponseTime}ms以内
+- RPS: ${escapedTargetRps}
+- 応答時間: ${escapedTargetResponseTime}ms以内
 """
 
 from locust import HttpUser, task, between
@@ -182,11 +268,11 @@ class ${className}User(HttpUser):
     """テスト対象ユーザーシミュレーション"""
 
     wait_time = between(1, 3)
-    host = "${endpoint.baseUrl}"
+    host = "${escapedBaseUrl}"
 
     @task
     def test_endpoint(self):
-        """${endpoint.endpoint}への${endpoint.method}リクエスト"""
+        """${escapedEndpoint}への${escapedMethod}リクエスト"""
 ${taskCode}
 
 
@@ -369,14 +455,21 @@ function generateZapScript(
   feature: string,
   endpoint: { baseUrl: string }
 ): string {
+  // セキュリティ: URLバリデーション（コマンドインジェクション対策）
+  validateUrl(endpoint.baseUrl);
+
+  // セキュリティ: Bashエスケープ（追加の防御層）
+  const escapedUrl = escapeBash(endpoint.baseUrl);
+  const escapedFeature = escapeBash(feature);
+
   return `#!/bin/bash
 # OWASP ZAPセキュリティスキャン実行スクリプト
-# 自動生成: michi phase:run ${feature} phase-b
+# 自動生成: michi phase:run ${escapedFeature} phase-b
 
 set -e
 
 # 変数定義
-TARGET_URL="${endpoint.baseUrl}"
+TARGET_URL=${escapedUrl}
 CONFIG_FILE="zap-config.yaml"
 REPORT_DIR="./reports"
 

package/scripts/test-script-runner.ts

@@ -0,0 +1,130 @@
+/**
+ * テストスクリプトランナー
+ * Multi-Repoプロジェクトのテストスクリプトを実行
+ */
+
+import { execSync } from 'child_process';
+import { join } from 'path';
+
+/**
+ * テストタイプ
+ */
+export type TestType = 'e2e' | 'integration' | 'performance';
+
+/**
+ * テスト実行結果
+ */
+export interface TestExecutionResult {
+  success: boolean;
+  exitCode: number;
+  executionTime: number; // 秒単位
+  outputPath: string;
+  error?: string;
+}
+
+/**
+ * execSync実行時のエラー型
+ */
+interface ExecError extends Error {
+  status?: number;
+  stderr?: Buffer | string;
+}
+
+/**
+ * テストスクリプトランナー
+ */
+export class TestScriptRunner {
+  /**
+   * テストスクリプトを実行
+   *
+   * @param projectName プロジェクト名
+   * @param testType テストタイプ (e2e | integration | performance)
+   * @param projectRoot プロジェクトルートディレクトリ（デフォルト: process.cwd()）
+   * @returns テスト実行結果
+   */
+  async runTestScript(
+    projectName: string,
+    testType: TestType,
+    projectRoot: string = process.cwd()
+  ): Promise<TestExecutionResult> {
+    // 1. テストスクリプトパスを生成
+    const scriptPath = join(
+      projectRoot,
+      'docs',
+      'michi',
+      projectName,
+      'tests',
+      'scripts',
+      `run-${testType}.sh`
+    );
+
+    // 2. テスト結果の出力先パスを生成（スクリプト側で使用）
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('T')[0];
+    const outputPath = join(
+      projectRoot,
+      'docs',
+      'michi',
+      projectName,
+      'tests',
+      'results',
+      `${testType}-${timestamp}.log`
+    );
+
+    // 3. 実行前のログ出力
+    console.log('🚀 テストスクリプトを実行中...');
+    console.log(`  テストタイプ: ${testType}`);
+    console.log(`  スクリプトパス: ${scriptPath}`);
+    console.log(`  実行開始時刻: ${new Date().toLocaleString('ja-JP', { timeZone: 'Asia/Tokyo' })}`);
+
+    // 4. テストスクリプトを実行
+    const startTime = Date.now();
+    let exitCode = 0;
+    let error: string | undefined;
+
+    try {
+      execSync(scriptPath, {
+        stdio: 'inherit', // リアルタイム出力
+        encoding: 'utf-8',
+      });
+    } catch (err) {
+      // スクリプト実行エラー
+      const execError = err as ExecError;
+      exitCode = execError.status !== undefined ? execError.status : 1;
+      error = execError.message;
+
+      // stderrがある場合は追加
+      if (execError.stderr) {
+        const stderrStr = execError.stderr.toString();
+        error = stderrStr || error;
+      }
+    }
+
+    const endTime = Date.now();
+    const executionTime = (endTime - startTime) / 1000; // ミリ秒から秒に変換
+
+    // 5. 実行後のログ出力
+    console.log('\n📊 テスト実行結果:');
+    console.log(`  終了コード: ${exitCode}`);
+    console.log(`  実行時間: ${executionTime.toFixed(2)}秒`);
+    console.log(`  テスト結果ファイル: ${outputPath}`);
+
+    const success = exitCode === 0;
+
+    if (success) {
+      console.log('✅ テスト実行が成功しました');
+    } else {
+      console.log('❌ テスト実行が失敗しました');
+      if (error) {
+        console.log(`  エラー: ${error}`);
+      }
+    }
+
+    return {
+      success,
+      exitCode,
+      executionTime,
+      outputPath,
+      error,
+    };
+  }
+}

package/scripts/utils/__tests__/config-loader.test.ts

@@ -10,6 +10,7 @@ import {
   loadConfig,
   getConfig,
   getConfigPath,
+  getGlobalEnvPath,
   clearConfigCache
 } from '../config-loader.js';
 
@@ -32,6 +33,9 @@ describe('config-loader', () => {
     // 環境変数をバックアップ
     originalEnv = { ...process.env };
 
+    // HOMEディレクトリをテスト用に変更（グローバル設定の影響を排除）
+    process.env.HOME = testProjectRoot;
+
     // キャッシュをクリア（クリーンな状態から開始）
     clearConfigCache();
   });
@@ -250,5 +254,150 @@ describe('config-loader', () => {
       consoleWarnSpy.mockRestore();
     });
   });
+
+  describe('5層階層対応', () => {
+    describe('getGlobalEnvPath', () => {
+      it('~/.michi/.envのパスを返す', () => {
+        const envPath = getGlobalEnvPath();
+        expect(envPath).toBe(join(process.env.HOME as string, '.michi', '.env'));
+      });
+    });
+
+    describe('グローバル.envからの設定読み込み', () => {
+      it('グローバル.envからAtlassian設定を読み込む', () => {
+        clearConfigCache();
+
+        // ~/.michi/.env を作成
+        const globalEnvPath = join(testProjectRoot, '.michi', '.env');
+        writeFileSync(globalEnvPath, 'ATLASSIAN_URL=https://test.atlassian.net\n');
+
+        const config = loadConfig(testProjectRoot);
+
+        // グローバル.envの値が読み込まれることを確認
+        expect(config).toHaveProperty('atlassian');
+        // 注: 実装後に具体的なアサーションを追加
+      });
+
+      it('グローバル.envが存在しない場合でもエラーにならない', () => {
+        clearConfigCache();
+
+        // ~/.michi/.env を削除
+        const globalEnvPath = join(testProjectRoot, '.michi', '.env');
+        if (existsSync(globalEnvPath)) {
+          unlinkSync(globalEnvPath);
+        }
+
+        expect(() => {
+          loadConfig(testProjectRoot);
+        }).not.toThrow();
+      });
+    });
+
+    describe('project.jsonからの設定読み込み', () => {
+      it('project.jsonからプロジェクトメタデータを読み込む', () => {
+        clearConfigCache();
+
+        // .kiro/project.json を作成
+        const projectJsonPath = join(testProjectRoot, '.kiro', 'project.json');
+        mkdirSync(join(testProjectRoot, '.kiro'), { recursive: true });
+        writeFileSync(projectJsonPath, JSON.stringify({
+          projectId: 'test-project',
+          projectName: 'Test Project',
+          jiraProjectKey: 'TP'
+        }));
+
+        const config = loadConfig(testProjectRoot);
+
+        // project.jsonの値が読み込まれることを確認
+        expect(config).toHaveProperty('project');
+        // 注: 実装後に具体的なアサーションを追加
+      });
+
+      it('project.jsonが存在しない場合でもエラーにならない', () => {
+        clearConfigCache();
+
+        // .kiro/project.json を削除
+        const projectJsonPath = join(testProjectRoot, '.kiro', 'project.json');
+        if (existsSync(projectJsonPath)) {
+          unlinkSync(projectJsonPath);
+        }
+
+        expect(() => {
+          loadConfig(testProjectRoot);
+        }).not.toThrow();
+      });
+    });
+
+    describe('優先順位の検証', () => {
+      it('プロジェクト.envがグローバル.envより優先される', () => {
+        clearConfigCache();
+
+        // グローバル.env
+        const globalEnvPath = join(testProjectRoot, '.michi', '.env');
+        writeFileSync(globalEnvPath, 'CONFLUENCE_PRD_SPACE=GLOBAL\n');
+
+        // プロジェクト.env
+        const projectEnvPath = join(testProjectRoot, '.env');
+        writeFileSync(projectEnvPath, 'CONFLUENCE_PRD_SPACE=PROJECT\n');
+
+        const config = loadConfig(testProjectRoot);
+
+        // プロジェクト.envの値が優先されることを確認
+        expect(config.confluence?.spaces?.requirements).toBe('PROJECT');
+      });
+    });
+
+    describe('キャッシュ無効化', () => {
+      it('グローバル.envを変更するとキャッシュが無効化される', async () => {
+        clearConfigCache();
+
+        // 最初の設定
+        const globalEnvPath = join(testProjectRoot, '.michi', '.env');
+        writeFileSync(globalEnvPath, 'CONFLUENCE_PRD_SPACE=INITIAL\n');
+
+        const config1 = getConfig(testProjectRoot);
+
+        // ファイルシステムのmtime精度を考慮して少し待つ
+        await new Promise(resolve => setTimeout(resolve, 10));
+
+        // 設定を更新
+        writeFileSync(globalEnvPath, 'CONFLUENCE_PRD_SPACE=UPDATED\n');
+
+        const config2 = getConfig(testProjectRoot);
+
+        // 異なる値が返されることを確認（キャッシュが無効化された）
+        expect(config1.confluence?.spaces?.requirements).toBe('INITIAL');
+        expect(config2.confluence?.spaces?.requirements).toBe('UPDATED');
+      });
+
+      it('project.jsonを変更するとキャッシュが無効化される', async () => {
+        clearConfigCache();
+
+        // 最初の設定
+        const projectJsonPath = join(testProjectRoot, '.kiro', 'project.json');
+        mkdirSync(join(testProjectRoot, '.kiro'), { recursive: true });
+        writeFileSync(projectJsonPath, JSON.stringify({
+          projectId: 'initial-id',
+          projectName: 'Initial Name'
+        }));
+
+        const config1 = getConfig(testProjectRoot);
+
+        // ファイルシステムのmtime精度を考慮して少し待つ
+        await new Promise(resolve => setTimeout(resolve, 10));
+
+        // 設定を更新
+        writeFileSync(projectJsonPath, JSON.stringify({
+          projectId: 'updated-id',
+          projectName: 'Updated Name'
+        }));
+
+        const config2 = getConfig(testProjectRoot);
+
+        // 異なるオブジェクトが返されることを確認（キャッシュが無効化された）
+        expect(config1).not.toBe(config2);
+      });
+    });
+  });
 });