codex-rule-maker 0.1.0__py3-none-any.whl

codex_builder/profiles.py

@@ -0,0 +1,437 @@
+"""Framework profile definitions used by the document renderer."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+class UnknownProfileError(ValueError):
+    """Raised when a stack profile is not supported."""
+
+
+@dataclass(frozen=True)
+class FrameworkProfile:
+    """Rules and notes for a supported framework or stack profile."""
+
+    key: str
+    display_name: str
+    philosophy_ko: str
+    philosophy_en: str
+    architecture_ko: tuple[str, ...]
+    architecture_en: tuple[str, ...]
+    framework_rules_ko: tuple[str, ...]
+    framework_rules_en: tuple[str, ...]
+    api_rules_ko: tuple[str, ...]
+    api_rules_en: tuple[str, ...]
+    test_rules_ko: tuple[str, ...]
+    test_rules_en: tuple[str, ...]
+    directories: tuple[str, ...]
+
+    def philosophy(self, language: str) -> str:
+        return self.philosophy_en if language == "en" else self.philosophy_ko
+
+    def architecture(self, language: str) -> tuple[str, ...]:
+        return self.architecture_en if language == "en" else self.architecture_ko
+
+    def framework_rules(self, language: str) -> tuple[str, ...]:
+        return self.framework_rules_en if language == "en" else self.framework_rules_ko
+
+    def api_rules(self, language: str) -> tuple[str, ...]:
+        return self.api_rules_en if language == "en" else self.api_rules_ko
+
+    def test_rules(self, language: str) -> tuple[str, ...]:
+        return self.test_rules_en if language == "en" else self.test_rules_ko
+
+
+FASTAPI_PROFILE = FrameworkProfile(
+    key="fastapi",
+    display_name="FastAPI",
+    philosophy_ko="FastAPI의 가벼운 실행 모델은 유지하되, 코드는 Controller, Service, Repository, Schema, Entity 계층으로 분리한다.",
+    philosophy_en="Keep FastAPI's lightweight runtime model, but separate code into Controller, Service, Repository, Schema, and Entity layers.",
+    architecture_ko=(
+        "HTTP 엔드포인트는 controller/router 계층에 두고 비즈니스 판단은 service 계층으로 위임한다.",
+        "service 계층은 유스케이스 단위 메서드를 제공하고 repository 또는 외부 연동 client를 조합한다.",
+        "repository 계층은 DB 접근만 담당하며 HTTP 요청/응답 객체를 알지 못해야 한다.",
+        "Pydantic schema는 요청/응답 계약이고 ORM entity는 저장 모델이다. 두 모델을 혼용하지 않는다.",
+        "권장 흐름: Controller -> Service -> Repository -> DB.",
+    ),
+    architecture_en=(
+        "Place HTTP endpoints in the controller/router layer and delegate business decisions to services.",
+        "Services expose use-case methods and coordinate repositories or external clients.",
+        "Repositories only handle database access and must not know HTTP request/response objects.",
+        "Pydantic schemas are request/response contracts and ORM entities are persistence models. Do not mix them.",
+        "Recommended flow: Controller -> Service -> Repository -> DB.",
+    ),
+    framework_rules_ko=(
+        "APIRouter는 라우팅과 의존성 연결만 담당한다.",
+        "Service가 FastAPI Response, Depends, Request에 직접 의존하지 않게 한다.",
+        "Repository는 SQLAlchemy, SQLModel 등 실제 저장소 API를 감싸는 경계로 둔다.",
+        "예외는 도메인/서비스 예외로 먼저 표현하고 controller에서 HTTP 상태로 변환한다.",
+        "배경 작업, 외부 호출, 긴 작업은 service 하위의 명시적 adapter/client로 분리한다.",
+    ),
+    framework_rules_en=(
+        "APIRouter should only handle routing and dependency wiring.",
+        "Services should not directly depend on FastAPI Response, Depends, or Request.",
+        "Repositories wrap storage APIs such as SQLAlchemy or SQLModel.",
+        "Represent errors as domain/service exceptions first, then map them to HTTP statuses in controllers.",
+        "Move background jobs, external calls, and long-running work into explicit adapters/clients below services.",
+    ),
+    api_rules_ko=(
+        "응답 모델은 response_model 또는 명시적 schema로 고정한다.",
+        "입력 검증은 schema에서 시작하고 유스케이스 검증은 service에서 수행한다.",
+        "엔드포인트 경로는 리소스 명사 중심으로 작성한다.",
+    ),
+    api_rules_en=(
+        "Pin response contracts with response_model or explicit schemas.",
+        "Start input validation in schemas and perform use-case validation in services.",
+        "Use resource nouns in endpoint paths.",
+    ),
+    test_rules_ko=(
+        "Service 테스트는 repository/client를 대체 객체로 격리한다.",
+        "API 테스트는 TestClient 또는 httpx 기반으로 요청/응답 계약을 검증한다.",
+        "Repository 테스트는 DB 스키마와 쿼리 동작을 별도로 검증한다.",
+    ),
+    test_rules_en=(
+        "Isolate service tests with repository/client doubles.",
+        "Use TestClient or httpx-based API tests to verify request/response contracts.",
+        "Verify repository tests against database schema and query behavior separately.",
+    ),
+    directories=("app/controllers", "app/services", "app/repositories", "app/schemas", "app/entities", "app/core"),
+)
+
+SPRINGBOOT_PROFILE = FrameworkProfile(
+    key="springboot",
+    display_name="Spring Boot",
+    philosophy_ko="Spring Boot 프로젝트는 Controller, Service, Repository, Entity, DTO 계층과 명시적 의존성 주입을 기준으로 유지한다.",
+    philosophy_en="Spring Boot projects should keep explicit Controller, Service, Repository, Entity, and DTO layers with dependency injection.",
+    architecture_ko=(
+        "Controller는 HTTP 요청/응답과 인증 컨텍스트 연결만 담당한다.",
+        "Service는 트랜잭션 경계와 비즈니스 규칙의 중심이다.",
+        "Repository는 JPA 또는 데이터 접근 인터페이스로 제한한다.",
+        "Entity는 DB 영속성 모델이고 DTO는 API 계약이다. Entity를 외부 응답으로 직접 노출하지 않는다.",
+        "권장 흐름: Controller -> Service -> Repository -> DB.",
+    ),
+    architecture_en=(
+        "Controllers handle HTTP request/response mapping and security context wiring only.",
+        "Services own transaction boundaries and business rules.",
+        "Repositories are limited to JPA or data access interfaces.",
+        "Entities are persistence models and DTOs are API contracts. Never expose entities directly in external responses.",
+        "Recommended flow: Controller -> Service -> Repository -> DB.",
+    ),
+    framework_rules_ko=(
+        "생성자 주입을 기본으로 사용한다.",
+        "@Transactional은 비즈니스 유스케이스가 있는 service 계층에 둔다.",
+        "ControllerAdvice 또는 공통 예외 처리기로 오류 응답을 일관화한다.",
+        "Entity 변경은 migration과 DB 문서 변경을 함께 검토한다.",
+    ),
+    framework_rules_en=(
+        "Prefer constructor injection.",
+        "Place @Transactional on service-layer use cases.",
+        "Use ControllerAdvice or a shared exception handler for consistent error responses.",
+        "Review migrations and DB documentation together with entity changes.",
+    ),
+    api_rules_ko=(
+        "Request DTO와 Response DTO를 분리한다.",
+        "상태 코드는 Controller에서 명시적으로 결정한다.",
+        "Bean Validation을 DTO 입력 계약에 적용한다.",
+    ),
+    api_rules_en=(
+        "Separate request DTOs from response DTOs.",
+        "Choose HTTP status codes explicitly in controllers.",
+        "Apply Bean Validation to DTO input contracts.",
+    ),
+    test_rules_ko=(
+        "Service는 단위 테스트로 비즈니스 규칙을 검증한다.",
+        "Controller는 WebMvcTest 또는 통합 테스트로 API 계약을 검증한다.",
+        "Repository는 필요한 경우 DataJpaTest로 쿼리와 매핑을 검증한다.",
+    ),
+    test_rules_en=(
+        "Verify business rules with service unit tests.",
+        "Verify API contracts with WebMvcTest or integration tests.",
+        "Use DataJpaTest when repository queries and mappings need verification.",
+    ),
+    directories=("src/main/java/.../controller", "src/main/java/.../service", "src/main/java/.../repository", "src/main/java/.../entity", "src/main/java/.../dto"),
+)
+
+REACT_PROFILE = FrameworkProfile(
+    key="react",
+    display_name="React",
+    philosophy_ko="React 코드는 화면, 컴포넌트, 훅, 서비스, 상태 저장소를 분리하고 UI와 데이터 접근을 섞지 않는다.",
+    philosophy_en="React code should separate pages, components, hooks, services, and stores without mixing UI and data access.",
+    architecture_ko=(
+        "page는 라우팅 단위 화면 조립을 담당한다.",
+        "component는 재사용 가능한 UI와 표시 책임을 담당한다.",
+        "hook은 화면 상태, 비동기 흐름, UI 유스케이스를 캡슐화한다.",
+        "service는 API 호출과 외부 클라이언트 경계만 담당한다.",
+        "store는 전역 상태를 담당하고 서버 응답 원본을 무분별하게 복제하지 않는다.",
+        "권장 흐름: Page -> Hook/Store -> Service -> API.",
+    ),
+    architecture_en=(
+        "Pages compose route-level screens.",
+        "Components own reusable UI and presentation.",
+        "Hooks encapsulate screen state, async flow, and UI use cases.",
+        "Services own API calls and external client boundaries only.",
+        "Stores own global state and should not blindly duplicate raw server responses.",
+        "Recommended flow: Page -> Hook/Store -> Service -> API.",
+    ),
+    framework_rules_ko=(
+        "컴포넌트 안에서 fetch/axios 호출을 직접 수행하지 않는다.",
+        "복잡한 상태 전이는 hook 또는 store action으로 분리한다.",
+        "공통 UI 컴포넌트와 기능 전용 컴포넌트를 분리한다.",
+        "API 타입과 UI view model의 변환 위치를 명확히 둔다.",
+    ),
+    framework_rules_en=(
+        "Do not call fetch/axios directly inside components.",
+        "Move complex state transitions into hooks or store actions.",
+        "Separate shared UI components from feature-specific components.",
+        "Keep API types and UI view-model mapping in an explicit location.",
+    ),
+    api_rules_ko=(
+        "service 함수는 HTTP 세부사항을 감추고 typed result를 반환한다.",
+        "API 오류는 화면에서 직접 문자열 조립하지 말고 공통 오류 모델로 변환한다.",
+        "인증 토큰 저장, 갱신, 만료 처리는 한 계층에서 일관되게 관리한다.",
+    ),
+    api_rules_en=(
+        "Service functions hide HTTP details and return typed results.",
+        "Convert API errors to a shared error model instead of hand-building strings in screens.",
+        "Manage auth token storage, refresh, and expiration consistently in one layer.",
+    ),
+    test_rules_ko=(
+        "컴포넌트 테스트는 사용자 상호작용과 표시 결과를 검증한다.",
+        "hook 테스트는 상태 전이와 비동기 흐름을 검증한다.",
+        "service 테스트는 API client 경계와 오류 변환을 검증한다.",
+    ),
+    test_rules_en=(
+        "Component tests verify user interactions and rendered results.",
+        "Hook tests verify state transitions and async flow.",
+        "Service tests verify API client boundaries and error mapping.",
+    ),
+    directories=("src/pages", "src/components", "src/hooks", "src/services", "src/stores", "src/types"),
+)
+
+NEXTJS_PROFILE = FrameworkProfile(
+    key="nextjs",
+    display_name="Next.js",
+    philosophy_ko="Next.js는 App Router를 기본으로 하며 Server Component와 Client Component의 책임을 명확히 구분한다.",
+    philosophy_en="Next.js should use the App Router by default and clearly separate Server Component and Client Component responsibilities.",
+    architecture_ko=(
+        "app 디렉토리는 라우트, 레이아웃, 서버 데이터 로딩의 기준 위치로 사용한다.",
+        "Server Component는 데이터 조회와 정적/서버 렌더링 책임을 담당한다.",
+        "Client Component는 브라우저 상태, 이벤트, 인터랙션이 필요한 경우에만 사용한다.",
+        "route handler는 API boundary이며 복잡한 비즈니스 로직은 service 계층으로 분리한다.",
+        "권장 흐름: Route/Page -> Server Action or Service -> Repository/External API.",
+    ),
+    architecture_en=(
+        "Use the app directory as the place for routes, layouts, and server data loading.",
+        "Server Components own data reads and static/server rendering.",
+        "Client Components are only for browser state, events, and interactions.",
+        "Route handlers are API boundaries; move complex business logic into services.",
+        "Recommended flow: Route/Page -> Server Action or Service -> Repository/External API.",
+    ),
+    framework_rules_ko=(
+        "'use client'는 필요한 파일에만 선언한다.",
+        "서버 전용 비밀값과 브라우저 공개 환경 변수를 구분한다.",
+        "데이터 변경은 server action 또는 route handler로 경계를 명확히 한다.",
+        "캐시, revalidate, dynamic 설정은 데이터 신선도 요구사항과 함께 문서화한다.",
+    ),
+    framework_rules_en=(
+        "Declare 'use client' only in files that need it.",
+        "Separate server-only secrets from browser-exposed environment variables.",
+        "Keep data mutations behind server actions or route handlers.",
+        "Document cache, revalidate, and dynamic settings with freshness requirements.",
+    ),
+    api_rules_ko=(
+        "route handler 응답은 명시적 JSON 계약을 유지한다.",
+        "server action의 입력 검증과 권한 검사를 생략하지 않는다.",
+        "프론트엔드 내부 호출과 외부 공개 API를 구분한다.",
+    ),
+    api_rules_en=(
+        "Route handler responses should keep explicit JSON contracts.",
+        "Do not skip input validation or authorization checks in server actions.",
+        "Separate internal frontend calls from externally exposed APIs.",
+    ),
+    test_rules_ko=(
+        "서버 로직은 service 단위 테스트로 우선 검증한다.",
+        "클라이언트 컴포넌트는 사용자 상호작용 중심으로 검증한다.",
+        "라우팅과 인증 흐름은 통합 테스트 또는 E2E 테스트로 검증한다.",
+    ),
+    test_rules_en=(
+        "Verify server logic first with service unit tests.",
+        "Verify Client Components around user interactions.",
+        "Verify routing and auth flow with integration or E2E tests.",
+    ),
+    directories=("app", "components", "features", "services", "lib", "types"),
+)
+
+NODE_EXPRESS_PROFILE = FrameworkProfile(
+    key="node-express",
+    display_name="Node Express",
+    philosophy_ko="Express는 얇은 HTTP 계층으로 유지하고 route, controller, service, repository를 분리한다.",
+    philosophy_en="Keep Express as a thin HTTP layer and separate routes, controllers, services, and repositories.",
+    architecture_ko=(
+        "route는 URL과 middleware 연결만 담당한다.",
+        "controller는 요청 파싱, 응답 변환, service 호출만 담당한다.",
+        "service는 비즈니스 유스케이스와 트랜잭션 흐름을 담당한다.",
+        "repository는 DB 접근을 담당하고 Express 객체를 알지 못해야 한다.",
+        "권장 흐름: Route -> Controller -> Service -> Repository -> DB.",
+    ),
+    architecture_en=(
+        "Routes only connect URLs and middleware.",
+        "Controllers parse requests, map responses, and call services only.",
+        "Services own business use cases and transaction flow.",
+        "Repositories own database access and must not know Express objects.",
+        "Recommended flow: Route -> Controller -> Service -> Repository -> DB.",
+    ),
+    framework_rules_ko=(
+        "비동기 오류 처리는 공통 error middleware로 모은다.",
+        "req/res 객체를 service 또는 repository로 넘기지 않는다.",
+        "validation middleware와 service 검증의 책임을 구분한다.",
+        "외부 API 호출은 client/adapter 계층으로 분리한다.",
+    ),
+    framework_rules_en=(
+        "Centralize async error handling in shared error middleware.",
+        "Do not pass req/res objects into services or repositories.",
+        "Separate validation middleware responsibilities from service validation.",
+        "Move external API calls into client/adapter layers.",
+    ),
+    api_rules_ko=(
+        "JSON 응답 형식과 오류 응답 형식을 공통으로 유지한다.",
+        "라우트 경로는 리소스 명사 중심으로 작성한다.",
+        "입력 검증 실패, 인증 실패, 권한 실패를 구분한다.",
+    ),
+    api_rules_en=(
+        "Keep JSON response and error response formats consistent.",
+        "Use resource nouns for route paths.",
+        "Distinguish validation, authentication, and authorization failures.",
+    ),
+    test_rules_ko=(
+        "Service 테스트는 DB와 HTTP를 격리한다.",
+        "Controller/route 테스트는 supertest 등으로 HTTP 계약을 검증한다.",
+        "Repository 테스트는 실제 쿼리와 transaction 동작을 검증한다.",
+    ),
+    test_rules_en=(
+        "Service tests isolate database and HTTP dependencies.",
+        "Controller/route tests verify HTTP contracts with tools such as supertest.",
+        "Repository tests verify real query and transaction behavior.",
+    ),
+    directories=("src/routes", "src/controllers", "src/services", "src/repositories", "src/middlewares", "src/types"),
+)
+
+FULLSTACK_FASTAPI_REACT_PROFILE = FrameworkProfile(
+    key="fullstack-fastapi-react",
+    display_name="Fullstack FastAPI + React",
+    philosophy_ko="FastAPI 백엔드와 React 프론트엔드는 API 계약을 중심으로 분리하고, 각 영역의 계층 규칙을 동시에 지킨다.",
+    philosophy_en="Separate the FastAPI backend and React frontend around the API contract while keeping both layer rules.",
+    architecture_ko=(
+        "backend는 Controller -> Service -> Repository -> DB 흐름을 따른다.",
+        "frontend는 Page -> Hook/Store -> Service -> API 흐름을 따른다.",
+        "API_SPEC.md는 백엔드 response schema와 프론트엔드 service 타입의 공통 계약이다.",
+        "백엔드 Entity를 프론트엔드 타입으로 직접 취급하지 않는다.",
+        "인증, 오류, pagination, enum 값은 양쪽 구현과 문서를 함께 갱신한다.",
+    ),
+    architecture_en=(
+        "Backend follows Controller -> Service -> Repository -> DB.",
+        "Frontend follows Page -> Hook/Store -> Service -> API.",
+        "API_SPEC.md is the shared contract between backend response schemas and frontend service types.",
+        "Do not treat backend entities as frontend types directly.",
+        "Update auth, errors, pagination, and enum values in both implementations and docs.",
+    ),
+    framework_rules_ko=(
+        "backend와 frontend 디렉토리 경계를 분명히 유지한다.",
+        "API 변경은 backend schema, frontend service/type, REF_DOCS/API_SPEC.md를 함께 수정한다.",
+        "React 컴포넌트는 백엔드 엔드포인트를 직접 호출하지 않고 service 계층을 통한다.",
+        "FastAPI service는 프론트엔드 화면 구조를 알지 못해야 한다.",
+        "CORS, 인증 토큰, 오류 응답 형식은 공통 정책으로 문서화한다.",
+    ),
+    framework_rules_en=(
+        "Keep backend and frontend directory boundaries clear.",
+        "API changes must update backend schemas, frontend services/types, and REF_DOCS/API_SPEC.md together.",
+        "React components call backend endpoints through the service layer, not directly.",
+        "FastAPI services must not know frontend screen structure.",
+        "Document CORS, auth tokens, and error response format as shared policies.",
+    ),
+    api_rules_ko=(
+        "OpenAPI 또는 명시적 API_SPEC.md를 기준 계약으로 유지한다.",
+        "Request/Response 필드명은 백엔드와 프론트엔드에서 동일하게 관리한다.",
+        "인증이 필요한 API는 권한 요구사항과 실패 응답을 반드시 문서화한다.",
+    ),
+    api_rules_en=(
+        "Keep OpenAPI or explicit API_SPEC.md as the source contract.",
+        "Maintain identical request/response field names across backend and frontend.",
+        "Document authorization requirements and failure responses for protected APIs.",
+    ),
+    test_rules_ko=(
+        "백엔드 API 테스트와 프론트엔드 service 테스트가 같은 계약을 검증하게 한다.",
+        "주요 사용자 흐름은 E2E 또는 통합 테스트 대상으로 둔다.",
+        "API mock은 실제 API_SPEC.md와 불일치하지 않게 관리한다.",
+    ),
+    test_rules_en=(
+        "Backend API tests and frontend service tests should verify the same contract.",
+        "Cover major user flows with E2E or integration tests.",
+        "Keep API mocks aligned with API_SPEC.md.",
+    ),
+    directories=("backend/app/controllers", "backend/app/services", "backend/app/repositories", "frontend/src/pages", "frontend/src/components", "frontend/src/services", "frontend/src/stores"),
+)
+
+PROFILES: dict[str, FrameworkProfile] = {
+    profile.key: profile
+    for profile in (
+        FASTAPI_PROFILE,
+        SPRINGBOOT_PROFILE,
+        REACT_PROFILE,
+        NEXTJS_PROFILE,
+        NODE_EXPRESS_PROFILE,
+        FULLSTACK_FASTAPI_REACT_PROFILE,
+    )
+}
+
+PROFILE_ALIASES: dict[str, str] = {
+    "fast-api": "fastapi",
+    "spring": "springboot",
+    "spring-boot": "springboot",
+    "next": "nextjs",
+    "next.js": "nextjs",
+    "node": "node-express",
+    "express": "node-express",
+    "nodeexpress": "node-express",
+    "fullstack": "fullstack-fastapi-react",
+    "fastapi-react": "fullstack-fastapi-react",
+}
+
+
+def supported_profile_names() -> tuple[str, ...]:
+    """Return supported canonical profile names."""
+
+    return tuple(PROFILES)
+
+
+def canonical_profile_name(name: str) -> str:
+    """Normalize a user-provided stack name to a supported profile key."""
+
+    normalized = name.strip().lower()
+    return PROFILE_ALIASES.get(normalized, normalized)
+
+
+def resolve_profiles(stack: tuple[str, ...]) -> tuple[FrameworkProfile, ...]:
+    """Resolve stack names to framework profiles, preserving user order."""
+
+    profiles: list[FrameworkProfile] = []
+    unknown: list[str] = []
+    seen: set[str] = set()
+
+    for raw_name in stack:
+        key = canonical_profile_name(raw_name)
+        profile = PROFILES.get(key)
+        if profile is None:
+            unknown.append(raw_name)
+            continue
+        if key not in seen:
+            profiles.append(profile)
+            seen.add(key)
+
+    if unknown:
+        supported = ", ".join(supported_profile_names())
+        invalid = ", ".join(unknown)
+        raise UnknownProfileError(f"unsupported stack profile(s): {invalid}. Supported: {supported}")
+
+    return tuple(profiles)

codex_builder/prompt.py

@@ -0,0 +1,230 @@
+"""Interactive prompt flow for codex-init."""
+
+from __future__ import annotations
+
+import argparse
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Callable, Optional, TextIO
+
+from codex_builder.constants import (
+    CODEX_DIR_NAME,
+    DEFAULT_DOCS_LEVEL,
+    DEFAULT_LANGUAGE,
+    DEFAULT_STACK,
+)
+from codex_builder.models import ConfigError, ProjectConfig, parse_yes_no
+from codex_builder.profiles import supported_profile_names
+from codex_builder.validator import (
+    validate_docs_level,
+    validate_existing_directory,
+    validate_language,
+    validate_stack,
+)
+
+
+InputFunc = Callable[[str], str]
+
+
+class PromptAbort(Exception):
+    """Raised when the user chooses not to generate .codex."""
+
+
+@dataclass(frozen=True)
+class PromptBuildRequest:
+    """Resolved request data needed by the CLI entrypoint."""
+
+    config: ProjectConfig
+    target_dir: Path
+    force: bool
+    backup_existing: bool
+
+
+class PromptSession:
+    """Collect missing CLI values using plain input prompts."""
+
+    def __init__(self, *, input_func: Optional[InputFunc] = None, output: Optional[TextIO] = None) -> None:
+        self._input = input_func or input
+        self._output = output
+
+    def resolve_request(
+        self,
+        args: argparse.Namespace,
+        *,
+        prompt_for_missing: bool,
+        confirm_before_build: bool,
+    ) -> PromptBuildRequest:
+        config = self._resolve_config(args, prompt_for_missing=prompt_for_missing)
+        target_dir = self._resolve_target_dir(args.target_dir, prompt_for_missing=prompt_for_missing)
+        force, backup_existing, conflict_prompted = self._resolve_existing_codex_policy(args, target_dir)
+
+        if confirm_before_build or conflict_prompted:
+            if not self.confirm_generation(config, target_dir):
+                raise PromptAbort("cancelled by user")
+
+        return PromptBuildRequest(
+            config=config,
+            target_dir=target_dir,
+            force=force,
+            backup_existing=backup_existing,
+        )
+
+    def _resolve_config(self, args: argparse.Namespace, *, prompt_for_missing: bool) -> ProjectConfig:
+        cwd_name = Path.cwd().name
+
+        if prompt_for_missing:
+            project_name = args.name or self.prompt_text("프로젝트 이름", cwd_name)
+            description = args.description if args.description is not None else self.prompt_text("프로젝트 설명", "")
+            stack = validate_stack(args.stack) if args.stack else self.prompt_stack()
+            database = args.database if args.database else self.prompt_database()
+            auth_enabled = parse_yes_no(args.auth) if args.auth is not None else self.prompt_confirm("인증 기능을 사용하나요?", default=False)
+            external_api_enabled = (
+                parse_yes_no(args.external_api)
+                if args.external_api is not None
+                else self.prompt_confirm("외부 API 연동이 있나요?", default=False)
+            )
+            docs_level = validate_docs_level(args.docs_level) if args.docs_level else self.prompt_docs_level()
+            language = validate_language(args.language) if args.language else self.prompt_language()
+        else:
+            project_name = args.name or cwd_name
+            description = args.description or ""
+            stack = validate_stack(args.stack or DEFAULT_STACK)
+            database = args.database or None
+            auth_enabled = parse_yes_no(args.auth, default=False)
+            external_api_enabled = parse_yes_no(args.external_api, default=False)
+            docs_level = validate_docs_level(args.docs_level or DEFAULT_DOCS_LEVEL)
+            language = validate_language(args.language or DEFAULT_LANGUAGE)
+
+        return ProjectConfig(
+            project_name=project_name,
+            description=description,
+            stack=stack,
+            database=database or None,
+            auth_enabled=auth_enabled,
+            external_api_enabled=external_api_enabled,
+            docs_level=docs_level,
+            language=language,
+        )
+
+    def _resolve_target_dir(self, target_dir: Optional[Path], *, prompt_for_missing: bool) -> Path:
+        if target_dir is not None:
+            return validate_existing_directory(target_dir)
+
+        if prompt_for_missing:
+            raw_target = self.prompt_text("대상 디렉토리", str(Path.cwd()))
+            return validate_existing_directory(Path(raw_target))
+
+        return validate_existing_directory(Path.cwd())
+
+    def _resolve_existing_codex_policy(self, args: argparse.Namespace, target_dir: Path) -> tuple[bool, bool, bool]:
+        codex_dir = target_dir / CODEX_DIR_NAME
+        if args.force:
+            return True, not args.overwrite, False
+        if not codex_dir.exists():
+            return False, True, False
+
+        action = self.prompt_existing_codex_action()
+        if action == "abort":
+            raise PromptAbort("existing .codex kept unchanged")
+        if action == "backup":
+            return True, True, True
+        return True, False, True
+
+    def prompt_text(self, label: str, default: str) -> str:
+        suffix = f" [{default}]" if default else ""
+        value = self._input(f"{label}{suffix}: ").strip()
+        return value or default
+
+    def prompt_confirm(self, label: str, *, default: bool) -> bool:
+        suffix = "[Y/n]" if default else "[y/N]"
+        while True:
+            value = self._input(f"{label} {suffix}: ").strip().lower()
+            if not value:
+                return default
+            if value in {"y", "yes"}:
+                return True
+            if value in {"n", "no"}:
+                return False
+            self._write("y 또는 n으로 입력해 주세요.")
+
+    def prompt_stack(self) -> tuple[str, ...]:
+        self._write("지원 프로필:")
+        for profile_name in supported_profile_names():
+            self._write(f"- {profile_name}")
+
+        while True:
+            raw_stack = self.prompt_text("사용 스택", ",".join(DEFAULT_STACK))
+            try:
+                return validate_stack(raw_stack)
+            except ConfigError as exc:
+                self._write(f"잘못된 stack 값입니다. {exc}")
+
+    def prompt_database(self) -> Optional[str]:
+        if not self.prompt_confirm("DB를 사용하나요?", default=False):
+            return None
+
+        while True:
+            database = self.prompt_text("DB 종류", "mysql").strip().lower()
+            if database:
+                return database
+            self._write("DB 종류를 입력해 주세요.")
+
+    def prompt_docs_level(self) -> str:
+        return self._prompt_choice("문서화 수준", ("light", "standard", "strict"), DEFAULT_DOCS_LEVEL, validate_docs_level)
+
+    def prompt_language(self) -> str:
+        return self._prompt_choice("문서 언어", ("ko", "en"), DEFAULT_LANGUAGE, validate_language)
+
+    def prompt_existing_codex_action(self) -> str:
+        self._write("")
+        self._write("기존 .codex 폴더가 존재합니다.")
+        self._write("1. 중단")
+        self._write("2. 백업 후 재생성")
+        self._write("3. 삭제 후 재생성")
+
+        while True:
+            value = self.prompt_text("처리 방식 선택", "1").strip().lower()
+            if value in {"1", "abort", "stop", "중단"}:
+                return "abort"
+            if value in {"2", "backup", "백업"}:
+                return "backup"
+            if value in {"3", "overwrite", "delete", "삭제"}:
+                return "overwrite"
+            self._write("1, 2, 3 중 하나를 입력해 주세요.")
+
+    def confirm_generation(self, config: ProjectConfig, target_dir: Path) -> bool:
+        self._write("")
+        self._write("생성 설정 확인")
+        self._write("")
+        self._write(f"프로젝트 이름: {config.project_name}")
+        self._write(f"설명: {config.description or '-'}")
+        self._write(f"스택: {','.join(config.stack)}")
+        self._write(f"DB: {config.database or 'no'}")
+        self._write(f"인증: {self._yes_no(config.auth_enabled)}")
+        self._write(f"외부 API: {self._yes_no(config.external_api_enabled)}")
+        self._write(f"문서화 수준: {config.docs_level}")
+        self._write(f"언어: {config.language}")
+        self._write(f"대상 디렉토리: {target_dir}")
+        self._write("")
+        return self.prompt_confirm("이 설정으로 .codex를 생성할까요?", default=True)
+
+    def _prompt_choice(
+        self,
+        label: str,
+        choices: tuple[str, ...],
+        default: str,
+        validator: Callable[[str], str],
+    ) -> str:
+        choices_text = "/".join(choices)
+        while True:
+            value = self.prompt_text(f"{label} ({choices_text})", default)
+            try:
+                return validator(value)
+            except ConfigError as exc:
+                self._write(f"잘못된 입력입니다. {exc}")
+
+    def _write(self, message: str) -> None:
+        print(message, file=self._output)
+
+    def _yes_no(self, value: bool) -> str:
+        return "yes" if value else "no"