@sk8metal/michi-cli 0.14.1 → 0.20.0

package/scripts/utils/project-analyzer.ts

@@ -0,0 +1,429 @@
+/**
+ * ProjectAnalyzer クラス
+ * project-finder, project-detector, language-detector の統合
+ */
+
+import { existsSync } from 'fs';
+import { safeReadFileOrThrow } from './safe-file-reader.js';
+import { resolve, join, dirname } from 'path';
+import type { Result } from './types/validation.js';
+import { success, failure } from './types/validation.js';
+
+/**
+ * Project detection error types
+ */
+export type ProjectError =
+  | { type: 'FileNotFound'; path: string }
+  | { type: 'InvalidJSON'; path: string; cause: string }
+  | { type: 'MissingField'; field: string }
+  | { type: 'Unknown'; message: string };
+
+/**
+ * Programming language types
+ */
+export type Language = 'nodejs' | 'java' | 'php' | 'python' | 'go' | 'rust' | 'unknown';
+
+/**
+ * Project information (from project-detector)
+ */
+export interface ProjectInfo {
+  language: Language;
+  buildTool: string;
+  testFramework?: string;
+  hasCI: boolean;
+  hasDependencies: boolean;
+  packageManager?: string;
+}
+
+/**
+ * Project metadata (from project-meta)
+ */
+export interface ProjectMetadata {
+  projectId: string;
+  projectName: string;
+  jiraProjectKey: string;
+  confluenceLabels: string[];
+  status: 'active' | 'inactive' | 'completed';
+  team: string[];
+  stakeholders: string[];
+  repository: string;
+  description?: string;
+}
+
+/**
+ * ProjectAnalyzer class
+ * Unified interface for project detection utilities
+ */
+export class ProjectAnalyzer {
+  /**
+   * Find project root directory
+   * Searches for .git or projects/ directory
+   *
+   * @param startPath - Starting directory (default: process.cwd())
+   * @returns Result<string, ProjectError> - Project root path or error
+   */
+  findProjectRoot(startPath: string = process.cwd()): Result<string, ProjectError> {
+    try {
+      let currentDir = resolve(startPath);
+      const root = resolve('/');
+
+      while (currentDir !== root && currentDir !== dirname(currentDir)) {
+        // Check for .git directory or projects/ directory
+        if (existsSync(join(currentDir, '.git')) || existsSync(join(currentDir, 'projects'))) {
+          return success(currentDir);
+        }
+
+        const parentDir = dirname(currentDir);
+        if (parentDir === currentDir) {
+          break;
+        }
+        currentDir = parentDir;
+      }
+
+      // If no repository root found, return starting directory
+      return success(resolve(startPath));
+    } catch (error) {
+      return failure([{
+        type: 'Unknown',
+        message: error instanceof Error ? error.message : String(error)
+      }]);
+    }
+  }
+
+  /**
+   * Detect programming language from project files
+   *
+   * @param projectRoot - Project root directory (default: process.cwd())
+   * @returns Result<Language, ProjectError> - Detected language or error
+   */
+  detectLanguage(projectRoot: string = process.cwd()): Result<Language, ProjectError> {
+    try {
+      // Node.js/TypeScript
+      if (existsSync(join(projectRoot, 'package.json'))) {
+        return success('nodejs' as Language);
+      }
+
+      // Java
+      if (existsSync(join(projectRoot, 'build.gradle')) ||
+          existsSync(join(projectRoot, 'build.gradle.kts')) ||
+          existsSync(join(projectRoot, 'pom.xml'))) {
+        return success('java' as Language);
+      }
+
+      // PHP
+      if (existsSync(join(projectRoot, 'composer.json'))) {
+        return success('php' as Language);
+      }
+
+      // Python
+      if (existsSync(join(projectRoot, 'requirements.txt')) ||
+          existsSync(join(projectRoot, 'pyproject.toml')) ||
+          existsSync(join(projectRoot, 'setup.py'))) {
+        return success('python' as Language);
+      }
+
+      // Go
+      if (existsSync(join(projectRoot, 'go.mod'))) {
+        return success('go' as Language);
+      }
+
+      // Rust
+      if (existsSync(join(projectRoot, 'Cargo.toml'))) {
+        return success('rust' as Language);
+      }
+
+      // Unknown
+      return success('unknown' as Language);
+    } catch (error) {
+      return failure([{
+        type: 'Unknown',
+        message: error instanceof Error ? error.message : String(error)
+      }]);
+    }
+  }
+
+  /**
+   * Get project metadata from .kiro/project.json
+   *
+   * @param projectRoot - Project root directory (default: process.cwd())
+   * @returns Result<ProjectMetadata, ProjectError> - Project metadata or error
+   */
+  getProjectMetadata(projectRoot: string = process.cwd()): Result<ProjectMetadata, ProjectError> {
+    const projectJsonPath = resolve(projectRoot, '.kiro/project.json');
+
+    if (!existsSync(projectJsonPath)) {
+      return failure([{
+        type: 'FileNotFound',
+        path: projectJsonPath
+      }]);
+    }
+
+    try {
+      const content = safeReadFileOrThrow(projectJsonPath, 'utf-8');
+      const meta = JSON.parse(content) as ProjectMetadata;
+
+      // Validate required fields
+      const requiredFields: (keyof ProjectMetadata)[] = [
+        'projectId',
+        'projectName',
+        'jiraProjectKey',
+        'confluenceLabels'
+      ];
+
+      for (const field of requiredFields) {
+        if (!meta[field]) {
+          return failure([{
+            type: 'MissingField',
+            field: String(field)
+          }]);
+        }
+      }
+
+      // Validate projectId against path traversal attacks
+      if (!this.validateProjectId(meta.projectId)) {
+        return failure([{
+          type: 'Unknown',
+          message: 'Invalid projectId: must contain only alphanumeric characters, hyphens, and underscores'
+        }]);
+      }
+
+      return success(meta);
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        return failure([{
+          type: 'InvalidJSON',
+          path: projectJsonPath,
+          cause: error.message
+        }]);
+      }
+      return failure([{
+        type: 'Unknown',
+        message: error instanceof Error ? error.message : String(error)
+      }]);
+    }
+  }
+
+  /**
+   * Validate project ID against path traversal attacks
+   * Security: Prevents malicious project IDs like "../tmp/evil"
+   *
+   * @param projectId - Project ID to validate
+   * @returns true if valid, false otherwise
+   */
+  private validateProjectId(projectId: string): boolean {
+    // Reject empty or whitespace-only IDs
+    if (!projectId.trim() || /^\s+$/.test(projectId)) {
+      return false;
+    }
+    // Reject path traversal attempts (.. / \)
+    if (projectId.includes('..') || projectId.includes('/') || projectId.includes('\\')) {
+      return false;
+    }
+    // Only allow alphanumeric, hyphens, and underscores
+    return /^[A-Za-z0-9_-]+$/.test(projectId);
+  }
+
+  /**
+   * Get comprehensive project information
+   * Combines language detection with detailed project info
+   *
+   * @param projectRoot - Project root directory (default: process.cwd())
+   * @returns Result<ProjectInfo, ProjectError> - Detailed project information or error
+   */
+  getProjectInfo(projectRoot: string = process.cwd()): Result<ProjectInfo, ProjectError> {
+    try {
+      // Node.js/TypeScript
+      if (existsSync(join(projectRoot, 'package.json'))) {
+        return this.detectNodeJsProject(projectRoot);
+      }
+
+      // Java
+      if (existsSync(join(projectRoot, 'build.gradle')) ||
+          existsSync(join(projectRoot, 'build.gradle.kts'))) {
+        return this.detectJavaProject(projectRoot, 'gradle');
+      }
+
+      if (existsSync(join(projectRoot, 'pom.xml'))) {
+        return this.detectJavaProject(projectRoot, 'maven');
+      }
+
+      // PHP
+      if (existsSync(join(projectRoot, 'composer.json'))) {
+        return this.detectPHPProject(projectRoot);
+      }
+
+      // Python
+      if (existsSync(join(projectRoot, 'requirements.txt')) ||
+          existsSync(join(projectRoot, 'pyproject.toml')) ||
+          existsSync(join(projectRoot, 'setup.py'))) {
+        return this.detectPythonProject(projectRoot);
+      }
+
+      // Go
+      if (existsSync(join(projectRoot, 'go.mod'))) {
+        return this.detectGoProject(projectRoot);
+      }
+
+      // Rust
+      if (existsSync(join(projectRoot, 'Cargo.toml'))) {
+        return this.detectRustProject(projectRoot);
+      }
+
+      // Unknown
+      return success({
+        language: 'unknown',
+        buildTool: 'unknown',
+        hasCI: existsSync(join(projectRoot, '.github/workflows')),
+        hasDependencies: false
+      });
+    } catch (error) {
+      return failure([{
+        type: 'Unknown',
+        message: error instanceof Error ? error.message : String(error)
+      }]);
+    }
+  }
+
+  /**
+   * Detect Node.js project
+   */
+  private detectNodeJsProject(projectRoot: string): Result<ProjectInfo, ProjectError> {
+    try {
+      const packageJson = JSON.parse(safeReadFileOrThrow(join(projectRoot, 'package.json'), 'utf-8'));
+
+      // Detect package manager
+      let packageManager = 'npm';
+      if (existsSync(join(projectRoot, 'pnpm-lock.yaml'))) {
+        packageManager = 'pnpm';
+      } else if (existsSync(join(projectRoot, 'yarn.lock'))) {
+        packageManager = 'yarn';
+      }
+
+      // Detect test framework
+      let testFramework: string | undefined;
+      const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+      if (deps['vitest']) {
+        testFramework = 'vitest';
+      } else if (deps['jest']) {
+        testFramework = 'jest';
+      } else if (deps['mocha']) {
+        testFramework = 'mocha';
+      }
+
+      return success({
+        language: 'nodejs',
+        buildTool: packageManager,
+        testFramework,
+        hasCI: existsSync(join(projectRoot, '.github/workflows')),
+        hasDependencies: true,
+        packageManager
+      });
+    } catch (error) {
+      return failure([{
+        type: 'InvalidJSON',
+        path: join(projectRoot, 'package.json'),
+        cause: error instanceof Error ? error.message : String(error)
+      }]);
+    }
+  }
+
+  /**
+   * Detect Java project
+   */
+  private detectJavaProject(projectRoot: string, buildTool: 'gradle' | 'maven'): Result<ProjectInfo, ProjectError> {
+    return success({
+      language: 'java',
+      buildTool,
+      testFramework: 'junit',
+      hasCI: existsSync(join(projectRoot, '.github/workflows')),
+      hasDependencies: true
+    });
+  }
+
+  /**
+   * Detect PHP project
+   */
+  private detectPHPProject(projectRoot: string): Result<ProjectInfo, ProjectError> {
+    try {
+      const composerJson = JSON.parse(safeReadFileOrThrow(join(projectRoot, 'composer.json'), 'utf-8'));
+
+      // Detect test framework
+      let testFramework: string | undefined;
+      const deps = { ...composerJson.require, ...composerJson['require-dev'] };
+      if (deps['phpunit/phpunit']) {
+        testFramework = 'phpunit';
+      }
+
+      return success({
+        language: 'php',
+        buildTool: 'composer',
+        testFramework,
+        hasCI: existsSync(join(projectRoot, '.github/workflows')),
+        hasDependencies: true
+      });
+    } catch (error) {
+      return failure([{
+        type: 'InvalidJSON',
+        path: join(projectRoot, 'composer.json'),
+        cause: error instanceof Error ? error.message : String(error)
+      }]);
+    }
+  }
+
+  /**
+   * Detect Python project
+   */
+  private detectPythonProject(projectRoot: string): Result<ProjectInfo, ProjectError> {
+    let buildTool = 'pip';
+    let testFramework: string | undefined;
+
+    if (existsSync(join(projectRoot, 'pyproject.toml'))) {
+      buildTool = 'poetry or uv';
+      const pyproject = safeReadFileOrThrow(join(projectRoot, 'pyproject.toml'), 'utf-8');
+      if (pyproject.includes('pytest')) {
+        testFramework = 'pytest';
+      } else if (pyproject.includes('unittest')) {
+        testFramework = 'unittest';
+      }
+    } else if (existsSync(join(projectRoot, 'requirements.txt'))) {
+      const requirements = safeReadFileOrThrow(join(projectRoot, 'requirements.txt'), 'utf-8');
+      if (requirements.includes('pytest')) {
+        testFramework = 'pytest';
+      }
+    }
+
+    return success({
+      language: 'python',
+      buildTool,
+      testFramework,
+      hasCI: existsSync(join(projectRoot, '.github/workflows')),
+      hasDependencies: true
+    });
+  }
+
+  /**
+   * Detect Go project
+   */
+  private detectGoProject(projectRoot: string): Result<ProjectInfo, ProjectError> {
+    return success({
+      language: 'go',
+      buildTool: 'go',
+      testFramework: 'testing',
+      hasCI: existsSync(join(projectRoot, '.github/workflows')),
+      hasDependencies: true
+    });
+  }
+
+  /**
+   * Detect Rust project
+   */
+  private detectRustProject(projectRoot: string): Result<ProjectInfo, ProjectError> {
+    return success({
+      language: 'rust',
+      buildTool: 'cargo',
+      testFramework: 'cargo-test',
+      hasCI: existsSync(join(projectRoot, '.github/workflows')),
+      hasDependencies: true
+    });
+  }
+}

