AIDeveloper-PC/requirements_generator/main.py

#!/usr/bin/env python3
# main.py - 主入口：支持交互式 & 非交互式两种运行模式
import os
import sys
from typing import Dict, List

import click
from rich.console import Console
from rich.table import Table
from rich.panel import Panel
from rich.prompt import Prompt, Confirm

import config
from database.db_manager import DBManager
from database.models import Project, RawRequirement, FunctionalRequirement
from core.llm_client import LLMClient
from core.requirement_analyzer import RequirementAnalyzer
from core.code_generator import CodeGenerator
from utils.file_handler import read_file_auto, merge_knowledge_files
from utils.output_writer import (
    ensure_project_dir, build_project_output_dir,
    write_project_readme, write_function_signatures_json,
    validate_all_signatures, patch_signatures_with_url,
)

console = Console()
db      = DBManager()


# ══════════════════════════════════════════════════════
#  显示工具函数
# ══════════════════════════════════════════════════════

def print_banner():
    console.print(Panel.fit(
        "[bold cyan]🚀 需求分析 & 代码生成工具[/bold cyan]\n"
        "[dim]Powered by LLM · SQLite · Python[/dim]",
        border_style="cyan",
    ))


def print_functional_requirements(reqs: List[FunctionalRequirement]):
    """以表格形式展示功能需求列表（含模块列）"""
    table = Table(title="📋 功能需求列表", show_lines=True)
    table.add_column("序号",   style="cyan",    width=6)
    table.add_column("ID",     style="dim",     width=6)
    table.add_column("模块",   style="magenta", width=15)
    table.add_column("标题",   style="bold",    width=18)
    table.add_column("函数名",                  width=25)
    table.add_column("优先级",                  width=8)
    table.add_column("描述",                    width=35)

    priority_color = {"high": "red", "medium": "yellow", "low": "green"}
    for req in reqs:
        color = priority_color.get(req.priority, "white")
        table.add_row(
            str(req.index_no),
            str(req.id) if req.id else "-",
            req.module or config.DEFAULT_MODULE,
            req.title,
            f"[code]{req.function_name}[/code]",
            f"[{color}]{req.priority}[/{color}]",
            req.description[:50] + "..." if len(req.description) > 50 else req.description,
        )
    console.print(table)


def print_module_summary(reqs: List[FunctionalRequirement]):
    """打印模块分组摘要"""
    module_map: Dict[str, List[str]] = {}
    for req in reqs:
        m = req.module or config.DEFAULT_MODULE
        module_map.setdefault(m, []).append(req.function_name)

    table = Table(title="📦 功能模块分组", show_lines=True)
    table.add_column("模块",     style="magenta bold", width=20)
    table.add_column("函数数量", style="cyan",         width=8)
    table.add_column("函数列表",                       width=50)
    for module, funcs in sorted(module_map.items()):
        table.add_row(module, str(len(funcs)), ", ".join(funcs))
    console.print(table)


def print_signatures_preview(signatures: List[dict]):
    """以表格形式预览函数签名列表（含 module / url 列）"""
    table = Table(title="📄 函数签名预览", show_lines=True)
    table.add_column("需求编号", style="cyan",    width=8)
    table.add_column("模块",     style="magenta", width=15)
    table.add_column("函数名",   style="bold",    width=22)
    table.add_column("参数数",                    width=6)
    table.add_column("返回类型",                  width=10)
    table.add_column("URL",      style="dim",     width=28)

    for sig in signatures:
        ret         = sig.get("return") or {}
        url         = sig.get("url", "")
        url_display = os.path.basename(url) if url else "[dim]待生成[/dim]"
        table.add_row(
            sig.get("requirement_id", "-"),
            sig.get("module", "-"),
            sig.get("name", "-"),
            str(len(sig.get("parameters", {}))),
            ret.get("type", "void"),
            url_display,
        )
    console.print(table)


# ══════════════════════════════════════════════════════
#  Step 1：项目初始化
# ══════════════════════════════════════════════════════

