@sk8metal/michi-cli 0.0.8 → 0.1.0

package/scripts/utils/jira-issue-type-fetcher.ts

@@ -0,0 +1,199 @@
+/**
+ * JIRA Issue Types取得ユーティリティ
+ * 
+ * JIRA APIからプロジェクトのIssue Typesを取得する機能を提供
+ */
+
+import axios from 'axios';
+
+/**
+ * Issue Type情報
+ */
+export interface IssueTypeInfo {
+  id: string;
+  name: string;
+  description?: string;
+  iconUrl?: string;
+  subtask?: boolean;
+}
+
+/**
+ * JIRA認証情報
+ */
+export interface JIRACredentials {
+  url: string;
+  email: string;
+  apiToken: string;
+}
+
+/**
+ * 認証情報が設定されているかチェック
+ */
+export function hasJiraCredentials(): boolean {
+  return !!(
+    process.env.ATLASSIAN_URL &&
+    process.env.ATLASSIAN_EMAIL &&
+    process.env.ATLASSIAN_API_TOKEN
+  );
+}
+
+/**
+ * 環境変数からJIRA認証情報を取得
+ */
+export function getJiraCredentials(): JIRACredentials | null {
+  const url = process.env.ATLASSIAN_URL;
+  const email = process.env.ATLASSIAN_EMAIL;
+  const apiToken = process.env.ATLASSIAN_API_TOKEN;
+
+  if (!url || !email || !apiToken) {
+    return null;
+  }
+
+  return { url, email, apiToken };
+}
+
+/**
+ * リクエスト間の待機時間（ミリ秒）
+ * 環境変数 ATLASSIAN_REQUEST_DELAY で調整可能（デフォルト: 500ms）
+ */
+function getRequestDelay(): number {
+  return parseInt(process.env.ATLASSIAN_REQUEST_DELAY || '500', 10);
+}
+
+/**
+ * リクエスト間のスリープ処理（レートリミット対策）
+ */
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * JIRA APIからプロジェクトのIssue Typesを取得
+ * 
+ * @param projectKey プロジェクトキー（例: "PC"）
+ * @param credentials JIRA認証情報（省略時は環境変数から取得）
+ * @returns Issue Typesのリスト、取得失敗時はnull
+ */
+export async function getProjectIssueTypes(
+  projectKey: string,
+  credentials?: JIRACredentials
+): Promise<IssueTypeInfo[] | null> {
+  const creds = credentials || getJiraCredentials();
+  
+  if (!creds) {
+    return null;
+  }
+
+  const baseUrl = `${creds.url}/rest/api/3`;
+  const auth = Buffer.from(`${creds.email}:${creds.apiToken}`).toString('base64');
+  
+  // レートリミット対策: リクエスト前に待機
+  await sleep(getRequestDelay());
+
+  try {
+    const response = await axios.get(`${baseUrl}/project/${projectKey}`, {
+      headers: {
+        'Authorization': `Basic ${auth}`,
+        'Content-Type': 'application/json'
+      },
+      timeout: 10000 // 10秒タイムアウト
+    });
+
+    const issueTypes = response.data.issueTypes || [];
+    
+    return issueTypes.map((it: any) => ({
+      id: it.id,
+      name: it.name,
+      description: it.description || undefined,
+      iconUrl: it.iconUrl || undefined,
+      subtask: it.subtask || false
+    }));
+  } catch (error: any) {
+    // エラーをログに記録（デバッグ用）
+    if (error.response) {
+      // HTTPエラー（4xx, 5xx）
+      const status = error.response.status;
+      const statusText = error.response.statusText;
+      
+      if (status === 401) {
+        console.error('❌ JIRA認証に失敗しました。認証情報を確認してください。');
+      } else if (status === 403) {
+        console.error('❌ JIRAへのアクセス権限がありません。');
+      } else if (status === 404) {
+        console.error(`❌ JIRAプロジェクト "${projectKey}" が見つかりません。`);
+      } else {
+        console.error(`❌ JIRA APIエラー: ${status} ${statusText}`);
+      }
+    } else if (error.request) {
+      // ネットワークエラー
+      console.error('❌ JIRA APIへの接続に失敗しました。ネットワークを確認してください。');
+    } else {
+      // その他のエラー
+      console.error(`❌ エラー: ${error.message}`);
+    }
+    
+    return null;
+  }
+}
+
+/**
+ * Issue Type名からIDを取得
+ * 
+ * @param issueTypes Issue Typesのリスト
+ * @param name Issue Type名（例: "Story", "ストーリー"）
+ * @returns Issue Type ID、見つからない場合はnull
+ */
+export function findIssueTypeIdByName(
+  issueTypes: IssueTypeInfo[],
+  name: string
+): string | null {
+  const normalizedName = name.toLowerCase().trim();
+  
+  const found = issueTypes.find(it => 
+    it.name.toLowerCase() === normalizedName ||
+    it.name === name
+  );
+  
+  return found ? found.id : null;
+}
+
+/**
+ * Issue Type IDが存在するかチェック
+ * 
+ * @param issueTypes Issue Typesのリスト
+ * @param id Issue Type ID
+ * @returns 存在する場合はtrue
+ */
+export function hasIssueTypeId(
+  issueTypes: IssueTypeInfo[],
+  id: string
+): boolean {
+  return issueTypes.some(it => it.id === id);
+}
+
+/**
+ * StoryタイプのIssue Typesをフィルタリング
+ * 
+ * @param issueTypes Issue Typesのリスト
+ * @returns Storyタイプのリスト
+ */
+export function filterStoryTypes(issueTypes: IssueTypeInfo[]): IssueTypeInfo[] {
+  return issueTypes.filter(it =>
+    !it.subtask &&
+    (it.name.toLowerCase().includes('story') || it.name.includes('ストーリー')) &&
+    !it.name.toLowerCase().includes('epic') &&
+    !it.name.includes('エピック')
+  );
+}
+
+/**
+ * SubtaskタイプのIssue Typesをフィルタリング
+ * 
+ * @param issueTypes Issue Typesのリスト
+ * @returns Subtaskタイプのリスト
+ */
+export function filterSubtaskTypes(issueTypes: IssueTypeInfo[]): IssueTypeInfo[] {
+  return issueTypes.filter(it => it.subtask === true);
+}
+
+

