@sk8metal/michi-cli 0.0.8 → 0.1.0

package/scripts/utils/confluence-approval.ts

@@ -0,0 +1,167 @@
+/**
+ * Confluence承認状態ポーリングユーティリティ
+ * Confluence APIを使用してページの承認状態を確認
+ */
+
+import axios from 'axios';
+
+/**
+ * Confluence設定
+ */
+export interface ConfluenceConfig {
+  url: string;
+  email: string;
+  apiToken: string;
+}
+
+/**
+ * 承認状態
+ */
+export interface ApprovalStatus {
+  approved: boolean;
+  approvers: string[];
+  pendingApprovers: string[];
+  pageId: string;
+  pageTitle: string;
+}
+
+/**
+ * Confluenceページの承認状態を取得
+ * @param pageId ページID
+ * @param config Confluence設定
+ * @returns 承認状態
+ */
+export async function getApprovalStatus(
+  pageId: string,
+  config: ConfluenceConfig
+): Promise<ApprovalStatus> {
+  const baseUrl = `${config.url}/wiki/rest/api`;
+  const auth = Buffer.from(`${config.email}:${config.apiToken}`).toString('base64');
+
+  try {
+    // ページ情報を取得
+    const pageResponse = await axios.get(`${baseUrl}/content/${pageId}`, {
+      params: {
+        expand: 'metadata.labels'
+      },
+      headers: {
+        'Authorization': `Basic ${auth}`,
+        'Content-Type': 'application/json'
+      }
+    });
+
+    const pageTitle = pageResponse.data.title;
+    const labels = pageResponse.data.metadata?.labels?.results || [];
+
+    // 承認ラベルをチェック
+    // Confluenceでは通常、承認はカスタムラベルやメタデータで管理される
+    // ここでは "approved" ラベルの存在で判定
+    const hasApprovedLabel = labels.some((label: any) =>
+      label.name === 'approved' || label.name === '承認済み'
+    );
+
+    // ページのコメントから承認者を取得
+    const commentsResponse = await axios.get(`${baseUrl}/content/${pageId}/child/comment`, {
+      params: {
+        expand: 'body.view'
+      },
+      headers: {
+        'Authorization': `Basic ${auth}`,
+        'Content-Type': 'application/json'
+      }
+    });
+
+    const comments = commentsResponse.data.results || [];
+    const approvers: string[] = [];
+
+    // "承認" または "Approved" を含むコメントから承認者を抽出
+    for (const comment of comments) {
+      const body = comment.body?.view?.value || '';
+      const author = comment.version?.by?.displayName || 'Unknown';
+
+      if (
+        body.includes('承認') ||
+        body.toLowerCase().includes('approved') ||
+        body.toLowerCase().includes('lgtm')
+      ) {
+        if (!approvers.includes(author)) {
+          approvers.push(author);
+        }
+      }
+    }
+
+    return {
+      approved: hasApprovedLabel && approvers.length > 0,
+      approvers,
+      pendingApprovers: [],
+      pageId,
+      pageTitle
+    };
+  } catch (error: any) {
+    console.error('Failed to get approval status:', error.message);
+    throw error;
+  }
+}
+
+/**
+ * 承認状態をポーリング
+ * @param pageId ページID
+ * @param config Confluence設定
+ * @param interval チェック間隔 (ミリ秒)
+ * @param timeout タイムアウト (ミリ秒)
+ * @returns 承認状態
+ */
+export async function pollForApproval(
+  pageId: string,
+  config: ConfluenceConfig,
+  interval: number = 30000, // 30秒
+  timeout: number = 1800000 // 30分
+): Promise<ApprovalStatus> {
+  const startTime = Date.now();
+
+  while (true) {
+    try {
+      const status = await getApprovalStatus(pageId, config);
+
+      if (status.approved) {
+        return status;
+      }
+
+      // タイムアウトチェック
+      if (Date.now() - startTime > timeout) {
+        throw new Error('Approval timeout: No approval received within the specified time');
+      }
+
+      // 次のチェックまで待機
+      await new Promise(resolve => setTimeout(resolve, interval));
+    } catch (error: any) {
+      // エラーがタイムアウト以外の場合はリトライ
+      if (error.message.includes('timeout')) {
+        throw error;
+      }
+
+      console.warn('Error checking approval status, will retry:', error.message);
+      await new Promise(resolve => setTimeout(resolve, interval));
+    }
+  }
+}
+
+/**
+ * 手動承認を待つ (コンソール出力のみ)
+ * @param pageUrl ページURL
+ * @param requiredApprovers 必要な承認者リスト
+ */
+export function waitForManualApproval(
+  pageUrl: string,
+  requiredApprovers: string[] = []
+): void {
+  console.log('\n⏸️  承認待ち\n');
+  console.log(`📄 ページURL: ${pageUrl}`);
+
+  if (requiredApprovers.length > 0) {
+    console.log(`👥 承認者: ${requiredApprovers.join(', ')}`);
+  }
+
+  console.log('\n承認が完了したら、このプロセスを再開してください。');
+  console.log('（自動ポーリングを有効にするには、環境変数 CONFLUENCE_AUTO_POLL=true を設定してください）');
+}