def step_init_project(
    project_name:    str  = None,
    language:        str  = None,
    description:     str  = "",
    non_interactive: bool = False,
) -> Project:
    console.print(
        "\n[bold]Step 1 · 项目配置[/bold]"
        + (" [dim](非交互)[/dim]" if non_interactive else ""),
        style="blue",
    )
    if not non_interactive:
        project_name = project_name or Prompt.ask("📁 项目名称")
        language     = language or Prompt.ask(
            "💻 目标语言", default=config.DEFAULT_LANGUAGE,
            choices=["python","javascript","typescript","java","go","rust"],
        )
        description = description or Prompt.ask("📝 项目描述（可选）", default="")
    else:
        if not project_name:
            raise ValueError("非交互模式下 --project-name 为必填项")
        language = language or config.DEFAULT_LANGUAGE
        console.print(f"  项目: {project_name}  语言: {language}")

    existing = db.get_project_by_name(project_name)
    if existing:
        if non_interactive:
            console.print(f"[green]✓ 已加载项目: {project_name} (ID={existing.id})[/green]")
            return existing
        if Confirm.ask(f"⚠️  项目 '{project_name}' 已存在，继续使用？"):
            console.print(f"[green]✓ 已加载项目: {project_name} (ID={existing.id})[/green]")
            return existing
        project_name = Prompt.ask("请输入新的项目名称")

    project    = Project(
        name        = project_name,
        language    = language,
        output_dir  = build_project_output_dir(project_name),
        description = description,
    )
    project.id = db.create_project(project)
    console.print(f"[green]✓ 项目已创建: {project_name} (ID={project.id})[/green]")
    return project


# ══════════════════════════════════════════════════════
#  Step 2：输入原始需求 & 知识库
# ══════════════════════════════════════════════════════

def step_input_requirement(
    project:          Project,
    requirement_text: str   = None,
    requirement_file: str   = None,
    knowledge_files:  list  = None,
    non_interactive:  bool  = False,
) -> tuple:
    console.print(
        "\n[bold]Step 2 · 输入原始需求[/bold]"
        + (" [dim](非交互)[/dim]" if non_interactive else ""),
        style="blue",
    )
    raw_text    = ""
    source_name = None
    source_type = "text"

    if non_interactive:
        if requirement_file:
            raw_text    = read_file_auto(requirement_file)
            source_name = os.path.basename(requirement_file)
            source_type = "file"
            console.print(f"  需求文件: {source_name} ({len(raw_text)} 字符)")
        elif requirement_text:
            raw_text    = requirement_text
            console.print(f"  需求文本: {raw_text[:80]}{'...' if len(raw_text)>80 else ''}")
        else:
            raise ValueError("非交互模式下必须提供 --requirement-text 或 --requirement-file")
    else:
        input_type = Prompt.ask("📥 需求输入方式", choices=["text","file"], default="text")
        if input_type == "text":
            console.print("[dim]请输入原始需求（输入空行结束）：[/dim]")
            lines = []
            while True:
                line = input()
                if line == "" and lines:
                    break
                lines.append(line)
            raw_text = "\n".join(lines)
        else:
            fp          = Prompt.ask("📂 需求文件路径")
            raw_text    = read_file_auto(fp)
            source_name = os.path.basename(fp)
            source_type = "file"
            console.print(f"[green]✓ 已读取: {source_name} ({len(raw_text)} 字符)[/green]")

    knowledge_text = ""
    if non_interactive:
        if knowledge_files:
            knowledge_text = merge_knowledge_files(list(knowledge_files))
            console.print(f"  知识库: {len(knowledge_files)} 个文件，{len(knowledge_text)} 字符")
    else:
        if Confirm.ask("📚 是否输入知识库文件？", default=False):
            kb_paths = []
            while True:
                p = Prompt.ask("知识库文件路径（留空结束）", default="")
                if not p:
                    break
                if os.path.exists(p):
                    kb_paths.append(p)
                    console.print(f"  [green]+ {p}[/green]")
                else:
                    console.print(f"  [red]文件不存在: {p}[/red]")
            if kb_paths:
                knowledge_text = merge_knowledge_files(kb_paths)
                console.print(f"[green]✓ 知识库已合并 ({len(knowledge_text)} 字符)[/green]")

    return raw_text, knowledge_text, source_name, source_type


# ══════════════════════════════════════════════════════
#  Step 3：LLM 分解需求
# ══════════════════════════════════════════════════════

