@sk8metal/michi-cli 0.0.1 → 0.0.2

package/scripts/utils/feature-name-validator.ts

@@ -0,0 +1,135 @@
+/**
+ * 機能名（feature）のバリデーション
+ * kebab-case形式を強制
+ */
+
+export interface ValidationResult {
+  valid: boolean;
+  errors: string[];
+}
+
+/**
+ * kebab-case形式の正規表現
+ * - 小文字の英数字で始まる
+ * - 小文字の英数字とハイフンのみ
+ * - 連続したハイフン不可
+ * - 先頭・末尾のハイフン不可
+ */
+const KEBAB_CASE_PATTERN = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+
+/**
+ * feature名がkebab-case形式か検証
+ */
+export function validateFeatureName(featureName: string): ValidationResult {
+  const errors: string[] = [];
+  
+  // 空文字チェック
+  if (!featureName || featureName.trim().length === 0) {
+    errors.push('❌ feature名が空です');
+    return { valid: false, errors };
+  }
+  
+  const trimmed = featureName.trim();
+  
+  // kebab-case形式チェック
+  if (!KEBAB_CASE_PATTERN.test(trimmed)) {
+    errors.push(`❌ feature名が無効な形式です: "${trimmed}"`);
+    errors.push('   必須形式: 英語、kebab-case（ハイフン区切り）、小文字のみ');
+    
+    // 具体的な問題を特定
+    if (/[A-Z]/.test(trimmed)) {
+      errors.push('   → 大文字が含まれています（小文字に変換してください）');
+    }
+    if (/[ぁ-んァ-ヶー一-龯]/.test(trimmed)) {
+      errors.push('   → 日本語が含まれています（英語に変換してください）');
+    }
+    if (/_/.test(trimmed)) {
+      errors.push('   → アンダースコア(_)が含まれています（ハイフン(-)を使用してください）');
+    }
+    if (/\s/.test(trimmed)) {
+      errors.push('   → スペースが含まれています（ハイフン(-)を使用してください）');
+    }
+    if (trimmed.startsWith('-') || trimmed.endsWith('-')) {
+      errors.push('   → 先頭または末尾にハイフンがあります（削除してください）');
+    }
+    if (/--/.test(trimmed)) {
+      errors.push('   → 連続したハイフンがあります（1つに減らしてください）');
+    }
+    if (/[^a-z0-9-]/.test(trimmed)) {
+      const invalidChars = trimmed.match(/[^a-z0-9-]/g);
+      errors.push(`   → 使用できない文字が含まれています: ${[...new Set(invalidChars)].join(', ')}`);
+    }
+    
+    // 修正案を提示
+    const suggestion = suggestFeatureName(trimmed);
+    if (suggestion && suggestion !== trimmed) {
+      errors.push(`   💡 修正案: "${suggestion}"`);
+    }
+  }
+  
+  // 長さチェック（推奨）
+  if (trimmed.length > 50) {
+    errors.push(`⚠️  feature名が長すぎます（${trimmed.length}文字）。50文字以内を推奨`);
+  }
+  
+  // 単語数チェック（推奨）
+  const wordCount = trimmed.split('-').length;
+  if (wordCount > 5) {
+    errors.push(`⚠️  単語数が多すぎます（${wordCount}単語）。2-4単語を推奨`);
+  }
+  
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+/**
+ * 不正なfeature名を修正案に変換
+ */
+export function suggestFeatureName(input: string): string {
+  return input
+    .toLowerCase()                    // 小文字に変換
+    .replace(/[ぁ-んァ-ヶー一-龯]/g, '') // 日本語削除
+    .replace(/\s+/g, '-')             // スペース→ハイフン
+    .replace(/_+/g, '-')              // アンダースコア→ハイフン
+    .replace(/[^a-z0-9-]/g, '')       // 無効文字削除
+    .replace(/--+/g, '-')             // 連続ハイフン→1つ
+    .replace(/^-+|-+$/g, '');         // 先頭・末尾ハイフン削除
+}
+
+/**
+ * feature名をバリデートし、エラー時は例外をスロー
+ */
+export function validateFeatureNameOrThrow(featureName: string): void {
+  const result = validateFeatureName(featureName);
+  
+  if (!result.valid) {
+    const errorMessage = [
+      `Invalid feature name: "${featureName}"`,
+      '',
+      ...result.errors,
+      '',
+      'ヘルプ: README.md#機能名（feature）の命名規則 を参照してください'
+    ].join('\n');
+    
+    throw new Error(errorMessage);
+  }
+}
+
+/**
+ * feature名をバリデートし、警告を表示（続行可能）
+ */
+export function validateFeatureNameWithWarning(featureName: string): boolean {
+  const result = validateFeatureName(featureName);
+  
+  if (!result.valid) {
+    console.error('\n⚠️  Feature name validation failed:');
+    result.errors.forEach(err => console.error(err));
+    console.error('\nヘルプ: README.md#機能名（feature）の命名規則 を参照してください\n');
+    return false;
+  }
+  
+  return true;
+}
+

package/scripts/utils/project-meta.ts

@@ -0,0 +1,69 @@
+/**
+ * プロジェクトメタデータ読み込みユーティリティ
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+
+export interface ProjectMetadata {
+  projectId: string;
+  projectName: string;
+  jiraProjectKey: string;
+  confluenceLabels: string[];
+  status: 'active' | 'inactive' | 'completed';
+  team: string[];
+  stakeholders: string[];
+  repository: string;
+  description?: string;
+}
+
+/**
+ * .kiro/project.json を読み込む
+ */
+export function loadProjectMeta(projectRoot: string = process.cwd()): ProjectMetadata {
+  const projectJsonPath = resolve(projectRoot, '.kiro/project.json');
+  
+  if (!existsSync(projectJsonPath)) {
+    throw new Error(`Project metadata not found: ${projectJsonPath}`);
+  }
+  
+  try {
+    const content = readFileSync(projectJsonPath, 'utf-8');
+    const meta = JSON.parse(content) as ProjectMetadata;
+    
+    // 必須フィールドのバリデーション
+    const requiredFields: (keyof ProjectMetadata)[] = [
+      'projectId',
+      'projectName',
+      'jiraProjectKey',
+      'confluenceLabels'
+    ];
+    
+    for (const field of requiredFields) {
+      if (!meta[field]) {
+        throw new Error(`Required field missing in project.json: ${field}`);
+      }
+    }
+    
+    return meta;
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error(`Invalid JSON in ${projectJsonPath}: ${error.message}`);
+    }
+    throw error;
+  }
+}
+
+/**
+ * プロジェクトメタデータを表示用にフォーマット
+ */
+export function formatProjectInfo(meta: ProjectMetadata): string {
+  return `
+Project: ${meta.projectName} (${meta.projectId})
+JIRA: ${meta.jiraProjectKey}
+Labels: ${meta.confluenceLabels.join(', ')}
+Status: ${meta.status}
+Team: ${meta.team.join(', ')}
+`.trim();
+}
+