package/scripts/utils/confluence-hierarchy.ts

@@ -3,12 +3,10 @@
  * 各パターン（single, by-section, by-hierarchy, manual）に対応
  */
 
-import { readFileSync } from 'fs';
-import { resolve } from 'path';
 import type { ConfluenceClient } from '../confluence-sync.js';
 import { convertMarkdownToConfluence, createConfluencePage } from '../markdown-to-confluence.js';
 import type { ProjectMetadata } from './project-meta.js';
-import type { ConfluenceConfig, ConfluencePageCreationGranularity } from '../config/config-schema.js';
+import type { ConfluenceConfig } from '../config/config-schema.js';
 
 /**
  * ページ作成結果
@@ -200,7 +198,7 @@ async function getOrCreateParentPage(
   parentTitle: string,
   projectMeta: ProjectMetadata,
   featureName: string,
-  githubUrl: string
+  _githubUrl: string
 ): Promise<string> {
   // 既存の親ページを検索
   const existingParent = await client.searchPage(spaceKey, parentTitle);

package/scripts/utils/docker-generator.ts

@@ -0,0 +1,151 @@
+/**
+ * Docker Compose設定生成ユーティリティ
+ * 選択されたサービスに応じてdocker-compose.ymlを生成
+ */
+
+import { writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import inquirer from 'inquirer';
+
+/**
+ * Docker Compose設定を生成
+ */
+export async function generateDockerCompose(
+  feature: string,
+  suggestedServices: string[] = [],
+  projectRoot: string = process.cwd()
+): Promise<void> {
+  // サービスを選択（推奨サービスはデフォルトで選択）
+  const answers = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'services',
+      message: '必要なサービスを選択してください:',
+      choices: [
+        { name: 'PostgreSQL', value: 'postgres', checked: suggestedServices.includes('postgres') },
+        { name: 'MySQL', value: 'mysql', checked: suggestedServices.includes('mysql') },
+        { name: 'Redis', value: 'redis', checked: suggestedServices.includes('redis') },
+        { name: 'MongoDB', value: 'mongodb', checked: suggestedServices.includes('mongodb') },
+        { name: 'Mock API Server', value: 'mockapi', checked: suggestedServices.includes('mockapi') }
+      ]
+    }
+  ]);
+  
+  if (answers.services.length === 0) {
+    console.log('   ⏭️  Docker Compose: スキップ（サービス未選択）');
+    return;
+  }
+  
+  // docker-compose.ymlを生成
+  const compose = generateDockerComposeYaml(answers.services);
+  const outputPath = join(projectRoot, 'docker-compose.yml');
+  
+  // 既存ファイルがある場合は確認
+  if (existsSync(outputPath)) {
+    console.log('   ⚠️  docker-compose.yml: 既存（上書きスキップ）');
+    return;
+  }
+  
+  writeFileSync(outputPath, compose, 'utf-8');
+  console.log(`   ✅ Docker Compose: docker-compose.yml (${answers.services.join(', ')})`);
+}
+
+/**
+ * Docker Compose YAMLを生成
+ */
+function generateDockerComposeYaml(services: string[]): string {
+  let yaml = `version: '3.8'
+
+services:
+`;
+  
+  if (services.includes('postgres')) {
+    yaml += `  postgres:
+    image: postgres:15-alpine
+    environment:
+      POSTGRES_USER: testuser
+      POSTGRES_PASSWORD: testpass
+      POSTGRES_DB: testdb
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+
+`;
+  }
+  
+  if (services.includes('mysql')) {
+    yaml += `  mysql:
+    image: mysql:8.0
+    environment:
+      MYSQL_ROOT_PASSWORD: rootpass
+      MYSQL_DATABASE: testdb
+      MYSQL_USER: testuser
+      MYSQL_PASSWORD: testpass
+    ports:
+      - "3306:3306"
+    volumes:
+      - mysql_data:/var/lib/mysql
+
+`;
+  }
+  
+  if (services.includes('redis')) {
+    yaml += `  redis:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis_data:/data
+
+`;
+  }
+  
+  if (services.includes('mongodb')) {
+    yaml += `  mongodb:
+    image: mongo:7
+    environment:
+      MONGO_INITDB_ROOT_USERNAME: root
+      MONGO_INITDB_ROOT_PASSWORD: rootpass
+      MONGO_INITDB_DATABASE: testdb
+    ports:
+      - "27017:27017"
+    volumes:
+      - mongodb_data:/data/db
+
+`;
+  }
+  
+  if (services.includes('mockapi')) {
+    yaml += `  mockapi:
+    image: mockserver/mockserver:latest
+    ports:
+      - "1080:1080"
+    environment:
+      MOCKSERVER_INITIALIZATION_JSON_PATH: /config/initializerJson.json
+    volumes:
+      - ./mock-config:/config
+
+`;
+  }
+  
+  // ボリューム定義
+  yaml += `volumes:
+`;
+  
+  if (services.includes('postgres')) {
+    yaml += '  postgres_data:\n';
+  }
+  if (services.includes('mysql')) {
+    yaml += '  mysql_data:\n';
+  }
+  if (services.includes('redis')) {
+    yaml += '  redis_data:\n';
+  }
+  if (services.includes('mongodb')) {
+    yaml += '  mongodb_data:\n';
+  }
+  
+  return yaml;
+}
+