def step_decompose_requirements(
    project:         Project,
    raw_text:        str,
    knowledge_text:  str,
    source_name:     str,
    source_type:     str,
    non_interactive: bool = False,
) -> tuple:
    console.print(
        "\n[bold]Step 3 · LLM 需求分解[/bold]"
        + (" [dim](非交互)[/dim]" if non_interactive else ""),
        style="blue",
    )
    raw_req = RawRequirement(
        project_id  = project.id,
        content     = raw_text,
        source_type = source_type,
        source_name = source_name,
        knowledge   = knowledge_text or None,
    )
    raw_req_id = db.create_raw_requirement(raw_req)
    console.print(f"[dim]原始需求已存储 (ID={raw_req_id})[/dim]")

    with console.status("[bold yellow]🤖 LLM 正在分解需求...[/bold yellow]"):
        llm       = LLMClient()
        analyzer  = RequirementAnalyzer(llm)
        func_reqs = analyzer.decompose(
            raw_requirement = raw_text,
            project_id      = project.id,
            raw_req_id      = raw_req_id,
            knowledge       = knowledge_text,
        )

    for req in func_reqs:
        req.id = db.create_functional_requirement(req)

    console.print(f"[green]✓ 已生成 {len(func_reqs)} 个功能需求[/green]")
    return raw_req_id, func_reqs


# ══════════════════════════════════════════════════════
#  Step 4：模块分类（可选重新分类）
# ══════════════════════════════════════════════════════

def step_classify_modules(
    project:         Project,
    func_reqs:       List[FunctionalRequirement],
    knowledge_text:  str  = "",
    non_interactive: bool = False,
) -> List[FunctionalRequirement]:
    """
    Step 4：对功能需求进行模块分类。

    - 非交互模式：直接使用 LLM 分类结果
    - 交互模式：展示 LLM 分类结果，允许用户手动调整
    """
    console.print(
        "\n[bold]Step 4 · 功能模块分类[/bold]"
        + (" [dim](非交互)[/dim]" if non_interactive else ""),
        style="blue",
    )

    # LLM 自动分类
    with console.status("[bold yellow]🤖 LLM 正在进行模块分类...[/bold yellow]"):
        llm      = LLMClient()
        analyzer = RequirementAnalyzer(llm)
        try:
            updates = analyzer.classify_modules(func_reqs, knowledge_text)
            # 回写 module 到 func_reqs 对象
            name_to_module = {u["function_name"]: u["module"] for u in updates}
            for req in func_reqs:
                req.module = name_to_module.get(req.function_name, config.DEFAULT_MODULE)
                db.update_functional_requirement(req)
            console.print(f"[green]✓ LLM 模块分类完成[/green]")
        except Exception as e:
            console.print(f"[yellow]⚠ 模块分类失败，保留原有模块: {e}[/yellow]")

    print_module_summary(func_reqs)

    if non_interactive:
        return func_reqs

    # 交互式调整
    while True:
        console.print(
            "\n模块操作: [cyan]r[/cyan]=重新分类  "
            "[cyan]e[/cyan]=手动编辑某需求的模块  [cyan]ok[/cyan]=确认继续"
        )
        action = Prompt.ask("请选择操作", default="ok").strip().lower()

        if action == "ok":
            break

        elif action == "r":
            # 重新触发 LLM 分类
            with console.status("[bold yellow]🤖 重新分类中...[/bold yellow]"):
                try:
                    updates = analyzer.classify_modules(func_reqs, knowledge_text)
                    name_to_module = {u["function_name"]: u["module"] for u in updates}
                    for req in func_reqs:
                        req.module = name_to_module.get(req.function_name, config.DEFAULT_MODULE)
                        db.update_functional_requirement(req)
                    console.print("[green]✓ 重新分类完成[/green]")
                except Exception as e:
                    console.print(f"[red]重新分类失败: {e}[/red]")
            print_module_summary(func_reqs)

        elif action == "e":
            print_functional_requirements(func_reqs)
            idx_str = Prompt.ask("输入要修改模块的需求序号")
            if not idx_str.isdigit():
                continue
            idx    = int(idx_str)
            target = next((r for r in func_reqs if r.index_no == idx), None)
            if target is None:
                console.print("[red]序号不存在[/red]")
                continue
            new_module     = Prompt.ask(
                f"新模块名（当前: {target.module}）",
                default=target.module or config.DEFAULT_MODULE,
            )
            target.module  = new_module.strip() or config.DEFAULT_MODULE
            db.update_functional_requirement(target)
            console.print(f"[green]✓ 已更新 '{target.function_name}' → 模块: {target.module}[/green]")
            print_module_summary(func_reqs)

    return func_reqs


