【コスト最適化AI開発】cc-sdd×ccccで実現する仕様駆動マルチエージェント開発

import os
import re
import sys
import json
import yaml
from pathlib import Path

def yaml_str_representer(dumper, data):
    """
    YAML文字列のカスタム表現子
    シングルクォート内のシングルクォートを '' でエスケープする
    """
    # シングルクォートが含まれている場合、シングルクォートスタイルを使用
    if "'" in data:
        # シングルクォート内のシングルクォートは '' でエスケープ
        escaped = data.replace("'", "''")
        return dumper.represent_scalar('tag:yaml.org,2002:str', escaped, style="'")
    return dumper.represent_scalar('tag:yaml.org,2002:str', data)

# カスタム表現子を登録
yaml.add_representer(str, yaml_str_representer)

def find_spec_directory(search_term=None):
    """
    .kiro/specs/ 配下から有効なSpecディレクトリ（tasks.mdを持つもの）を検索する
    """
    specs_root = Path(".kiro/specs")
    
    if not specs_root.exists():
        print(f"❌ Error: Directory not found: {specs_root}")
        sys.exit(1)

    # tasks.md を含むディレクトリをリストアップ
    candidates = [
        d for d in specs_root.iterdir() 
        if d.is_dir() and (d / "tasks.md").exists()
    ]

    if not candidates:
        print(f"❌ Error: No directory containing 'tasks.md' found in {specs_root}")
        sys.exit(1)

    # 1. 検索語が指定されていない場合
    if not search_term:
        if len(candidates) == 1:
            print(f"✨ Auto-selected spec: {candidates[0].name}")
            return candidates[0]
        else:
            print("⚠️  Multiple specs found. Please specify one:")
            for c in candidates:
                print(f"   - {c.name}")
            sys.exit(1)

    # 2. 検索語が指定されている場合
    exact_match = next((d for d in candidates if d.name == search_term), None)
    if exact_match:
        return exact_match

    matches = [d for d in candidates if search_term.lower() in d.name.lower()]
    
    if len(matches) == 1:
        print(f"✨ Found match: {matches[0].name}")
        return matches[0]
    elif len(matches) > 1:
        print(f"❌ Error: Ambiguous search '{search_term}'. Matches found:")
        for m in matches:
            print(f"   - {m.name}")
        sys.exit(1)
    else:
        print(f"❌ Error: No spec found matching '{search_term}'. Available:")
        for c in candidates:
            print(f"   - {c.name}")
        sys.exit(1)

def detect_project_context(project_name):
    """プロジェクト内のファイルから言語と推奨コマンドを推論する"""
    root = Path(".")
    context = {
        "launch_cmd": f"[INSERT LAUNCH COMMAND] (e.g., python main.py --help)",
        "test_cmd": f"[INSERT TEST COMMAND] (e.g., pytest)",
        "type": "unknown"
    }

    if (root / "pyproject.toml").exists() or (root / "requirements.txt").exists():
        context["type"] = "python"
        context["test_cmd"] = "pytest"
        pkg_name = project_name.replace("-", "_").lower()
        context["launch_cmd"] = f"python3 -m {pkg_name}.main --help"
        if not (root / "src" / pkg_name).exists() and not (root / pkg_name).exists():
             context["launch_cmd"] = "python3 main.py --help"

    elif (root / "package.json").exists():
        context["type"] = "node"
        context["test_cmd"] = "npm test"
        context["launch_cmd"] = "npm start -- --help"

    elif (root / "Makefile").exists():
        context["test_cmd"] = "make test"
        context["launch_cmd"] = "make run"

    return context