package/scripts/utils/language-detector.ts

@@ -0,0 +1,139 @@
+/**
+ * 実装言語検出ユーティリティ
+ * design.md、requirements.mdから実装言語を自動推論
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { extractSection } from './markdown-parser.js';
+
+export interface LanguageRecommendation {
+  language: string; // 'Node.js/TypeScript', 'Java', etc.
+  confidence: 'high' | 'medium' | 'low';
+  reasons: string[];
+}
+
+/**
+ * 実装言語を分析
+ */
+export function analyzeLanguage(feature: string, projectRoot: string = process.cwd()): LanguageRecommendation {
+  const reasons: string[] = [];
+  const scores: Record<string, number> = {
+    'Node.js/TypeScript': 0,
+    'Java': 0,
+    'PHP': 0,
+    'Python': 0,
+    'Go': 0,
+    'Rust': 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');
+    
+    // Node.js/TypeScript
+    if (techStack.match(/Node\.js|TypeScript|npm|pnpm|yarn/i)) {
+      scores['Node.js/TypeScript'] += 5;
+      reasons.push('Technology StackにNode.js/TypeScriptが含まれている');
+    }
+    
+    if (techStack.match(/React|Next\.js|Express|NestJS/i)) {
+      scores['Node.js/TypeScript'] += 3;
+      reasons.push('Node.jsフレームワーク（React/Next.js/Express等）が含まれている');
+    }
+    
+    // Java
+    if (techStack.match(/Java|JDK|Spring|Gradle|Maven/i)) {
+      scores['Java'] += 5;
+      reasons.push('Technology StackにJavaが含まれている');
+    }
+    
+    if (techStack.match(/Spring Boot|Spring Framework|Hibernate/i)) {
+      scores['Java'] += 3;
+      reasons.push('Javaフレームワーク（Spring等）が含まれている');
+    }
+    
+    // PHP
+    if (techStack.match(/PHP|Composer|Laravel|Symfony/i)) {
+      scores['PHP'] += 5;
+      reasons.push('Technology StackにPHPが含まれている');
+    }
+    
+    // Python
+    if (techStack.match(/Python|Django|Flask|FastAPI|pip|poetry/i)) {
+      scores['Python'] += 5;
+      reasons.push('Technology StackにPythonが含まれている');
+    }
+    
+    // Go
+    if (techStack.match(/\bGo\b|Golang|go mod/i)) {
+      scores['Go'] += 5;
+      reasons.push('Technology StackにGoが含まれている');
+    }
+    
+    // Rust
+    if (techStack.match(/Rust|Cargo|Actix|Rocket/i)) {
+      scores['Rust'] += 5;
+      reasons.push('Technology StackにRustが含まれている');
+    }
+    
+    // Runtimeセクションも確認
+    const runtime = design.toLowerCase();
+    if (runtime.includes('node.js')) {
+      scores['Node.js/TypeScript'] += 2;
+    }
+    if (runtime.includes('jvm') || runtime.includes('java')) {
+      scores['Java'] += 2;
+    }
+  }
+  
+  // requirements.mdを解析
+  const requirementsPath = join(projectRoot, '.kiro', 'specs', feature, 'requirements.md');
+  if (existsSync(requirementsPath)) {
+    const requirements = readFileSync(requirementsPath, 'utf-8');
+    
+    // APIやWebアプリケーションの言及
+    if (requirements.match(/REST API|GraphQL API/i)) {
+      // API系はNode.js、Java、Go、Pythonが一般的
+      if (scores['Node.js/TypeScript'] > 0) scores['Node.js/TypeScript'] += 1;
+      if (scores['Java'] > 0) scores['Java'] += 1;
+      if (scores['Go'] > 0) scores['Go'] += 1;
+      if (scores['Python'] > 0) scores['Python'] += 1;
+    }
+    
+    if (requirements.match(/Web.*アプリケーション|UI|フロントエンド/i)) {
+      // Webアプリケーションは主にNode.js、PHP、Python
+      if (scores['Node.js/TypeScript'] > 0) scores['Node.js/TypeScript'] += 1;
+      if (scores['PHP'] > 0) scores['PHP'] += 1;
+      if (scores['Python'] > 0) scores['Python'] += 1;
+    }
+  }
+  
+  // 最高スコアの言語を選択
+  let maxScore = 0;
+  let recommendedLanguage = 'その他';
+  
+  for (const [lang, score] of Object.entries(scores)) {
+    if (score > maxScore) {
+      maxScore = score;
+      recommendedLanguage = lang;
+    }
+  }
+  
+  // 信頼度を判定
+  const confidence: 'high' | 'medium' | 'low' = 
+    maxScore >= 5 ? 'high' : 
+      maxScore >= 3 ? 'medium' : 
+        'low';
+  
+  return {
+    language: recommendedLanguage,
+    confidence,
+    reasons
+  };
+}
+