# ══════════════════════════════════════════════════════
#  Step 5：编辑功能需求
# ══════════════════════════════════════════════════════

def step_edit_requirements(
    project:         Project,
    func_reqs:       List[FunctionalRequirement],
    raw_req_id:      int,
    non_interactive: bool = False,
    skip_indices:    list = None,
) -> List[FunctionalRequirement]:
    console.print(
        "\n[bold]Step 5 · 编辑功能需求[/bold]"
        + (" [dim](非交互)[/dim]" if non_interactive else ""),
        style="blue",
    )

    if non_interactive:
        if skip_indices:
            to_skip = set(skip_indices)
            removed, kept = [], []
            for req in func_reqs:
                if req.index_no in to_skip:
                    db.delete_functional_requirement(req.id)
                    removed.append(req.title)
                else:
                    kept.append(req)
            func_reqs = kept
            for i, req in enumerate(func_reqs, 1):
                req.index_no = i
                db.update_functional_requirement(req)
            if removed:
                console.print(f"  [red]已跳过: {', '.join(removed)}[/red]")
        print_functional_requirements(func_reqs)
        return func_reqs

    while True:
        print_functional_requirements(func_reqs)
        console.print(
            "\n操作: [cyan]d[/cyan]=删除  [cyan]a[/cyan]=添加  "
            "[cyan]e[/cyan]=编辑  [cyan]ok[/cyan]=确认继续"
        )
        action = Prompt.ask("请选择操作", default="ok").strip().lower()

        if action == "ok":
            break

        elif action == "d":
            idx_str   = Prompt.ask("输入要删除的序号（多个用逗号分隔）")
            to_delete = {int(x.strip()) for x in idx_str.split(",") if x.strip().isdigit()}
            removed, kept = [], []
            for req in func_reqs:
                if req.index_no in to_delete:
                    db.delete_functional_requirement(req.id)
                    removed.append(req.title)
                else:
                    kept.append(req)
            func_reqs = kept
            for i, req in enumerate(func_reqs, 1):
                req.index_no = i
                db.update_functional_requirement(req)
            console.print(f"[red]✗ 已删除: {', '.join(removed)}[/red]")

        elif action == "a":
            title         = Prompt.ask("功能标题")
            description   = Prompt.ask("功能描述")
            func_name     = Prompt.ask("函数名 (snake_case)")
            priority      = Prompt.ask(
                "优先级", choices=["high","medium","low"], default="medium"
            )
            module        = Prompt.ask(
                "所属模块（snake_case，留空使用默认）",
                default=config.DEFAULT_MODULE,
            )
            new_req = FunctionalRequirement(
                project_id    = project.id,
                raw_req_id    = raw_req_id,
                index_no      = len(func_reqs) + 1,
                title         = title,
                description   = description,
                function_name = func_name,
                priority      = priority,
                module        = module.strip() or config.DEFAULT_MODULE,
                is_custom     = True,
            )
            new_req.id = db.create_functional_requirement(new_req)
            func_reqs.append(new_req)
            console.print(f"[green]✓ 已添加: {title} → 模块: {new_req.module}[/green]")

        elif action == "e":
            idx_str = Prompt.ask("输入要编辑的序号")
            if not idx_str.isdigit():
                continue
            idx    = int(idx_str)
            target = next((r for r in func_reqs if r.index_no == idx), None)
            if target is None:
                console.print("[red]序号不存在[/red]")
                continue
            target.title         = Prompt.ask("新标题",   default=target.title)
            target.description   = Prompt.ask("新描述",   default=target.description)
            target.function_name = Prompt.ask("新函数名", default=target.function_name)
            target.priority      = Prompt.ask(
                "新优先级", choices=["high","medium","low"], default=target.priority
            )
            target.module        = Prompt.ask(
                "新模块", default=target.module or config.DEFAULT_MODULE
            ).strip() or config.DEFAULT_MODULE
            db.update_functional_requirement(target)
            console.print(f"[green]✓ 已更新: {target.title}[/green]")

    return func_reqs