package/scripts/validate-phase.ts

@@ -0,0 +1,279 @@
+/**
+ * フェーズ完了バリデーションスクリプト
+ * 各フェーズで必須項目が完了しているかチェック
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { loadProjectMeta } from './utils/project-meta.js';
+import { validateFeatureName } from './utils/feature-name-validator.js';
+
+type Phase = 'requirements' | 'design' | 'tasks';
+
+interface ValidationResult {
+  phase: Phase;
+  valid: boolean;
+  errors: string[];
+  warnings: string[];
+}
+
+/**
+ * spec.jsonを読み込み
+ */
+function loadSpecJson(feature: string): any {
+  const specPath = join(process.cwd(), '.kiro', 'specs', feature, 'spec.json');
+  
+  if (!existsSync(specPath)) {
+    throw new Error(`spec.json not found: ${specPath}`);
+  }
+  
+  return JSON.parse(readFileSync(specPath, 'utf-8'));
+}
+
+/**
+ * 要件定義フェーズのバリデーション
+ */
+function validateRequirements(feature: string): ValidationResult {
+  const errors: string[] = [];
+  const warnings: string[] = [];
+  
+  // 0. feature名のバリデーション
+  const nameValidation = validateFeatureName(feature);
+  if (!nameValidation.valid) {
+    errors.push(...nameValidation.errors);
+  }
+  
+  // 1. requirements.md存在チェック
+  const requirementsPath = join(process.cwd(), '.kiro', 'specs', feature, 'requirements.md');
+  if (!existsSync(requirementsPath)) {
+    errors.push('❌ requirements.md が作成されていません');
+  }
+  
+  // 2. spec.json読み込み
+  let spec: any;
+  try {
+    spec = loadSpecJson(feature);
+  } catch (error: any) {
+    errors.push(`❌ spec.json読み込みエラー: ${error.message}`);
+    return { phase: 'requirements', valid: false, errors, warnings };
+  }
+  
+  // 3. Confluenceページ作成チェック（必須）
+  if (!spec.confluence?.requirementsPageId) {
+    errors.push('❌ Confluenceページ（要件定義）が作成されていません');
+    errors.push('   → 実行: npm run confluence:sync <feature> requirements');
+  }
+  
+  // 4. spec.jsonのconfluence情報チェック
+  if (!spec.confluence?.spaceKey) {
+    errors.push('❌ spec.jsonにconfluence.spaceKeyが記録されていません');
+  }
+  
+  // 5. マイルストーン更新チェック
+  if (!spec.milestones?.requirements?.completed) {
+    warnings.push('⚠️  spec.jsonのmilestones.requirements.completedがfalseです');
+  }
+  
+  return {
+    phase: 'requirements',
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+
+/**
+ * 設計フェーズのバリデーション
+ */
+function validateDesign(feature: string): ValidationResult {
+  const errors: string[] = [];
+  const warnings: string[] = [];
+  
+  // 0. feature名のバリデーション
+  const nameValidation = validateFeatureName(feature);
+  if (!nameValidation.valid) {
+    errors.push(...nameValidation.errors);
+  }
+  
+  // 1. design.md存在チェック
+  const designPath = join(process.cwd(), '.kiro', 'specs', feature, 'design.md');
+  if (!existsSync(designPath)) {
+    errors.push('❌ design.md が作成されていません');
+  }
+  
+  // 2. spec.json読み込み
+  let spec: any;
+  try {
+    spec = loadSpecJson(feature);
+  } catch (error: any) {
+    errors.push(`❌ spec.json読み込みエラー: ${error.message}`);
+    return { phase: 'design', valid: false, errors, warnings };
+  }
+  
+  // 3. 前提: 要件定義完了チェック
+  if (!spec.milestones?.requirements?.completed) {
+    errors.push('❌ 要件定義が完了していません（前提条件）');
+  }
+  
+  // 4. Confluenceページ作成チェック（必須）
+  if (!spec.confluence?.designPageId) {
+    errors.push('❌ Confluenceページ（設計書）が作成されていません');
+    errors.push('   → 実行: npm run confluence:sync <feature> design');
+  }
+  
+  // 5. マイルストーン更新チェック
+  if (!spec.milestones?.design?.completed) {
+    warnings.push('⚠️  spec.jsonのmilestones.design.completedがfalseです');
+  }
+  
+  return {
+    phase: 'design',
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+
+/**
+ * タスク分割フェーズのバリデーション
+ */
+function validateTasks(feature: string): ValidationResult {
+  const errors: string[] = [];
+  const warnings: string[] = [];
+  
+  // 0. feature名のバリデーション
+  const nameValidation = validateFeatureName(feature);
+  if (!nameValidation.valid) {
+    errors.push(...nameValidation.errors);
+  }
+  
+  // 1. tasks.md存在チェック
+  const tasksPath = join(process.cwd(), '.kiro', 'specs', feature, 'tasks.md');
+  if (!existsSync(tasksPath)) {
+    errors.push('❌ tasks.md が作成されていません');
+  } else {
+    // 営業日表記チェック
+    const tasksContent = readFileSync(tasksPath, 'utf-8');
+    if (!tasksContent.includes('（月）') && !tasksContent.includes('（火）')) {
+      warnings.push('⚠️  tasks.mdに曜日表記（月、火、水...）が含まれていません');
+    }
+    if (!tasksContent.includes('Day 1') && !tasksContent.includes('Day1')) {
+      warnings.push('⚠️  tasks.mdに営業日カウント（Day 1, Day 2...）が含まれていません');
+    }
+    if (!tasksContent.includes('土日')) {
+      warnings.push('⚠️  tasks.mdに土日休みの明記がありません');
+    }
+  }
+  
+  // 2. spec.json読み込み
+  let spec: any;
+  try {
+    spec = loadSpecJson(feature);
+  } catch (error: any) {
+    errors.push(`❌ spec.json読み込みエラー: ${error.message}`);
+    return { phase: 'tasks', valid: false, errors, warnings };
+  }
+  
+  // 3. 前提: 設計完了チェック
+  if (!spec.milestones?.design?.completed) {
+    errors.push('❌ 設計が完了していません（前提条件）');
+  }
+  
+  // 4. JIRA Epic作成チェック（必須）
+  if (!spec.jira?.epicKey) {
+    errors.push('❌ JIRA Epicが作成されていません');
+    errors.push('   → 実行: npm run jira:sync <feature>');
+  }
+  
+  // 5. JIRA Story作成チェック（必須）
+  if (!spec.jira?.stories || spec.jira.stories.created === 0) {
+    errors.push('❌ JIRA Storyが1つも作成されていません');
+    errors.push('   → 実行: npm run jira:sync <feature>');
+  } else if (spec.jira.stories.created < spec.jira.stories.total) {
+    warnings.push(`⚠️  JIRA Storyが一部未作成: ${spec.jira.stories.created}/${spec.jira.stories.total}`);
+  }
+  
+  // 6. マイルストーン更新チェック
+  if (!spec.milestones?.tasks?.completed) {
+    warnings.push('⚠️  spec.jsonのmilestones.tasks.completedがfalseです');
+  }
+  
+  return {
+    phase: 'tasks',
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+
+/**
+ * フェーズをバリデート
+ */
+export function validatePhase(feature: string, phase: Phase): ValidationResult {
+  console.log(`\n🔍 Validating phase: ${phase} for feature: ${feature}`);
+  
+  let result: ValidationResult;
+  
+  switch (phase) {
+    case 'requirements':
+      result = validateRequirements(feature);
+      break;
+    case 'design':
+      result = validateDesign(feature);
+      break;
+    case 'tasks':
+      result = validateTasks(feature);
+      break;
+    default:
+      throw new Error(`Unknown phase: ${phase}`);
+  }
+  
+  // 結果表示
+  console.log('\n📊 Validation Result:');
+  
+  if (result.errors.length > 0) {
+    console.log('\n❌ エラー:');
+    result.errors.forEach(err => console.log(`  ${err}`));
+  }
+  
+  if (result.warnings.length > 0) {
+    console.log('\n⚠️  警告:');
+    result.warnings.forEach(warn => console.log(`  ${warn}`));
+  }
+  
+  if (result.valid) {
+    console.log('\n✅ バリデーション成功: すべての必須項目が完了しています');
+  } else {
+    console.log('\n❌ バリデーション失敗: 上記のエラーを修正してください');
+  }
+  
+  return result;
+}
+
+// CLI実行
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const args = process.argv.slice(2);
+  
+  if (args.length < 2) {
+    console.error('Usage: npm run validate:phase <feature> <phase>');
+    console.error('Example: npm run validate:phase calculator-app requirements');
+    console.error('Phases: requirements, design, tasks');
+    process.exit(1);
+  }
+  
+  const [feature, phase] = args;
+  
+  if (!['requirements', 'design', 'tasks'].includes(phase)) {
+    console.error('Invalid phase. Must be: requirements, design, or tasks');
+    process.exit(1);
+  }
+  
+  try {
+    const result = validatePhase(feature, phase as Phase);
+    process.exit(result.valid ? 0 : 1);
+  } catch (error: any) {
+    console.error(`\n❌ Validation error: ${error.message}`);
+    process.exit(1);
+  }
+}
+

package/scripts/workflow-orchestrator.ts

@@ -0,0 +1,178 @@
+/**
+ * ワークフローオーケストレーター
+ * AI開発フロー全体を統合実行
+ */
+
+import { config } from 'dotenv';
+import { loadProjectMeta } from './utils/project-meta.js';
+import { syncToConfluence } from './confluence-sync.js';
+import { syncTasksToJIRA } from './jira-sync.js';
+import { createPR } from './pr-automation.js';
+
+config();
+
+export interface WorkflowConfig {
+  feature: string;
+  stages: WorkflowStage[];
+  approvalGates?: {
+    requirements?: string[];
+    design?: string[];
+    release?: string[];
+  };
+}
+
+export type WorkflowStage =
+  | 'requirements'
+  | 'design'
+  | 'tasks'
+  | 'implement'
+  | 'test'
+  | 'release';
+
+export class WorkflowOrchestrator {
+  private config: WorkflowConfig;
+  
+  constructor(config: WorkflowConfig) {
+    this.config = config;
+  }
+  
+  /**
+   * ワークフロー全体を実行
+   */
+  async run(): Promise<void> {
+    console.log(`🚀 Starting workflow for: ${this.config.feature}`);
+    console.log(`Stages: ${this.config.stages.join(' → ')}`);
+    
+    const projectMeta = loadProjectMeta();
+    console.log(`Project: ${projectMeta.projectName}`);
+    
+    for (const stage of this.config.stages) {
+      console.log(`\n📋 Stage: ${stage}`);
+      
+      try {
+        await this.executeStage(stage);
+        
+        // 承認ゲートチェック
+        if (this.hasApprovalGate(stage)) {
+          await this.waitForApproval(stage);
+        }
+        
+        console.log(`✅ Stage completed: ${stage}`);
+      } catch (error: any) {
+        console.error(`❌ Stage failed: ${stage}`, error.message);
+        throw error;
+      }
+    }
+    
+    console.log('\n🎉 Workflow completed successfully!');
+  }
+  
+  /**
+   * 各ステージを実行
+   */
+  private async executeStage(stage: WorkflowStage): Promise<void> {
+    switch (stage) {
+      case 'requirements':
+        console.log('  Syncing requirements to Confluence...');
+        await syncToConfluence(this.config.feature, 'requirements');
+        break;
+        
+      case 'design':
+        console.log('  Syncing design to Confluence...');
+        await syncToConfluence(this.config.feature, 'design');
+        break;
+        
+      case 'tasks':
+        console.log('  Creating JIRA tasks...');
+        await syncTasksToJIRA(this.config.feature);
+        break;
+        
+      case 'implement':
+        console.log('  Implementation phase - manual step');
+        console.log('  Use: /kiro:spec-impl <feature> <tasks>');
+        break;
+        
+      case 'test':
+        console.log('  Test phase - execute tests');
+        // TODO: テスト実行とレポート生成
+        break;
+        
+      case 'release':
+        console.log('  Release preparation');
+        // TODO: リリースノート生成とJIRA Release作成
+        break;
+    }
+  }
+  
+  /**
+   * 承認ゲートがあるかチェック
+   */
+  private hasApprovalGate(stage: WorkflowStage): boolean {
+    const gates = this.config.approvalGates;
+    if (!gates) return false;
+    
+    const gateList =
+      stage === 'requirements' ? gates.requirements :
+      stage === 'design' ? gates.design :
+      stage === 'release' ? gates.release :
+      undefined;
+
+    return Array.isArray(gateList) && gateList.length > 0;
+  }
+  
+  /**
+   * 承認を待つ
+   */
+  private async waitForApproval(stage: WorkflowStage): Promise<void> {
+    console.log(`\n⏸️  Approval required for: ${stage}`);
+    
+    const approvers = this.config.approvalGates?.[stage as keyof typeof this.config.approvalGates];
+    if (approvers) {
+      console.log(`  Approvers: ${approvers.join(', ')}`);
+    }
+    
+    console.log('  ✅ Confluence で承認してください');
+    console.log('  ⏳ 承認完了後、次のステージに進みます');
+    
+    // TODO: Confluence APIで承認状態をポーリング
+    // 現在は手動確認
+    console.log('  （手動で承認を確認してください）');
+  }
+}
+
+// CLI実行
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const args = process.argv.slice(2);
+  
+  if (args.length === 0) {
+    console.error('Usage: npm run workflow:run -- --feature <feature_name>');
+    process.exit(1);
+  }
+  
+  const featureIndex = args.indexOf('--feature');
+  const feature = featureIndex >= 0 ? args[featureIndex + 1] : undefined;
+
+  if (featureIndex === -1 || !feature) {
+    console.error('Usage: npm run workflow:run -- --feature <feature_name>');
+    process.exit(1);
+  }
+  
+  const workflowConfig: WorkflowConfig = {
+    feature,
+    stages: ['requirements', 'design', 'tasks', 'implement', 'test', 'release'],
+    approvalGates: {
+      requirements: ['企画', '部長'],
+      design: ['アーキテクト', '部長'],
+      release: ['SM', '部長']
+    }
+  };
+  
+  const orchestrator = new WorkflowOrchestrator(workflowConfig);
+  
+  orchestrator.run()
+    .then(() => process.exit(0))
+    .catch((error) => {
+      console.error('❌ Workflow failed:', error.message);
+      process.exit(1);
+    });
+}