package/scripts/utils/markdown-parser.ts

@@ -0,0 +1,376 @@
+/**
+ * Markdown解析ユーティリティ
+ * requirements.mdとdesign.mdから構造化データを抽出
+ */
+
+export interface Component {
+  name: string;
+  domain: string;
+  intent: string;
+  requirements: string[];
+  methods: Method[];
+}
+
+export interface Method {
+  name: string;
+  signature: string;
+  parameters: Parameter[];
+  returnType: string;
+  description?: string;
+}
+
+export interface Parameter {
+  name: string;
+  type: string;
+}
+
+export interface Flow {
+  name: string;
+  type: 'sequence' | 'process' | 'data';
+  mermaidCode: string;
+  description?: string;
+}
+
+export interface Requirement {
+  id: string;
+  title: string;
+  objective: string;
+  acceptanceCriteria: string[];
+}
+
+/**
+ * Markdownから特定の見出しセクションを抽出
+ */
+export function extractSection(content: string, heading: string): string {
+  const lines = content.split('\n');
+  const headingRegex = new RegExp(`^#+\\s+${heading}`, 'i');
+  
+  let startIndex = -1;
+  let endIndex = lines.length;
+  let headingLevel = 0;
+  
+  // 開始位置を検索
+  for (let i = 0; i < lines.length; i++) {
+    if (headingRegex.test(lines[i])) {
+      startIndex = i;
+      const match = lines[i].match(/^(#+)/);
+      headingLevel = match ? match[1].length : 0;
+      break;
+    }
+  }
+  
+  if (startIndex === -1) {
+    return '';
+  }
+  
+  // 同じレベルまたは上位レベルの見出しまで抽出
+  for (let i = startIndex + 1; i < lines.length; i++) {
+    const match = lines[i].match(/^(#+)\s/);
+    if (match && match[1].length <= headingLevel) {
+      endIndex = i;
+      break;
+    }
+  }
+  
+  return lines.slice(startIndex, endIndex).join('\n');
+}
+
+/**
+ * design.mdからコンポーネント情報を抽出
+ */
+export function extractComponents(designMd: string): Component[] {
+  const components: Component[] = [];
+  const componentsSection = extractSection(designMd, 'Components and Interfaces');
+  
+  if (!componentsSection) {
+    return components;
+  }
+  
+  // コンポーネントサマリーテーブルを解析
+  const summaryTableMatch = componentsSection.match(/\|\s*Component\s*\|.*?\n\|[-\s|]+\n((?:\|.*?\n)+)/i);
+  if (summaryTableMatch) {
+    const rows = summaryTableMatch[1].trim().split('\n');
+    for (const row of rows) {
+      const cells = row.split('|').map(c => c.trim()).filter(c => c);
+      if (cells.length >= 3) {
+        components.push({
+          name: cells[0],
+          domain: cells[1] || '',
+          intent: cells[2] || '',
+          requirements: [],
+          methods: []
+        });
+      }
+    }
+  }
+  
+  // 各コンポーネントの詳細セクションからインターフェースを抽出
+  const lines = componentsSection.split('\n');
+  let currentComponent: Component | null = null;
+  
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    
+    // コンポーネント見出しを検索（#### Component Name）
+    const componentMatch = line.match(/^####\s+(.+)/);
+    if (componentMatch) {
+      const componentName = componentMatch[1].trim();
+      currentComponent = components.find(c => c.name === componentName) || null;
+      continue;
+    }
+    
+    // Service Interfaceセクションを検索
+    if (line.includes('##### Service Interface') && currentComponent) {
+      // TypeScriptコードブロックを抽出
+      let inCodeBlock = false;
+      let codeContent = '';
+      
+      for (let j = i + 1; j < lines.length; j++) {
+        if (lines[j].startsWith('```typescript') || lines[j].startsWith('```ts')) {
+          inCodeBlock = true;
+          continue;
+        }
+        if (lines[j].startsWith('```') && inCodeBlock) {
+          break;
+        }
+        if (inCodeBlock) {
+          codeContent += lines[j] + '\n';
+        }
+      }
+      
+      // インターフェースからメソッドを抽出
+      const methods = extractMethodsFromInterface(codeContent);
+      currentComponent.methods = methods;
+    }
+  }
+  
+  return components;
+}
+
+/**
+ * TypeScriptインターフェースからメソッドを抽出
+ */
+function extractMethodsFromInterface(interfaceCode: string): Method[] {
+  const methods: Method[] = [];
+  const lines = interfaceCode.split('\n');
+  
+  for (const line of lines) {
+    // メソッドシグネチャを検索（例: methodName(param: Type): ReturnType）
+    const methodMatch = line.match(/^\s*(\w+)\s*\(([^)]*)\)\s*:\s*(.+?)\s*;?\s*$/);
+    if (methodMatch) {
+      const methodName = methodMatch[1];
+      const paramsStr = methodMatch[2];
+      const returnType = methodMatch[3];
+      
+      // パラメータを解析
+      const parameters: Parameter[] = [];
+      if (paramsStr.trim()) {
+        const paramParts = paramsStr.split(',');
+        for (const part of paramParts) {
+          const paramMatch = part.trim().match(/(\w+)\??:\s*(.+)/);
+          if (paramMatch) {
+            parameters.push({
+              name: paramMatch[1],
+              type: paramMatch[2].trim()
+            });
+          }
+        }
+      }
+      
+      methods.push({
+        name: methodName,
+        signature: line.trim(),
+        parameters,
+        returnType: returnType.trim()
+      });
+    }
+  }
+  
+  return methods;
+}
+
+/**
+ * design.mdからシステムフローを抽出
+ */
+export function extractFlows(designMd: string): Flow[] {
+  const flows: Flow[] = [];
+  const flowsSection = extractSection(designMd, 'System Flows');
+  
+  if (!flowsSection) {
+    return flows;
+  }
+  
+  const lines = flowsSection.split('\n');
+  let currentFlowName = '';
+  let currentFlowType: 'sequence' | 'process' | 'data' = 'sequence';
+  
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    
+    // フロー見出しを検索（### Flow Name）
+    const flowMatch = line.match(/^###\s+(.+)/);
+    if (flowMatch) {
+      currentFlowName = flowMatch[1].trim();
+      continue;
+    }
+    
+    // Mermaidコードブロックを検索
+    if (line.startsWith('```mermaid') && currentFlowName) {
+      let mermaidCode = '';
+      
+      for (let j = i + 1; j < lines.length; j++) {
+        if (lines[j].startsWith('```')) {
+          break;
+        }
+        mermaidCode += lines[j] + '\n';
+      }
+      
+      // フロータイプを判定
+      if (mermaidCode.includes('sequenceDiagram')) {
+        currentFlowType = 'sequence';
+      } else if (mermaidCode.includes('graph') || mermaidCode.includes('flowchart')) {
+        currentFlowType = 'process';
+      }
+      
+      flows.push({
+        name: currentFlowName,
+        type: currentFlowType,
+        mermaidCode: mermaidCode.trim()
+      });
+      
+      currentFlowName = '';
+    }
+  }
+  
+  return flows;
+}
+
+/**
+ * requirements.mdから要件を抽出
+ */
+export function extractRequirements(requirementsMd: string): Requirement[] {
+  const requirements: Requirement[] = [];
+  const lines = requirementsMd.split('\n');
+  
+  let currentRequirement: Requirement | null = null;
+  let inAcceptanceCriteria = false;
+  
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    
+    // 要件見出しを検索（### Requirement N: Title）
+    const reqMatch = line.match(/^###\s+Requirement\s+(\d+):\s+(.+)/i);
+    if (reqMatch) {
+      // 前の要件を保存
+      if (currentRequirement) {
+        requirements.push(currentRequirement);
+      }
+      
+      currentRequirement = {
+        id: reqMatch[1],
+        title: reqMatch[2].trim(),
+        objective: '',
+        acceptanceCriteria: []
+      };
+      inAcceptanceCriteria = false;
+      continue;
+    }
+    
+    // NFR（非機能要件）も同様に抽出
+    const nfrMatch = line.match(/^###\s+(NFR-\d+):\s+(.+)/i);
+    if (nfrMatch) {
+      if (currentRequirement) {
+        requirements.push(currentRequirement);
+      }
+      
+      currentRequirement = {
+        id: nfrMatch[1],
+        title: nfrMatch[2].trim(),
+        objective: '',
+        acceptanceCriteria: []
+      };
+      inAcceptanceCriteria = false;
+      continue;
+    }
+    
+    // Objectiveを抽出
+    if (currentRequirement && line.includes('**Objective:**')) {
+      const objectiveMatch = line.match(/\*\*Objective:\*\*\s*(.+)/);
+      if (objectiveMatch) {
+        currentRequirement.objective = objectiveMatch[1].trim();
+      }
+      continue;
+    }
+    
+    // Acceptance Criteriaセクションの開始
+    if (currentRequirement && line.includes('#### Acceptance Criteria')) {
+      inAcceptanceCriteria = true;
+      continue;
+    }
+    
+    // Acceptance Criteriaを抽出
+    if (currentRequirement && inAcceptanceCriteria) {
+      const criteriaMatch = line.match(/^\d+\.\s+(.+)/);
+      if (criteriaMatch) {
+        currentRequirement.acceptanceCriteria.push(criteriaMatch[1].trim());
+      }
+      
+      // 次のセクションに到達したら終了
+      if (line.match(/^##[#]?\s+/)) {
+        inAcceptanceCriteria = false;
+      }
+    }
+  }
+  
+  // 最後の要件を保存
+  if (currentRequirement) {
+    requirements.push(currentRequirement);
+  }
+  
+  return requirements;
+}
+
+/**
+ * design.mdからインターフェース定義を抽出
+ */
+export function extractInterfaces(designMd: string): Record<string, string> {
+  const interfaces: Record<string, string> = {};
+  const lines = designMd.split('\n');
+  
+  let inCodeBlock = false;
+  let currentInterface = '';
+  let interfaceCode = '';
+  
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    
+    if (line.startsWith('```typescript') || line.startsWith('```ts')) {
+      inCodeBlock = true;
+      interfaceCode = '';
+      continue;
+    }
+    
+    if (line.startsWith('```') && inCodeBlock) {
+      inCodeBlock = false;
+      if (currentInterface && interfaceCode) {
+        interfaces[currentInterface] = interfaceCode.trim();
+      }
+      currentInterface = '';
+      interfaceCode = '';
+      continue;
+    }
+    
+    if (inCodeBlock) {
+      interfaceCode += line + '\n';
+      
+      // インターフェース名を抽出
+      const interfaceMatch = line.match(/interface\s+(\w+)/);
+      if (interfaceMatch && !currentInterface) {
+        currentInterface = interfaceMatch[1];
+      }
+    }
+  }
+  
+  return interfaces;
+}
+