# ══════════════════════════════════════════════════════
#  Step 6A：生成函数签名 JSON（初版，不含 url）
# ══════════════════════════════════════════════════════

def step_generate_signatures(
    project:         Project,
    func_reqs:       List[FunctionalRequirement],
    output_dir:      str,
    knowledge_text:  str,
    json_file_name:  str  = "function_signatures.json",
    non_interactive: bool = False,
) -> tuple:
    console.print(
        "\n[bold]Step 6A · 生成函数签名 JSON[/bold]"
        + (" [dim](非交互)[/dim]" if non_interactive else ""),
        style="blue",
    )
    llm      = LLMClient()
    analyzer = RequirementAnalyzer(llm)
    success_count = 0
    fail_count    = 0

    def on_progress(index, total, req, signature, error):
        nonlocal success_count, fail_count
        if error:
            console.print(
                f"  [{index}/{total}] [yellow]⚠ {req.title} 签名生成失败"
                f"（降级）: {error}[/yellow]"
            )
            fail_count += 1
        else:
            console.print(
                f"  [{index}/{total}] [green]✓ {req.title}[/green] "
                f"[dim]{req.module}[/dim] → {signature.get('name')}()"
            )
            success_count += 1

    console.print(f"[yellow]正在为 {len(func_reqs)} 个功能需求生成函数签名...[/yellow]")
    signatures = analyzer.build_function_signatures_batch(
        func_reqs   = func_reqs,
        knowledge   = knowledge_text,
        on_progress = on_progress,
    )

    # 校验
    report = validate_all_signatures(signatures)
    if report:
        console.print(f"[yellow]⚠ {len(report)} 个签名存在结构问题：[/yellow]")
        for fname, errs in report.items():
            for err in errs:
                console.print(f"  [yellow]· {fname}: {err}[/yellow]")
    else:
        console.print("[green]✓ 所有签名结构校验通过[/green]")

    json_path = write_function_signatures_json(
        output_dir          = output_dir,
        signatures          = signatures,
        project_name        = project.name,
        project_description = project.description or "",
        file_name           = json_file_name,
    )
    console.print(
        f"[green]✓ 签名 JSON 初版已写入: [cyan]{os.path.abspath(json_path)}[/cyan][/green]\n"
        f"  成功: {success_count}  降级: {fail_count}"
    )
    return signatures, json_path


# ══════════════════════════════════════════════════════
#  Step 6B：生成代码文件（按模块写入子目录）
# ══════════════════════════════════════════════════════

def step_generate_code(
    project:         Project,
    func_reqs:       List[FunctionalRequirement],
    output_dir:      str,
    knowledge_text:  str,
    signatures:      List[dict],
    non_interactive: bool = False,
) -> Dict[str, str]:
    """
    批量生成代码文件，按 req.module 路由到 output_dir/<module>/ 子目录。

    Returns:
        func_name_to_url: {函数名: 代码文件绝对路径}
    """
    console.print(
        "\n[bold]Step 6B · 生成代码文件[/bold]"
        + (" [dim](非交互)[/dim]" if non_interactive else ""),
        style="blue",
    )
    generator         = CodeGenerator(LLMClient())
    success_count     = 0
    fail_count        = 0
    func_name_to_url: Dict[str, str] = {}

    def on_progress(index, total, req, code_file, error):
        nonlocal success_count, fail_count
        if error:
            console.print(f"  [{index}/{total}] [red]✗ {req.title}: {error}[/red]")
            fail_count += 1
        else:
            db.upsert_code_file(code_file)
            req.status = "generated"
            db.update_functional_requirement(req)
            func_name_to_url[req.function_name] = os.path.abspath(code_file.file_path)
            console.print(
                f"  [{index}/{total}] [green]✓ {req.title}[/green] "
                f"[dim]{req.module}/{code_file.file_name}[/dim]"
            )
            success_count += 1

    console.print(
        f"[yellow]开始生成 {len(func_reqs)} 个代码文件（按模块分目录）...[/yellow]"
    )
    generator.generate_batch(
        func_reqs   = func_reqs,
        output_dir  = output_dir,
        language    = project.language,
        knowledge   = knowledge_text,
        signatures  = signatures,
        on_progress = on_progress,
    )

    # 生成 README（含模块列表）
    modules = list({req.module or config.DEFAULT_MODULE for req in func_reqs})
    req_summary = "\n".join(
        f"{i+1}. **{r.title}** (`{r.module}/{r.function_name}`) - {r.description[:80]}"
        for i, r in enumerate(func_reqs)
    )
    write_project_readme(
        output_dir           = output_dir,
        project_name         = project.name,
        project_description  = project.description or "",
        requirements_summary = req_summary,
        modules              = modules,
    )

    console.print(Panel(
        f"[bold green]✅ 代码生成完成！[/bold green]\n"
        f"成功: {success_count}  失败: {fail_count}\n"
        f"输出目录: [cyan]{os.path.abspath(output_dir)}[/cyan]",
        border_style="green",
    ))
    return func_name_to_url