package/scripts/utils/project-detector.ts

@@ -3,7 +3,8 @@
  * 既存ファイルからプロジェクト情報を自動検出
  */
 
-import { existsSync, readFileSync } from 'fs';
+import { existsSync } from 'fs';
+import { safeReadFileOrThrow } from './safe-file-reader.js';
 
 export interface ProjectInfo {
   language: 'nodejs' | 'java' | 'php' | 'python' | 'go' | 'rust' | 'other';
@@ -67,7 +68,7 @@ export function detectProject(projectRoot: string = process.cwd()): ProjectInfo
  * Node.jsプロジェクトを検出
  */
 function detectNodeJsProject(projectRoot: string): ProjectInfo {
-  const packageJson = JSON.parse(readFileSync(`${projectRoot}/package.json`, 'utf-8'));
+  const packageJson = JSON.parse(safeReadFileOrThrow(`${projectRoot}/package.json`, 'utf-8'));
   
   // パッケージマネージャーを検出
   let packageManager = 'npm';
@@ -115,7 +116,7 @@ function detectJavaProject(projectRoot: string, buildTool: 'gradle' | 'maven'):
  * PHPプロジェクトを検出
  */
 function detectPHPProject(projectRoot: string): ProjectInfo {
-  const composerJson = JSON.parse(readFileSync(`${projectRoot}/composer.json`, 'utf-8'));
+  const composerJson = JSON.parse(safeReadFileOrThrow(`${projectRoot}/composer.json`, 'utf-8'));
   
   // テストフレームワークを検出
   let testFramework: string | undefined;
@@ -142,14 +143,14 @@ function detectPythonProject(projectRoot: string): ProjectInfo {
   
   if (existsSync(`${projectRoot}/pyproject.toml`)) {
     buildTool = 'poetry or uv';
-    const pyproject = readFileSync(`${projectRoot}/pyproject.toml`, 'utf-8');
+    const pyproject = safeReadFileOrThrow(`${projectRoot}/pyproject.toml`, 'utf-8');
     if (pyproject.includes('pytest')) {
       testFramework = 'pytest';
     } else if (pyproject.includes('unittest')) {
       testFramework = 'unittest';
     }
   } else if (existsSync(`${projectRoot}/requirements.txt`)) {
-    const requirements = readFileSync(`${projectRoot}/requirements.txt`, 'utf-8');
+    const requirements = safeReadFileOrThrow(`${projectRoot}/requirements.txt`, 'utf-8');
     if (requirements.includes('pytest')) {
       testFramework = 'pytest';
     }

package/scripts/utils/project-finder.ts

@@ -1,78 +1,10 @@
 /**
  * プロジェクト検出ユーティリティ
- * リポジトリルートを検出し、projects/配下のプロジェクトを検索
- * 複数プロジェクトが存在する場合、選択機能を提供
+ * リポジトリルートを検出
  */
 
-import { existsSync, readdirSync } from 'fs';
+import { existsSync } from 'fs';
 import { resolve, join, dirname } from 'path';
-import { readFileSync } from 'fs';
-import type { ProjectMetadata } from './project-meta.js';
-
-export interface ProjectLocation {
-  path: string;
-  projectId: string;
-  projectName: string;
-  jiraProjectKey: string;
-}
-
-/**
- * 指定されたディレクトリに.kiro/project.jsonが存在するか確認
- */
-function hasProjectJson(dir: string): boolean {
-  const projectJsonPath = join(dir, '.kiro', 'project.json');
-  return existsSync(projectJsonPath);
-}
-
-/**
- * プロジェクトメタデータを読み込む
- */
-function loadProjectMetadata(dir: string): ProjectMetadata | null {
-  const projectJsonPath = join(dir, '.kiro', 'project.json');
-  
-  if (!existsSync(projectJsonPath)) {
-    return null;
-  }
-  
-  try {
-    const content = readFileSync(projectJsonPath, 'utf-8');
-    const meta = JSON.parse(content) as ProjectMetadata;
-    return meta;
-  } catch {
-    // パースエラーなどは無視
-    return null;
-  }
-}
-
-/**
- * 現在のディレクトリから親ディレクトリを遡って.kiro/project.jsonを検索
- */
-export function findCurrentProject(startDir: string = process.cwd()): ProjectLocation | null {
-  let currentDir = resolve(startDir);
-  const root = resolve('/');
-  
-  while (currentDir !== root && currentDir !== dirname(currentDir)) {
-    if (hasProjectJson(currentDir)) {
-      const meta = loadProjectMetadata(currentDir);
-      if (meta) {
-        return {
-          path: currentDir,
-          projectId: meta.projectId,
-          projectName: meta.projectName,
-          jiraProjectKey: meta.jiraProjectKey
-        };
-      }
-    }
-    
-    const parentDir = dirname(currentDir);
-    if (parentDir === currentDir) {
-      break;
-    }
-    currentDir = parentDir;
-  }
-  
-  return null;
-}
 
 /**
  * リポジトリルートを検出
@@ -98,87 +30,3 @@ export function findRepositoryRoot(startDir: string = process.cwd()): string {
   // リポジトリルートが見つからない場合、現在のディレクトリを返す
   return resolve(startDir);
 }
-
-/**
- * リポジトリルートからprojects/配下の全プロジェクトを検索
- * 統一されたディレクトリ構成: すべてのプロジェクトはprojects/{project-id}/配下に配置
- */
-export function findAllProjects(
-  searchDir?: string
-): ProjectLocation[] {
-  const projects: ProjectLocation[] = [];
-  
-  // リポジトリルートを検出
-  const repoRoot = searchDir ? findRepositoryRoot(searchDir) : findRepositoryRoot();
-  const projectsDir = join(repoRoot, 'projects');
-  
-  // projects/ディレクトリが存在しない場合は空配列を返す
-  if (!existsSync(projectsDir)) {
-    return projects;
-  }
-  
-  try {
-    // projects/配下のディレクトリを取得
-    const entries = readdirSync(projectsDir, { withFileTypes: true });
-    
-    for (const entry of entries) {
-      // 隠しディレクトリはスキップ
-      if (entry.name.startsWith('.')) {
-        continue;
-      }
-      
-      if (entry.isDirectory()) {
-        const projectDir = join(projectsDir, entry.name);
-        // プロジェクトディレクトリに.kiro/project.jsonがあるか確認
-        if (hasProjectJson(projectDir)) {
-          const meta = loadProjectMetadata(projectDir);
-          if (meta) {
-            projects.push({
-              path: projectDir,
-              projectId: meta.projectId,
-              projectName: meta.projectName,
-              jiraProjectKey: meta.jiraProjectKey
-            });
-          }
-        }
-      }
-    }
-  } catch {
-    // アクセス権限エラーなどは無視
-  }
-  
-  return projects;
-}
-
-/**
- * 複数プロジェクトから選択する（対話的）
- */
-export async function selectProject(
-  projects: ProjectLocation[],
-  question: (prompt: string) => Promise<string>
-): Promise<ProjectLocation | null> {
-  if (projects.length === 0) {
-    return null;
-  }
-  
-  if (projects.length === 1) {
-    return projects[0];
-  }
-  
-  console.log('\n📋 複数のプロジェクトが見つかりました:');
-  projects.forEach((project, index) => {
-    console.log(`  ${index + 1}. ${project.projectName} (${project.projectId}) - ${project.path}`);
-  });
-  
-  const answer = await question(`\n選択してください [1-${projects.length}]: `);
-  const index = parseInt(answer.trim(), 10) - 1;
-  
-  if (index >= 0 && index < projects.length) {
-    return projects[index];
-  }
-  
-  // 無効な入力の場合は最初のプロジェクトを返す
-  console.log('⚠️  無効な選択です。最初のプロジェクトを使用します。');
-  return projects[0];
-}
-