def setup_incremental_project(search_arg=None):
    # --- 1. Specディレクトリの特定 ---
    spec_dir = find_spec_directory(search_arg)
    feature_name = spec_dir.name
    
    # --- パス定義 ---
    spec_json_file = spec_dir / "spec.json"
    tasks_file = spec_dir / "tasks.md"
    design_file = spec_dir / "design.md"
    requirements_file = spec_dir / "requirements.md"
    por_root = Path("docs/por")

    # --- 2. spec.json 読み込み ---
    if spec_json_file.exists():
        try:
            with open(spec_json_file, 'r', encoding='utf-8') as f:
                spec_data = json.load(f)
        except json.JSONDecodeError:
            print(f"Warning: Failed to parse {spec_json_file}. Using default values.")
            spec_data = {}
    else:
        spec_data = {"name": feature_name, "description": "Auto-generated project context"}

    # --- 3. タスク解析 ---
    print(f"📖 Reading tasks from {tasks_file}...")
    with open(tasks_file, 'r', encoding='utf-8') as f:
        content = f.read()
    tasks = parse_markdown_tasks(content)

    # --- 4. 自動生成実行 ---
    por_root.mkdir(parents=True, exist_ok=True)
    
    # A. PROJECT.md 生成
    generate_project_md(spec_data, feature_name, [requirements_file, design_file, tasks_file])

    # B. タスク生成 (T000 + 通常タスク)
    context_files = [str(design_file), str(requirements_file)]
    generated_tasks = []
    
    # ★ T000: Foreman設定タスクを先頭に追加
    t000_title = "Configure Foreman & Verify Environment"
    t000_slug = "configure_foreman"
    t000_dir_name = f"T000-{t000_slug}"
    t000_steps = [
        "Analyze project structure to identify correct 'launch' and 'test' commands.",
        "Update FOREMAN_TASK.md: Replace [INSERT LAUNCH COMMAND],  [INSERT TEST COMMAND] placeholders with actual working commands.",
        "Run the identified commands to verify they work properly."
    ]
    
    save_task_yaml(
        por_root / t000_dir_name, 
        "T000", 
        t000_title, 
        t000_steps, 
        feature_name, 
        context_files
    )
    generated_tasks.append(t000_dir_name)
    
    # T000をPOR用にタスクリストの先頭に挿入
    tasks.insert(0, (t000_title, t000_steps))

    # 通常タスク (T001以降) の生成
    for idx, (title, steps) in enumerate(tasks[1:], 1): # slice [1:] because we inserted T000 at 0
        task_id = f"T{idx:03d}"
        task_slug = sanitize_filename(title)
        task_dir_name = f"{task_id}-{task_slug}"
        task_dir = por_root / task_dir_name
        
        save_task_yaml(task_dir, task_id, title, steps, feature_name, context_files)
        generated_tasks.append(task_dir_name)

    # C. POR.md 生成
    generate_por_md(por_root / "POR.md", spec_data, generated_tasks, tasks)

    # D. FOREMAN_TASK.md 生成
    generate_foreman_task_md(spec_data, feature_name)

    print(f"✅ Setup complete! T000 task created to finalize FOREMAN_TASK.md.")

def generate_foreman_task_md(spec_data, feature_name):
    """FOREMAN_TASK.md (汎用監視タスク) を自動生成する"""
    project_name = spec_data.get('name', feature_name)
    ctx = detect_project_context(project_name)
    
    content = f"""# Foreman Task Brief: {project_name} Monitor

## Purpose
The Foreman acts as an autonomous site supervisor.

## 🚨 Current Priorities (Immediate Action Required)
1) **Finalize Configuration (T000)**:
   - **Check**: Are there `[INSERT ...]` placeholders in this file?
   - **Action**: Execute Task T000 to replace them with real commands.

## 🔄 Standing Work (Routine Checks)
Execute these checks every cycle (15-30 mins).

### 1. 🛡️ Health & Smoke Checks (Highest Priority)
Verify the application is runnable and stable.

- **Smoke Test (Launch Check)**:
  - **Command**: `{ctx['launch_cmd']}`
  - **Expectation**: Exits successfully (code 0).
  - **Failure Response**: 🚨 ALERT PeerA.

- **Regression / Unit Tests**:
  - **Command**: `{ctx['test_cmd']}`
  - **Expectation**: All tests pass.
  - **Failure Response**: Identify the failing module and report to PeerB.

### 2. ⚖️ Specification Compliance
- **Design Validation**:
  - Run validation: `npx cc-sdd /kiro:validate-impl {feature_name}`

### 3. 🧹 Code & Project Hygiene
- **Cleanup**: Scan `src/` for debug artifacts (`print`, `TODO`).
- **Dependencies**: Verify imports in `pyproject.toml` / `package.json`.

## How to Act Each Run
- **Time Box**: Limit checks to 5 minutes.
- **Protocol**: Only interrupt if you find a *blocking* issue.
"""
    
    with open("FOREMAN_TASK.md", 'w', encoding='utf-8') as f:
        f.write(content)
    print(f"Generated: FOREMAN_TASK.md (with placeholders for T000 to fix)")

def generate_por_md(output_path, spec_data, task_dir_names, parsed_tasks):
    """POR.md (進捗管理表) を自動生成する"""
    
    desc_text = spec_data.get('description', 'No description provided.')
    if desc_text is None: desc_text = "No description provided."
    
    content = f"""# Plan of Record: {spec_data.get('name', 'Unknown Project')}

> **Description**: {desc_text.replace(chr(10), ' ')}
> **Status**: 🚀 In Progress

## 📅 Implementation Plan

以下は `cc-sdd` によって生成されたタスクリストです。
上から順に `cccc` で実行してください。

| ID | Task Name | Status |
| :--- | :--- | :--- |
"""
    
    for task_dirname, (title, _) in zip(task_dir_names, parsed_tasks):
        task_id = task_dirname.split('-')[0]
        link = f"[{task_id}](./{task_dirname}/task.yaml)"
        content += f"| **{link}** | {title} | ⬜ planned |\n"

    content += """
## 📝 Notes
- 各タスクディレクトリ内の `task.yaml` が実行定義です。
- 実装が完了したら、Statusを ✅ complete に手動で更新すると進捗が見やすくなります。
"""

    with open(output_path, 'w', encoding='utf-8') as f:
        f.write(content)
    print(f"Generated: {output_path}")