# ══════════════════════════════════════════════════════
#  Step 6C：回写 url 字段并刷新 JSON
# ══════════════════════════════════════════════════════

def step_patch_signatures_url(
    project:          Project,
    signatures:       List[dict],
    func_name_to_url: Dict[str, str],
    output_dir:       str,
    json_file_name:   str,
    non_interactive:  bool = False,
) -> str:
    console.print(
        "\n[bold]Step 6C · 回写代码路径（url）到签名 JSON[/bold]"
        + (" [dim](非交互)[/dim]" if non_interactive else ""),
        style="blue",
    )
    patch_signatures_with_url(signatures, func_name_to_url)

    patched   = sum(1 for s in signatures if s.get("url"))
    unpatched = len(signatures) - patched
    if unpatched:
        console.print(f"[yellow]⚠ {unpatched} 个函数 url 未回写（代码生成失败）[/yellow]")

    print_signatures_preview(signatures)

    json_path = write_function_signatures_json(
        output_dir          = output_dir,
        signatures          = signatures,
        project_name        = project.name,
        project_description = project.description or "",
        file_name           = json_file_name,
    )
    console.print(
        f"[green]✓ 签名 JSON 已更新（含 url）: "
        f"[cyan]{os.path.abspath(json_path)}[/cyan][/green]\n"
        f"  已回写: {patched}  未回写: {unpatched}"
    )
    return os.path.abspath(json_path)


# ══════════════════════════════════════════════════════
#  核心工作流
# ══════════════════════════════════════════════════════