package/scripts/utils/docker-requirement-detector.ts

@@ -0,0 +1,153 @@
+/**
+ * Docker Compose要件検出ユーティリティ
+ * design.md、requirements.md、test-type-selectionからDocker Composeの必要性を自動判断
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { extractSection } from './markdown-parser.js';
+
+export interface DockerRecommendation {
+  recommended: boolean;
+  confidence: 'high' | 'medium' | 'low';
+  reasons: string[];
+  suggestedServices: string[];
+}
+
+/**
+ * Docker Composeの必要性を分析
+ */
+export function analyzeDockerRequirement(feature: string, projectRoot: string = process.cwd()): DockerRecommendation {
+  const reasons: string[] = [];
+  const services: string[] = [];
+  let score = 0;
+  
+  // design.mdを解析
+  const designPath = join(projectRoot, '.kiro', 'specs', feature, 'design.md');
+  if (existsSync(designPath)) {
+    const design = readFileSync(designPath, 'utf-8');
+    
+    // Technology Stackセクションを確認
+    const techStack = extractSection(design, 'Technology Stack');
+    const dataModels = extractSection(design, 'Data Models');
+    
+    // データベースの検出
+    if (techStack.match(/PostgreSQL|Postgres/i) || dataModels.match(/PostgreSQL|Postgres/i)) {
+      score += 3;
+      services.push('postgres');
+      reasons.push('PostgreSQLがTechnology Stackに含まれている');
+    }
+    
+    if (techStack.match(/MySQL/i) || dataModels.match(/MySQL/i)) {
+      score += 3;
+      services.push('mysql');
+      reasons.push('MySQLがTechnology Stackに含まれている');
+    }
+    
+    if (techStack.match(/MongoDB|Mongo/i) || dataModels.match(/MongoDB|Mongo/i)) {
+      score += 3;
+      services.push('mongodb');
+      reasons.push('MongoDBがTechnology Stackに含まれている');
+    }
+    
+    // ミドルウェアの検出
+    if (techStack.match(/Redis/i)) {
+      score += 2;
+      services.push('redis');
+      reasons.push('RedisがTechnology Stackに含まれている');
+    }
+    
+    if (techStack.match(/Elasticsearch/i)) {
+      score += 2;
+      reasons.push('ElasticsearchがTechnology Stackに含まれている');
+    }
+    
+    if (techStack.match(/RabbitMQ|Kafka/i)) {
+      score += 2;
+      reasons.push('メッセージキュー（RabbitMQ/Kafka）がTechnology Stackに含まれている');
+    }
+    
+    // Data Modelsセクションの分析
+    if (dataModels.match(/Relational Database|RDBMS/i)) {
+      score += 2;
+      reasons.push('リレーショナルデータベースがData Modelsに定義されている');
+    }
+    
+    if (dataModels.match(/Document Store|NoSQL/i)) {
+      score += 2;
+      reasons.push('NoSQLデータベースがData Modelsに定義されている');
+    }
+    
+    // File Storageのみの場合は減点
+    if (techStack.match(/File System|File Storage/i) && 
+        !techStack.match(/PostgreSQL|MySQL|MongoDB|Redis/i)) {
+      score -= 1;
+      reasons.push('File Storageのみ（データベース不要の可能性）');
+    }
+  }
+  
+  // test-type-selection.jsonを解析
+  const testSelectionPath = join(projectRoot, '.kiro', 'specs', feature, 'test-type-selection.json');
+  if (existsSync(testSelectionPath)) {
+    try {
+      const testSelection = JSON.parse(readFileSync(testSelectionPath, 'utf-8'));
+      const testTypes = testSelection.selectedTypes || [];
+      
+      // 統合テストが選択されている
+      if (testTypes.includes('integration')) {
+        score += 2;
+        reasons.push('統合テストが選択されている（データベースやミドルウェアのテストに有用）');
+      }
+      
+      // E2Eテストが選択されている
+      if (testTypes.includes('e2e')) {
+        score += 2;
+        reasons.push('E2Eテストが選択されている（実環境に近い状態でのテストに有用）');
+      }
+      
+      // パフォーマンステストが選択されている
+      if (testTypes.includes('performance')) {
+        score += 1;
+        reasons.push('パフォーマンステストが選択されている（負荷テストにデータベースが有用）');
+      }
+    } catch {
+      // test-type-selection.jsonの読み込みエラーは無視
+    }
+  }
+  
+  // requirements.mdを解析
+  const requirementsPath = join(projectRoot, '.kiro', 'specs', feature, 'requirements.md');
+  if (existsSync(requirementsPath)) {
+    const requirements = readFileSync(requirementsPath, 'utf-8');
+    
+    // データ永続化の要件
+    if (requirements.match(/データベース|database|永続化|persist/i)) {
+      score += 1;
+      reasons.push('データ永続化の要件が含まれている');
+    }
+    
+    // 外部サービス連携の要件
+    if (requirements.match(/外部.*API|external.*API|mock.*server/i)) {
+      score += 1;
+      if (!services.includes('mockapi')) {
+        services.push('mockapi');
+      }
+      reasons.push('外部API連携の要件が含まれている（Mock API Serverが有用）');
+    }
+  }
+  
+  // 判定
+  const recommended = score >= 3;
+  const confidence: 'high' | 'medium' | 'low' = 
+    score >= 5 ? 'high' : 
+      score >= 3 ? 'medium' : 
+        'low';
+  
+  return {
+    recommended,
+    confidence,
+    reasons,
+    suggestedServices: [...new Set(services)] // 重複削除
+  };
+}
+