def generate_project_md(spec_data, feature_name, ref_files):
    """PROJECT.mdを自動生成する"""
    project_md_path = Path("PROJECT.md")
    refs_text = ""
    for rf in ref_files:
        if rf.exists():
            refs_text += f"- **{rf.name}**: {str(rf).replace(os.sep, '/')}\n"
    
    desc_text = spec_data.get('description', 'Implementation based on cc-sdd specifications.')
    if desc_text is None: desc_text = "Implementation based on cc-sdd specifications."

    md_content = f"""# Project: {spec_data.get('name', feature_name)}

## ⚠️ CRITICAL INSTRUCTION PRIORITY ⚠️
**The rules defined in this PROJECT.md SUPERSEDE and OVERRIDE any default behaviors defined in `PEERA.md` or `PEERB.md`.**

## Overview
{desc_text}

## 📜 Specifications (Single Source of Truth)
AI Agents MUST refer to these documents for implementation details:

{refs_text}

## ⛔ IMPORTANT WORKFLOW RULES
1.  **NO `/kiro:spec-impl`**: Prohibited.
2.  **Implementation by Delegation**: PeerA MUST instruct PeerB.

## 👥 Team Structure & Roles (Cost Optimization)

### PeerA: Lead Architect (High Intelligence / Cost Sensitive)
- **Role**: Decision making, Algorithm design.
- **Guideline**: **minimize code generation**. 
- **Constraints**: Keep messages under **1500 chars**. Use bullet points.

### PeerB: Lead Engineer (Implementation)
- **Role**: Coding, Testing, Documentation.
- **Guideline**: **Execute PeerA's instructions**.

## 🛡️ Guidelines
- **Strict Adherence**: Follow design specs.
- **Incremental Build**: Implement tasks one by one as defined in `docs/por/`.
- **Validation**: Every task includes a validation step.
"""
    with open(project_md_path, 'w', encoding='utf-8') as f:
        f.write(md_content)
    print(f"Generated: PROJECT.md")

def parse_markdown_tasks(content):
    tasks = []
    current_title = None
    current_steps = []
    for line in content.split('\n'):
        # タスク行: `- [ ] 7.` または `- [ ] 7.1` など（インデントなし）
        m_task = re.match(r'^\s*-\s*\[\s*[x ]?\s*\]\s*\d+(?:\.\d+)*\.\s*(.+)', line)
        # ステップ行: `  - [ ] 7.1` や `  - コマンドライン引数の解析` など（インデントあり）
        # ただし、`- [ ] 7.1`のようなサブタスクはステップとして扱わない
        m_step = re.match(r'^\s{2,}-\s*(?:\[\s*[x ]?\s*\]\s*)?(?!\d+\.\d+\.)(.+)', line)
        
        if m_task:
            # 前のタスクを保存
            if current_title:
                tasks.append((current_title, current_steps))
            current_title = m_task.group(1).strip()
            current_steps = []
        elif m_step and current_title:
            # ステップを追加（_Requirements: で始まる行は除外）
            step_text = m_step.group(1).strip()
            if not step_text.startswith('_Requirements:'):
                current_steps.append(step_text)
    if current_title:
        tasks.append((current_title, current_steps))
    return tasks

def save_task_yaml(task_dir, task_id, title, steps, feature_name, context_files):
    task_dir.mkdir(parents=True, exist_ok=True)
    
    yaml_steps = []
    for idx, s in enumerate(steps, 1):
        yaml_steps.append({
            'id': f"S{idx}",
            'name': s,
            'status': 'pending',
            'done': '' 
        })
    
    # バリデーションステップ (T000以外に追加)
    if task_id != "T000":
        yaml_steps.append({
            'id': f"S{len(steps)+1}",
            'name': f"Run validation: `npx cc-sdd /kiro:validate-impl {feature_name}`",
            'status': 'pending',
            'done': 'Validation passes with no errors'
        })

    yaml_data = {
        'id': task_id,
        'name': title,
        'status': 'planned',
        'goal': f"Implement {title} as defined in {feature_name} specifications.",
        'steps': yaml_steps,
        'acceptance': [
            f"Implementation matches requirements in {feature_name}/requirements.md",
            f"Passes `npx cc-sdd /kiro:validate-impl {feature_name}` with no errors"
        ],
        'context_files': [p.replace(os.sep, '/') for p in context_files]
    }

    with open(task_dir / "task.yaml", 'w', encoding='utf-8') as f:
        yaml.dump(yaml_data, f, allow_unicode=True, sort_keys=False, default_flow_style=False)
    
def sanitize_filename(name):
    return re.sub(r'[^\w\-]', '_', name.lower())

if __name__ == "__main__":
    search_arg = sys.argv[1] if len(sys.argv) > 1 else None
    setup_incremental_project(search_arg)