def run_workflow(
    project_name:     str   = None,
    language:         str   = None,
    description:      str   = "",
    requirement_text: str   = None,
    requirement_file: str   = None,
    knowledge_files:  tuple = (),
    skip_indices:     list  = None,
    json_file_name:   str   = "function_signatures.json",
    non_interactive:  bool  = False,
):
    """完整工作流 Step 1 → 6C"""
    print_banner()

    # Step 1：项目初始化
    project = step_init_project(
        project_name    = project_name,
        language        = language,
        description     = description,
        non_interactive = non_interactive,
    )

    # Step 2：输入原始需求
    raw_text, knowledge_text, source_name, source_type = step_input_requirement(
        project          = project,
        requirement_text = requirement_text,
        requirement_file = requirement_file,
        knowledge_files  = list(knowledge_files) if knowledge_files else [],
        non_interactive  = non_interactive,
    )

    # Step 3：LLM 需求分解
    raw_req_id, func_reqs = step_decompose_requirements(
        project         = project,
        raw_text        = raw_text,
        knowledge_text  = knowledge_text,
        source_name     = source_name,
        source_type     = source_type,
        non_interactive = non_interactive,
    )

    # Step 4：模块分类
    func_reqs = step_classify_modules(
        project         = project,
        func_reqs       = func_reqs,
        knowledge_text  = knowledge_text,
        non_interactive = non_interactive,
    )

    # Step 5：编辑功能需求
    func_reqs = step_edit_requirements(
        project         = project,
        func_reqs       = func_reqs,
        raw_req_id      = raw_req_id,
        non_interactive = non_interactive,
        skip_indices    = skip_indices or [],
    )

    if not func_reqs:
        console.print("[red]⚠ 功能需求列表为空，流程终止[/red]")
        return

    output_dir = ensure_project_dir(project.name)

    # Step 6A：生成函数签名
    signatures, json_path = step_generate_signatures(
        project         = project,
        func_reqs       = func_reqs,
        output_dir      = output_dir,
        knowledge_text  = knowledge_text,
        json_file_name  = json_file_name,
        non_interactive = non_interactive,
    )

    # Step 6B：生成代码文件
    func_name_to_url = step_generate_code(
        project         = project,
        func_reqs       = func_reqs,
        output_dir      = output_dir,
        knowledge_text  = knowledge_text,
        signatures      = signatures,
        non_interactive = non_interactive,
    )

    # Step 6C：回写 url，刷新 JSON
    json_path = step_patch_signatures_url(
        project          = project,
        signatures       = signatures,
        func_name_to_url = func_name_to_url,
        output_dir       = output_dir,
        json_file_name   = json_file_name,
        non_interactive  = non_interactive,
    )

    # 最终汇总
    modules = sorted({req.module or config.DEFAULT_MODULE for req in func_reqs})
    console.print(Panel(
        f"[bold cyan]🎉 全部流程完成！[/bold cyan]\n"
        f"项目:     [bold]{project.name}[/bold]\n"
        f"描述:     {project.description or '(无)'}\n"
        f"模块:     {', '.join(modules)}\n"
        f"代码目录: [cyan]{os.path.abspath(output_dir)}[/cyan]\n"
        f"签名文件: [cyan]{json_path}[/cyan]",
        border_style="cyan",
    ))


# ══════════════════════════════════════════════════════
#  CLI 入口（click）
# ══════════════════════════════════════════════════════

@click.command()
@click.option("--non-interactive",  is_flag=True, default=False,
              help="以非交互模式运行")
@click.option("--project-name",    "-p", default=None,  help="项目名称")
@click.option("--language",        "-l", default=None,
              type=click.Choice(["python","javascript","typescript","java","go","rust"]),
              help=f"目标代码语言（默认: {config.DEFAULT_LANGUAGE}）")
@click.option("--description",     "-d", default="",    help="项目描述")
@click.option("--requirement-text","-r", default=None,  help="原始需求文本")
@click.option("--requirement-file","-f", default=None,
              type=click.Path(exists=True), help="原始需求文件路径")
@click.option("--knowledge-file",  "-k", default=None, multiple=True,
              type=click.Path(exists=True), help="知识库文件（可多次指定）")
@click.option("--skip-index",      "-s", default=None, multiple=True, type=int,
              help="跳过的功能需求序号（可多次指定）")
@click.option("--json-file-name",  "-j", default="function_signatures.json",
              help="签名 JSON 文件名")
def cli(
    non_interactive, project_name, language, description,
    requirement_text, requirement_file, knowledge_file,
    skip_index, json_file_name,
):
    """
    需求分析 & 代码生成工具

    \b
    交互式运行：
      python main.py

    \b
    非交互式运行示例：
      python main.py --non-interactive \\
        --project-name "UserSystem" \\
        --description "用户管理系统后端服务" \\
        --language python \\
        --requirement-text "用户管理系统，包含注册、登录、修改密码功能"
    """
    try:
        run_workflow(
            project_name     = project_name,
            language         = language,
            description      = description,
            requirement_text = requirement_text,
            requirement_file = requirement_file,
            knowledge_files  = knowledge_file,
            skip_indices     = list(skip_index) if skip_index else [],
            json_file_name   = json_file_name,
            non_interactive  = non_interactive,
        )
    except KeyboardInterrupt:
        console.print("\n[yellow]用户中断，退出[/yellow]")
        sys.exit(0)
    except Exception as e:
        console.print(f"\n[bold red]❌ 错误: {e}[/bold red]")
        import traceback
        traceback.print_exc()
        sys.exit(1)


if __name__ == "__main__":
    cli()