codex-rule-maker 0.2.0__tar.gz → 0.4.0__tar.gz

codex_rule_maker-0.4.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 주민재
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{codex_rule_maker-0.2.0 → codex_rule_maker-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-rule-maker
-Version: 0.2.0
+Version: 0.4.0
 Summary: CLI tool that generates a .codex folder with AI developer rules and project reference documents.
 Author: codex-rule-maker
 Project-URL: Homepage, https://github.com/Sharon77770/codex_rule_maker
@@ -21,13 +21,17 @@ Classifier: Topic :: Software Development :: Code Generators
 Classifier: Topic :: Software Development :: Documentation
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Provides-Extra: dev
 Requires-Dist: build<2,>=1; extra == "dev"
 Requires-Dist: pytest<9,>=7; extra == "dev"
 Requires-Dist: twine<7,>=5; extra == "dev"
+Dynamic: license-file
 
 # codex-rule-maker
 
+현재 버전: `0.4.0`
+
 `codex-rule-maker`는 프로젝트 루트에 `.codex` 규칙 폴더와 `docs/` 프로젝트 문서 템플릿을 자동 구성하는 Python CLI 도구입니다. 사용자가 프로젝트 이름, 설명, 스택, DB, 인증 여부, 외부 API 여부, 문서화 수준, 문서 언어를 입력하면 Codex가 작업 전에 읽을 개발 규칙과 프로젝트 문서 구조를 생성합니다.
 
 ## 설치
@@ -222,19 +226,22 @@ docs/
 
 ## 지원 프레임워크 프로필
 
-- `fastapi`: controller/service/repository/schema/entity 계층 분리
-- `python`: 일반 Python package/module/service/adapter/CLI 경계 분리
-- `springboot`: controller/service/repository/entity/dto 계층 분리
-- `react`: component/page/hook/service/store 분리
-- `nextjs`: App Router, Server Component와 Client Component 구분
-- `node-express`: route/controller/service/repository 분리
-- `fullstack-fastapi-react`: FastAPI 백엔드와 React 프론트엔드 규칙 동시 적용
+- `fastapi`: 기능 폴더 하위 controller/service/repository/schema/entity 분리
+- `python`: 프레임워크 없는 Python 프로젝트의 기능/도메인 폴더 하위 service/adapter/model/CLI 경계 분리
+- `typescript-javascript`: 프레임워크 없는 TypeScript/JavaScript 프로젝트의 기능/도메인 폴더 하위 service/adapter/model 경계 분리
+- `springboot`: 기능 package 하위 controller/service/repository/entity/dto 분리
+- `react`: 기능 폴더 하위 page/component/hook/service/store 분리
+- `nextjs`: App Router 유지, 기능 폴더 하위 component/service/repository/type 분리
+- `node-express`: 기능 폴더 하위 route/controller/service/repository 분리
+- `fullstack-fastapi-react`: FastAPI 백엔드와 React 프론트엔드 모두 기능 폴더 하위 계층 분리 적용
 
 여러 프로필은 comma로 조합할 수 있습니다.
 
 ```bash
 codex-init --stack fastapi,react
 codex-init --stack python
+codex-init --stack typescript
+codex-init --stack javascript
 codex-init --stack fullstack-fastapi-react
 codex-init --stack nextjs
 ```
@@ -245,7 +252,7 @@ codex-init --stack nextjs
 - `--language en`을 사용하면 영어 문서를 생성합니다.
 - `--docs strict`는 코드 변경 후 문서 업데이트 필수 규칙을 포함합니다.
 - `--auth yes`는 인증/권한 규칙을 포함합니다.
-- `--external-api yes`는 외부 연동 계층 분리 규칙을 포함합니다.
+- `--external-api yes`는 확인된 계약을 기준으로 실제 외부 연동을 구현하기 위한 client/adapter 및 계약 문서 규칙을 포함합니다.
 - `--db mysql`처럼 DB를 지정하면 DB, Repository, Schema 관련 규칙을 포함합니다.
 - 프로젝트 명세 템플릿은 `.codex/ref_docs`가 아니라 `docs/architecture`, `docs/api`, `docs/database`에 생성됩니다.
 

{codex_rule_maker-0.2.0 → codex_rule_maker-0.4.0}/README.md

@@ -1,5 +1,7 @@
 # codex-rule-maker
 
+현재 버전: `0.4.0`
+
 `codex-rule-maker`는 프로젝트 루트에 `.codex` 규칙 폴더와 `docs/` 프로젝트 문서 템플릿을 자동 구성하는 Python CLI 도구입니다. 사용자가 프로젝트 이름, 설명, 스택, DB, 인증 여부, 외부 API 여부, 문서화 수준, 문서 언어를 입력하면 Codex가 작업 전에 읽을 개발 규칙과 프로젝트 문서 구조를 생성합니다.
 
 ## 설치
@@ -194,19 +196,22 @@ docs/
 
 ## 지원 프레임워크 프로필
 
-- `fastapi`: controller/service/repository/schema/entity 계층 분리
-- `python`: 일반 Python package/module/service/adapter/CLI 경계 분리
-- `springboot`: controller/service/repository/entity/dto 계층 분리
-- `react`: component/page/hook/service/store 분리
-- `nextjs`: App Router, Server Component와 Client Component 구분
-- `node-express`: route/controller/service/repository 분리
-- `fullstack-fastapi-react`: FastAPI 백엔드와 React 프론트엔드 규칙 동시 적용
+- `fastapi`: 기능 폴더 하위 controller/service/repository/schema/entity 분리
+- `python`: 프레임워크 없는 Python 프로젝트의 기능/도메인 폴더 하위 service/adapter/model/CLI 경계 분리
+- `typescript-javascript`: 프레임워크 없는 TypeScript/JavaScript 프로젝트의 기능/도메인 폴더 하위 service/adapter/model 경계 분리
+- `springboot`: 기능 package 하위 controller/service/repository/entity/dto 분리
+- `react`: 기능 폴더 하위 page/component/hook/service/store 분리
+- `nextjs`: App Router 유지, 기능 폴더 하위 component/service/repository/type 분리
+- `node-express`: 기능 폴더 하위 route/controller/service/repository 분리
+- `fullstack-fastapi-react`: FastAPI 백엔드와 React 프론트엔드 모두 기능 폴더 하위 계층 분리 적용
 
 여러 프로필은 comma로 조합할 수 있습니다.
 
 ```bash
 codex-init --stack fastapi,react
 codex-init --stack python
+codex-init --stack typescript
+codex-init --stack javascript
 codex-init --stack fullstack-fastapi-react
 codex-init --stack nextjs
 ```
@@ -217,7 +222,7 @@ codex-init --stack nextjs
 - `--language en`을 사용하면 영어 문서를 생성합니다.
 - `--docs strict`는 코드 변경 후 문서 업데이트 필수 규칙을 포함합니다.
 - `--auth yes`는 인증/권한 규칙을 포함합니다.
-- `--external-api yes`는 외부 연동 계층 분리 규칙을 포함합니다.
+- `--external-api yes`는 확인된 계약을 기준으로 실제 외부 연동을 구현하기 위한 client/adapter 및 계약 문서 규칙을 포함합니다.
 - `--db mysql`처럼 DB를 지정하면 DB, Repository, Schema 관련 규칙을 포함합니다.
 - 프로젝트 명세 템플릿은 `.codex/ref_docs`가 아니라 `docs/architecture`, `docs/api`, `docs/database`에 생성됩니다.
 

{codex_rule_maker-0.2.0 → codex_rule_maker-0.4.0}/codex_builder/cli.py

@@ -10,7 +10,7 @@ from typing import Optional
 from codex_builder.builder import CodexBuilder, CodexBuildError, ExistingCodexError
 from codex_builder.models import ConfigError
 from codex_builder.prompt import PromptAbort, PromptSession
-from codex_builder.profiles import UnknownProfileError, supported_profile_names
+from codex_builder.profiles import UnknownProfileError, supported_profile_labels
 
 
 def build_parser() -> argparse.ArgumentParser:
@@ -22,7 +22,7 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument("--description", help="Short project description.")
     parser.add_argument(
         "--stack",
-        help=f"Comma-separated stack profiles. Supported: {', '.join(supported_profile_names())}.",
+        help=f"Comma-separated stack profiles. Supported: {', '.join(supported_profile_labels())}.",
     )
     parser.add_argument("--db", "--database", dest="database", help="Database name, for example mysql or postgres.")
     parser.add_argument("--auth", help="Whether authentication is used: yes/no.")

{codex_rule_maker-0.2.0 → codex_rule_maker-0.4.0}/codex_builder/profiles.py

@@ -46,17 +46,19 @@ class FrameworkProfile:
 PYTHON_PROFILE = FrameworkProfile(
     key="python",
     display_name="Python",
-    philosophy_ko="일반 Python 프로젝트는 프레임워크 전제 없이 package/module, service, adapter, CLI 경계를 명확히 분리한다.",
-    philosophy_en="General Python projects should separate package/module, service, adapter, and CLI boundaries without assuming a framework.",
+    philosophy_ko="일반 Python 프로젝트는 프레임워크 전제 없이 기능/도메인 폴더를 우선하고, 각 기능 내부에서 service, adapter, CLI 경계를 명확히 분리한다.",
+    philosophy_en="General Python projects should prefer feature/domain folders first, then separate service, adapter, and CLI boundaries inside each feature without assuming a framework.",
     architecture_ko=(
-        "패키지는 기능 또는 도메인 책임 기준으로 나누고 임시 script 모음처럼 방치하지 않는다.",
+        "패키지는 기능 또는 도메인 책임 기준으로 나누고 각 기능 폴더 하위에 service, adapter, model 등을 둔다.",
+        "공통 package는 여러 기능이 공유하는 정책, 설정, utility에만 사용한다.",
         "CLI 또는 실행 진입점은 입력 파싱과 출력 변환만 담당하고 실제 판단은 service/application 계층에 위임한다.",
         "핵심 도메인 함수와 클래스는 파일 시스템, 네트워크, 환경 변수, process args에 직접 의존하지 않게 한다.",
         "파일, DB, 외부 API, subprocess 연동은 adapter 또는 infrastructure 모듈 뒤에 둔다.",
         "권장 흐름: Entrypoint/CLI -> Application Service -> Domain/Adapter -> External System.",
     ),
     architecture_en=(
-        "Split packages by feature or domain responsibility instead of leaving them as loose script collections.",
+        "Split packages by feature or domain responsibility and place service, adapter, and model modules under each feature folder.",
+        "Use shared packages only for policies, settings, and utilities reused by multiple features.",
         "CLI or runtime entrypoints should only parse input and map output, then delegate decisions to service/application layers.",
         "Keep core domain functions and classes independent from filesystem, network, environment variables, and process args.",
         "Put filesystem, database, external API, and subprocess integrations behind adapter or infrastructure modules.",
@@ -96,28 +98,105 @@ PYTHON_PROFILE = FrameworkProfile(
         "Use `tmp_path`, monkeypatching, and test doubles to isolate filesystem and external dependencies.",
         "Lock down CLI arguments, configuration parsing, and error paths with regression tests.",
     ),
-    directories=("src/<package_name>", "src/<package_name>/services", "src/<package_name>/adapters", "tests", "scripts"),
+    directories=(
+        "src/<package_name>/<feature>/services",
+        "src/<package_name>/<feature>/adapters",
+        "src/<package_name>/<feature>/models",
+        "src/<package_name>/shared",
+        "tests",
+        "scripts",
+    ),
+)
+
+
+TYPESCRIPT_JAVASCRIPT_PROFILE = FrameworkProfile(
+    key="typescript-javascript",
+    display_name="TypeScript/JavaScript",
+    philosophy_ko="일반 TypeScript/JavaScript 프로젝트는 프레임워크 전제 없이 기능/도메인 폴더를 우선하고, 각 기능 내부에서 service, adapter, model 경계를 분리한다.",
+    philosophy_en="General TypeScript/JavaScript projects should prefer feature/domain folders first, then separate service, adapter, and model boundaries without assuming a framework.",
+    architecture_ko=(
+        "패키지는 기능 또는 도메인 책임 기준으로 나누고 각 기능 폴더 하위에 services, adapters, models/types 등을 둔다.",
+        "공통 모듈은 여러 기능에서 공유하는 정책, 설정, utility에만 사용한다.",
+        "실행 진입점은 입력 파싱과 출력 변환만 담당하고 실제 판단은 application/service 계층에 위임한다.",
+        "핵심 도메인 로직은 filesystem, network, environment, process 전역 객체에 직접 의존하지 않게 한다.",
+        "파일, DB, 외부 API, subprocess 연동은 adapter 또는 infrastructure 모듈 뒤에 둔다.",
+        "권장 흐름: Entrypoint -> Application Service -> Domain/Adapter -> External System.",
+    ),
+    architecture_en=(
+        "Split modules by feature or domain responsibility and place services, adapters, and models/types under each feature folder.",
+        "Use shared modules only for policies, settings, and utilities reused by multiple features.",
+        "Runtime entrypoints should parse input and map output only, then delegate decisions to application/services.",
+        "Keep core domain logic independent from filesystem, network, environment, and process globals.",
+        "Put filesystem, database, external API, and subprocess integrations behind adapter or infrastructure modules.",
+        "Recommended flow: Entrypoint -> Application Service -> Domain/Adapter -> External System.",
+    ),
+    framework_rules_ko=(
+        "프레임워크 전역 객체와 import 시점 부수효과에 의존하지 않는 모듈을 작성한다.",
+        "TypeScript는 공개 함수와 클래스의 타입을 명시하고, JavaScript는 필요한 경우 JSDoc으로 계약을 표현한다.",
+        "비동기 오류는 호출자가 처리할 수 있는 명확한 Error 타입과 메시지로 전달한다.",
+        "표준 런타임과 기존 dependency로 충분한 문제에 불필요한 패키지를 추가하지 않는다.",
+        "순수 계산 로직과 I/O 로직을 분리해 테스트와 재사용이 가능하게 한다.",
+    ),
+    framework_rules_en=(
+        "Write modules that do not depend on framework globals or import-time side effects.",
+        "Use explicit types for public TypeScript functions and classes, and express JavaScript contracts with JSDoc when useful.",
+        "Propagate async failures with clear Error types and messages that callers can handle.",
+        "Do not add dependencies when the runtime and existing packages are sufficient.",
+        "Separate pure computation from I/O so logic stays testable and reusable.",
+    ),
+    api_rules_ko=(
+        "공개 함수, 모듈 export, CLI 옵션은 외부 계약으로 보고 이름과 반환 형식을 안정적으로 관리한다.",
+        "외부 입력은 진입점에서 검증하고 내부 model로 변환한 뒤 service 계층에 전달한다.",
+        "공개 모듈의 오류와 비동기 동작은 호출자가 예측할 수 있게 문서화한다.",
+    ),
+    api_rules_en=(
+        "Treat public functions, module exports, and CLI options as external contracts with stable names and return shapes.",
+        "Validate external input at the entrypoint and convert it into internal models before passing it to services.",
+        "Document public module errors and async behavior so callers can predict them.",
+    ),
+    test_rules_ko=(
+        "순수 로직 테스트와 filesystem/network/environment I/O 테스트를 분리한다.",
+        "외부 의존성은 명시적인 test double과 임시 디렉토리로 격리한다.",
+        "CLI 인자, module export, 비동기 오류 경로는 회귀 테스트로 고정한다.",
+    ),
+    test_rules_en=(
+        "Separate pure logic tests from filesystem, network, and environment I/O tests.",
+        "Isolate external dependencies with explicit test doubles and temporary directories.",
+        "Lock down CLI arguments, module exports, and async failure paths with regression tests.",
+    ),
+    directories=(
+        "src/<feature>/services",
+        "src/<feature>/adapters",
+        "src/<feature>/models",
+        "src/shared",
+        "tests",
+        "scripts",
+    ),
 )
 
 
 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.",
+    philosophy_ko="FastAPI의 가벼운 실행 모델은 유지하되, login/post/talk 같은 기능 폴더를 먼저 나누고 각 기능 안에서 Controller, Service, Repository, Schema, Entity 계층을 분리한다.",
+    philosophy_en="Keep FastAPI's lightweight runtime model, but split by feature/domain first, then separate Controller, Service, Repository, Schema, and Entity layers inside each feature.",
     architecture_ko=(
-        "HTTP 엔드포인트는 controller/router 계층에 두고 비즈니스 판단은 service 계층으로 위임한다.",
-        "service 계층은 유스케이스 단위 메서드를 제공하고 repository 또는 외부 연동 client를 조합한다.",
+        "기능 경계는 `app/features/<feature>` 아래에 둔다. 예: login, post, talk.",
+        "HTTP 엔드포인트는 각 기능의 controller/router 계층에 두고 비즈니스 판단은 같은 기능의 service 계층으로 위임한다.",
+        "service 계층은 유스케이스 단위 메서드를 제공하고 같은 기능의 repository 또는 외부 연동 client를 조합한다.",
         "repository 계층은 DB 접근만 담당하며 HTTP 요청/응답 객체를 알지 못해야 한다.",
-        "Pydantic schema는 요청/응답 계약이고 ORM entity는 저장 모델이다. 두 모델을 혼용하지 않는다.",
-        "권장 흐름: Controller -> Service -> Repository -> DB.",
+        "Pydantic schema는 요청/응답 계약이고 ORM entity는 저장 모델이다. 두 모델은 같은 기능 폴더 안에서도 혼용하지 않는다.",
+        "공통 설정, DB session, 인증 dependency처럼 여러 기능이 공유하는 요소만 core/shared에 둔다.",
+        "권장 흐름: 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.",
+        "Use `app/features/<feature>` as the feature boundary, for example login, post, or talk.",
+        "Place HTTP endpoints in each feature's controller/router layer and delegate business decisions to the same feature's services.",
+        "Services expose use-case methods and coordinate repositories or external clients within the same feature.",
         "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.",
+        "Pydantic schemas are request/response contracts and ORM entities are persistence models. Do not mix them even inside the same feature folder.",
+        "Put only cross-feature settings, DB sessions, auth dependencies, and shared policies in core/shared.",
+        "Recommended flow: Controller -> Service -> Repository -> DB, with each layer located inside the same feature folder.",
     ),
     framework_rules_ko=(
         "APIRouter는 라우팅과 의존성 연결만 담당한다.",
@@ -153,27 +232,39 @@ FASTAPI_PROFILE = FrameworkProfile(
         "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"),
+    directories=(
+        "app/features/<feature>/controllers",
+        "app/features/<feature>/services",
+        "app/features/<feature>/repositories",
+        "app/features/<feature>/schemas",
+        "app/features/<feature>/entities",
+        "app/core",
+        "app/shared",
+    ),
 )
 
 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.",
+    philosophy_ko="Spring Boot 프로젝트는 기능 package를 먼저 나누고 각 기능 안에서 Controller, Service, Repository, Entity, DTO 계층과 명시적 의존성 주입을 유지한다.",
+    philosophy_en="Spring Boot projects should split by feature package first, then keep explicit Controller, Service, Repository, Entity, and DTO layers with dependency injection inside each feature.",
     architecture_ko=(
-        "Controller는 HTTP 요청/응답과 인증 컨텍스트 연결만 담당한다.",
-        "Service는 트랜잭션 경계와 비즈니스 규칙의 중심이다.",
+        "기능 경계는 `.../<feature>` package 아래에 둔다. 예: login, post, talk.",
+        "Controller는 각 기능 package 안에서 HTTP 요청/응답과 인증 컨텍스트 연결만 담당한다.",
+        "Service는 같은 기능 package 안에서 트랜잭션 경계와 비즈니스 규칙의 중심이다.",
         "Repository는 JPA 또는 데이터 접근 인터페이스로 제한한다.",
         "Entity는 DB 영속성 모델이고 DTO는 API 계약이다. Entity를 외부 응답으로 직접 노출하지 않는다.",
-        "권장 흐름: Controller -> Service -> Repository -> DB.",
+        "공통 config, security, exception handler만 전역 package로 분리한다.",
+        "권장 흐름: Controller -> Service -> Repository -> DB, 단 각 계층은 같은 기능 package 안에 둔다.",
     ),
     architecture_en=(
-        "Controllers handle HTTP request/response mapping and security context wiring only.",
-        "Services own transaction boundaries and business rules.",
+        "Use `.../<feature>` packages as feature boundaries, for example login, post, or talk.",
+        "Controllers handle HTTP request/response mapping and security context wiring only inside each feature package.",
+        "Services own transaction boundaries and business rules inside the same feature package.",
         "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.",
+        "Keep only shared config, security, and exception handlers in global packages.",
+        "Recommended flow: Controller -> Service -> Repository -> DB, with each layer located inside the same feature package.",
     ),
     framework_rules_ko=(
         "생성자 주입을 기본으로 사용한다.",
@@ -207,29 +298,38 @@ SPRINGBOOT_PROFILE = FrameworkProfile(
         "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"),
+    directories=(
+        "src/main/java/.../<feature>/controller",
+        "src/main/java/.../<feature>/service",
+        "src/main/java/.../<feature>/repository",
+        "src/main/java/.../<feature>/entity",
+        "src/main/java/.../<feature>/dto",
+        "src/main/java/.../global",
+    ),
 )
 
 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.",
+    philosophy_ko="React 코드는 기능 폴더를 먼저 나누고 각 기능 안에서 화면, 컴포넌트, 훅, 서비스, 상태 저장소를 분리해 UI와 데이터 접근을 섞지 않는다.",
+    philosophy_en="React code should split by feature first, then separate pages, components, hooks, services, and stores inside each feature without mixing UI and data access.",
     architecture_ko=(
-        "page는 라우팅 단위 화면 조립을 담당한다.",
-        "component는 재사용 가능한 UI와 표시 책임을 담당한다.",
+        "기능 경계는 `src/features/<feature>` 아래에 둔다. 예: login, post, talk.",
+        "page는 각 기능의 라우팅 단위 화면 조립을 담당한다.",
+        "component는 기능 내부 UI와 표시 책임을 담당하고 여러 기능에서 재사용되는 것만 shared에 둔다.",
         "hook은 화면 상태, 비동기 흐름, UI 유스케이스를 캡슐화한다.",
         "service는 API 호출과 외부 클라이언트 경계만 담당한다.",
         "store는 전역 상태를 담당하고 서버 응답 원본을 무분별하게 복제하지 않는다.",
-        "권장 흐름: Page -> Hook/Store -> Service -> API.",
+        "권장 흐름: Page -> Hook/Store -> Service -> API, 단 구현 위치는 같은 기능 폴더 안이다.",
     ),
     architecture_en=(
-        "Pages compose route-level screens.",
-        "Components own reusable UI and presentation.",
+        "Use `src/features/<feature>` as the feature boundary, for example login, post, or talk.",
+        "Pages compose route-level screens inside each feature.",
+        "Components own feature UI and presentation; move only cross-feature reusable components to shared.",
         "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.",
+        "Recommended flow: Page -> Hook/Store -> Service -> API, with implementation located inside the same feature folder.",
     ),
     framework_rules_ko=(
         "컴포넌트 안에서 fetch/axios 호출을 직접 수행하지 않는다.",
@@ -263,27 +363,37 @@ REACT_PROFILE = FrameworkProfile(
         "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"),
+    directories=(
+        "src/features/<feature>/pages",
+        "src/features/<feature>/components",
+        "src/features/<feature>/hooks",
+        "src/features/<feature>/services",
+        "src/features/<feature>/stores",
+        "src/features/<feature>/types",
+        "src/shared",
+    ),
 )
 
 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.",
+    philosophy_ko="Next.js는 App Router를 기본으로 하되, 기능 구현은 features 하위에 모으고 Server Component와 Client Component의 책임을 명확히 구분한다.",
+    philosophy_en="Next.js should use the App Router by default, keep feature implementation under features, and clearly separate Server Component and Client Component responsibilities.",
     architecture_ko=(
         "app 디렉토리는 라우트, 레이아웃, 서버 데이터 로딩의 기준 위치로 사용한다.",
+        "기능별 component, service, repository, type은 `features/<feature>` 아래에 둔다.",
         "Server Component는 데이터 조회와 정적/서버 렌더링 책임을 담당한다.",
         "Client Component는 브라우저 상태, 이벤트, 인터랙션이 필요한 경우에만 사용한다.",
         "route handler는 API boundary이며 복잡한 비즈니스 로직은 service 계층으로 분리한다.",
-        "권장 흐름: Route/Page -> Server Action or Service -> Repository/External API.",
+        "권장 흐름: Route/Page -> Feature Service -> Repository/External API.",
     ),
     architecture_en=(
         "Use the app directory as the place for routes, layouts, and server data loading.",
+        "Place feature components, services, repositories, and types under `features/<feature>`.",
         "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.",
+        "Recommended flow: Route/Page -> Feature Service -> Repository/External API.",
     ),
     framework_rules_ko=(
         "'use client'는 필요한 파일에만 선언한다.",
@@ -317,27 +427,39 @@ NEXTJS_PROFILE = FrameworkProfile(
         "Verify Client Components around user interactions.",
         "Verify routing and auth flow with integration or E2E tests.",
     ),
-    directories=("app", "components", "features", "services", "lib", "types"),
+    directories=(
+        "app",
+        "features/<feature>/components",
+        "features/<feature>/services",
+        "features/<feature>/repositories",
+        "features/<feature>/types",
+        "components/shared",
+        "lib",
+    ),
 )
 
 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.",
+    philosophy_ko="Express는 얇은 HTTP 계층으로 유지하고 기능 폴더 안에서 route, controller, service, repository를 분리한다.",
+    philosophy_en="Keep Express as a thin HTTP layer and separate routes, controllers, services, and repositories inside feature folders.",
     architecture_ko=(
-        "route는 URL과 middleware 연결만 담당한다.",
+        "기능 경계는 `src/features/<feature>` 아래에 둔다. 예: login, post, talk.",
+        "route는 각 기능 내부에서 URL과 middleware 연결만 담당한다.",
         "controller는 요청 파싱, 응답 변환, service 호출만 담당한다.",
-        "service는 비즈니스 유스케이스와 트랜잭션 흐름을 담당한다.",
+        "service는 같은 기능 내부에서 비즈니스 유스케이스와 트랜잭션 흐름을 담당한다.",
         "repository는 DB 접근을 담당하고 Express 객체를 알지 못해야 한다.",
-        "권장 흐름: Route -> Controller -> Service -> Repository -> DB.",
+        "공통 middleware, config, error handler만 전역 경계로 둔다.",
+        "권장 흐름: Route -> Controller -> Service -> Repository -> DB, 단 각 계층은 같은 기능 폴더 안에 둔다.",
     ),
     architecture_en=(
-        "Routes only connect URLs and middleware.",
+        "Use `src/features/<feature>` as the feature boundary, for example login, post, or talk.",
+        "Routes only connect URLs and middleware inside each feature.",
         "Controllers parse requests, map responses, and call services only.",
-        "Services own business use cases and transaction flow.",
+        "Services own business use cases and transaction flow inside the same feature.",
         "Repositories own database access and must not know Express objects.",
-        "Recommended flow: Route -> Controller -> Service -> Repository -> DB.",
+        "Keep only shared middleware, config, and error handlers in global boundaries.",
+        "Recommended flow: Route -> Controller -> Service -> Repository -> DB, with each layer located inside the same feature folder.",
     ),
     framework_rules_ko=(
         "비동기 오류 처리는 공통 error middleware로 모은다.",
@@ -371,24 +493,32 @@ NODE_EXPRESS_PROFILE = FrameworkProfile(
         "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"),
+    directories=(
+        "src/features/<feature>/routes",
+        "src/features/<feature>/controllers",
+        "src/features/<feature>/services",
+        "src/features/<feature>/repositories",
+        "src/features/<feature>/types",
+        "src/shared",
+        "src/middlewares",
+    ),
 )
 
 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.",
+    philosophy_ko="FastAPI 백엔드와 React 프론트엔드는 API 계약을 중심으로 분리하고, 양쪽 모두 기능 폴더 안에서 계층 규칙을 지킨다.",
+    philosophy_en="Separate the FastAPI backend and React frontend around the API contract while keeping layer rules inside feature folders on both sides.",
     architecture_ko=(
-        "backend는 Controller -> Service -> Repository -> DB 흐름을 따른다.",
-        "frontend는 Page -> Hook/Store -> Service -> API 흐름을 따른다.",
+        "backend는 Controller -> Service -> Repository -> DB 흐름을 따르되 각 계층은 `backend/app/features/<feature>` 안에 둔다.",
+        "frontend는 Page -> Hook/Store -> Service -> API 흐름을 따르되 각 계층은 `frontend/src/features/<feature>` 안에 둔다.",
         "docs/api/specification.md는 백엔드 response schema와 프론트엔드 service 타입의 공통 계약이다.",
         "백엔드 Entity를 프론트엔드 타입으로 직접 취급하지 않는다.",
         "인증, 오류, pagination, enum 값은 양쪽 구현과 문서를 함께 갱신한다.",
     ),
     architecture_en=(
-        "Backend follows Controller -> Service -> Repository -> DB.",
-        "Frontend follows Page -> Hook/Store -> Service -> API.",
+        "Backend follows Controller -> Service -> Repository -> DB, with each layer under `backend/app/features/<feature>`.",
+        "Frontend follows Page -> Hook/Store -> Service -> API, with each layer under `frontend/src/features/<feature>`.",
         "docs/api/specification.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.",
@@ -420,14 +550,27 @@ FULLSTACK_FASTAPI_REACT_PROFILE = FrameworkProfile(
     test_rules_ko=(
         "백엔드 API 테스트와 프론트엔드 service 테스트가 같은 계약을 검증하게 한다.",
         "주요 사용자 흐름은 E2E 또는 통합 테스트 대상으로 둔다.",
-        "API mock은 실제 docs/api/specification.md와 불일치하지 않게 관리한다.",
+        "API contract test는 실제 docs/api/specification.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 docs/api/specification.md.",
+        "Keep API contract tests aligned with docs/api/specification.md.",
+    ),
+    directories=(
+        "backend/app/features/<feature>/controllers",
+        "backend/app/features/<feature>/services",
+        "backend/app/features/<feature>/repositories",
+        "backend/app/features/<feature>/schemas",
+        "backend/app/features/<feature>/entities",
+        "frontend/src/features/<feature>/pages",
+        "frontend/src/features/<feature>/components",
+        "frontend/src/features/<feature>/hooks",
+        "frontend/src/features/<feature>/services",
+        "frontend/src/features/<feature>/stores",
+        "backend/app/core",
+        "frontend/src/shared",
     ),
-    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] = {
@@ -435,6 +578,7 @@ PROFILES: dict[str, FrameworkProfile] = {
     for profile in (
         FASTAPI_PROFILE,
         PYTHON_PROFILE,
+        TYPESCRIPT_JAVASCRIPT_PROFILE,
         SPRINGBOOT_PROFILE,
         REACT_PROFILE,
         NEXTJS_PROFILE,
@@ -449,6 +593,16 @@ PROFILE_ALIASES: dict[str, str] = {
     "plain-python": "python",
     "vanilla-python": "python",
     "general-python": "python",
+    "ts": "typescript-javascript",
+    "js": "typescript-javascript",
+    "typescript": "typescript-javascript",
+    "javascript": "typescript-javascript",
+    "ts-js": "typescript-javascript",
+    "ts/js": "typescript-javascript",
+    "plain-typescript": "typescript-javascript",
+    "plain-javascript": "typescript-javascript",
+    "vanilla-typescript": "typescript-javascript",
+    "vanilla-javascript": "typescript-javascript",
     "fast-api": "fastapi",
     "spring": "springboot",
     "spring-boot": "springboot",
@@ -468,6 +622,12 @@ def supported_profile_names() -> tuple[str, ...]:
     return tuple(PROFILES)
 
 
+def supported_profile_labels() -> tuple[str, ...]:
+    """Return user-facing labels for supported profile choices."""
+
+    return tuple(f"{profile.key} ({profile.display_name})" for profile in PROFILES.values())
+
+
 def canonical_profile_name(name: str) -> str:
     """Normalize a user-provided stack name to a supported profile key."""
 

{codex_rule_maker-0.2.0 → codex_rule_maker-0.4.0}/codex_builder/prompt.py

@@ -14,7 +14,7 @@ from codex_builder.constants import (
     DEFAULT_STACK,
 )
 from codex_builder.models import ConfigError, ProjectConfig, parse_yes_no
-from codex_builder.profiles import supported_profile_names
+from codex_builder.profiles import supported_profile_labels
 from codex_builder.validator import (
     validate_docs_level,
     validate_existing_directory,
@@ -149,8 +149,8 @@ class PromptSession:
 
     def prompt_stack(self) -> tuple[str, ...]:
         self._write("지원 프로필:")
-        for profile_name in supported_profile_names():
-            self._write(f"- {profile_name}")
+        for profile_label in supported_profile_labels():
+            self._write(f"- {profile_label}")
 
         while True:
             raw_stack = self.prompt_text("사용 스택", ",".join(DEFAULT_STACK))

{codex_rule_maker-0.2.0 → codex_rule_maker-0.4.0}/codex_builder/template_renderer.py

@@ -85,7 +85,7 @@ class TemplateRenderer:
                     "- Do not put all logic in one file for convenience.",
                     "- Do not place business logic in controllers, route handlers, or UI components.",
                     "- Do not return persistence entities directly from public APIs.",
-                    "- Do not complete external integrations with fake implementations.",
+                "- Implement external integrations against their confirmed contracts and keep failure behavior explicit.",
                     "- Do not add core code without documenting the intent when the behavior is non-obvious.",
                 ]
             )
@@ -119,7 +119,7 @@ class TemplateRenderer:
                 "- 편의를 위해 모든 로직을 한 파일에 몰아넣지 않는다.",
                 "- controller, route handler, UI component에 비즈니스 로직을 넣지 않는다.",
                 "- persistence entity를 public API 응답으로 직접 반환하지 않는다.",
-                "- 외부 연동을 가짜 구현으로 완성한 것처럼 만들지 않는다.",
+                "- 외부 연동은 확인된 계약을 기준으로 구현하고 실패 동작을 명시한다.",
                 "- 동작이 비명시적인 핵심 코드에 의도 설명 없이 코드를 추가하지 않는다.",
             ]
         )
@@ -139,7 +139,7 @@ class TemplateRenderer:
                 lines.extend(
                     [
                         "- External API calls must go through a dedicated client/adapter layer.",
-                        "- Do not fake completed external integrations. Leave clear TODOs when credentials or contracts are missing.",
+                        "- Implement confirmed credentials, contracts, schemas, and failure handling together.",
                     ]
                 )
             if config.database:
@@ -160,7 +160,7 @@ class TemplateRenderer:
             lines.extend(
                 [
                     "- 외부 API 호출은 반드시 전용 client/adapter 계층을 통해 수행한다.",
-                    "- 계약이나 인증 정보가 없는 외부 연동은 완성된 것처럼 꾸미지 말고 명확한 TODO를 남긴다.",
+                    "- 외부 연동은 인증 정보, 계약, schema, 실패 처리를 실제 구현과 함께 관리한다.",
                 ]
             )
         if config.database:
@@ -174,7 +174,7 @@ class TemplateRenderer:
             lines = [
                 f"# Architecture Rules - {config.project_name}",
                 "",
-                "This project follows a layered architecture. Keep responsibilities explicit and directional.",
+                "This project follows a feature-first layered architecture. Keep responsibilities explicit and directional.",
                 "",
                 "[Directory Structure]",
             ]
@@ -183,6 +183,11 @@ class TemplateRenderer:
                     lines.extend(f"- `{directory}`" for directory in profile.directories)
             lines.extend(
                 [
+                    "",
+                    "[Feature Module Layout]",
+                    "- Prefer feature/domain folders as the outer boundary, such as `login`, `post`, or `talk`.",
+                    "- Place layer folders such as `controllers`, `services`, `repositories`, `schemas`, `entities`, `components`, or `hooks` inside each feature when the active profile uses them.",
+                    "- Keep cross-cutting code in shared/core/infrastructure folders only when it is reused by multiple features.",
                     "",
                     "[Layer Responsibilities]",
                     "- Presentation/API layers handle request parsing, response mapping, routing, and UI composition only.",
@@ -203,7 +208,7 @@ class TemplateRenderer:
             lines = [
                 f"# 아키텍처 규칙 - {config.project_name}",
                 "",
-                "이 프로젝트는 명확한 계층형 아키텍처를 따른다. 책임과 의존성 방향을 반드시 분리한다.",
+                "이 프로젝트는 기능 우선 계층형 아키텍처를 따른다. 책임과 의존성 방향을 반드시 분리한다.",
                 "",
                 "[디렉토리 구조]",
             ]
@@ -212,6 +217,11 @@ class TemplateRenderer:
                     lines.extend(f"- `{directory}`" for directory in profile.directories)
             lines.extend(
                 [
+                    "",
+                    "[기능 모듈 배치]",
+                    "- `login`, `post`, `talk` 같은 기능/도메인 폴더를 바깥 경계로 우선한다.",
+                    "- 활성 profile에서 사용하는 `controllers`, `services`, `repositories`, `schemas`, `entities`, `components`, `hooks` 같은 계층 폴더는 각 기능 폴더 안에 둔다.",
+                    "- 여러 기능에서 공유하는 설정, 공통 middleware, 공통 client만 shared/core/infrastructure에 둔다.",
                     "",
                     "[계층 책임]",
                     "- Presentation/API 계층은 요청 파싱, 응답 변환, 라우팅, 화면 조립만 담당한다.",
@@ -253,7 +263,7 @@ class TemplateRenderer:
                 "[Spacing Rules]",
                 "- Keep method boundaries visually obvious. Use the repository's formatter when it enforces exact blank lines.",
                 "- When the formatter allows manual spacing, keep five blank-line units between methods.",
-                "- Inside a method, separate unrelated logic blocks with two blank-line units when the formatter allows it.",
+                "- Inside a method, separate unrelated logic blocks with three blank-line units when the formatter allows it.",
                 "- If a function signature, expression, query, JSX block, or builder chain spans multiple lines, leave a blank line before starting the next logic block.",
                 "- Do not compress validation, transformation, persistence, and response mapping into one dense block.",
                 "",
@@ -313,7 +323,7 @@ class TemplateRenderer:
                 "[공백 규칙]",
                 "- 메서드 경계는 눈으로 분명히 구분되어야 한다. 정확한 공백 수는 저장소 formatter가 강제하면 formatter를 따른다.",
                 "- formatter가 수동 공백을 허용하면 메서드 간 5칸 공백을 둔다.",
-                "- 메서드 내부의 연관 없는 로직 블록 간에는 formatter가 허용하는 범위에서 2칸 공백을 둔다.",
+                "- 메서드 내부의 연관 없는 로직 블록 간에는 formatter가 허용하는 범위에서 3칸 공백을 둔다.",
                 "- 함수 시그니처, 표현식, 쿼리, JSX block, builder chain이 여러 줄에 걸쳐 작성되면 다음 로직 블록 전에는 반드시 공백을 둔다.",
                 "- validation, transformation, persistence, response mapping을 하나의 빽빽한 블록으로 압축하지 않는다.",
                 "",
@@ -777,34 +787,16 @@ class TemplateRenderer:
                 "- Third-party HTTP APIs or SDKs",
                 "- Any system outside the current repository process",
                 "",
-                "[Rules]",
-                "- Do not implement an integration as complete unless credentials, contract, timeout behavior, and failure mapping are known.",
-                "- When the contract is missing, write only the class/method boundary and leave the body as `pass` or the language equivalent.",
-                "- Add TODO comments that state required input, expected output, upstream endpoint or SDK method, timeout, retry, and error mapping.",
+                "[Implementation]",
+                "- Implement external calls with the confirmed credentials, contract, timeout behavior, and failure mapping.",
                 "- Services call integrations through narrow methods that describe business intent.",
                 "- Convert upstream DTOs into internal DTOs before returning data to callers.",
-                "",
-                "[Python Skeleton]",
-                "```python",
-                "def request_external_job(self, request_dto: ExternalJobRequestDto) -> ExternalJobResponseDto:",
-                '    """Request a job from the external system."""',
-                "    # TODO: define upstream endpoint, request fields, response fields, timeout, retry, and failure mapping.",
-                "    pass",
-                "```",
+                "- Keep request/response schemas and integration documentation synchronized with the implementation.",
                 "",
                 "[Prohibited]",
-                "- Fake API implementations.",
-                "- Random sample data that pretends to be upstream data.",
+                "- Fabricated upstream responses or behavior that bypasses the confirmed contract.",
                 "- Calling external HTTP or SDK code directly from controllers or UI components.",
             ]
-            if not config.external_api_enabled:
-                lines.extend(
-                    [
-                        "",
-                        "[When External APIs Are Added Later]",
-                        "- Update project configuration and docs before introducing the integration.",
-                    ]
-                )
             for profile in profiles:
                 lines.extend(["", f"[{profile.display_name} Integration Notes]"])
                 lines.extend(self._bullets(self._profile_external_rules(profile, config.language)))
@@ -821,34 +813,15 @@ class TemplateRenderer:
             "- Third-party HTTP API 또는 SDK",
             "- 현재 저장소 프로세스 밖의 모든 시스템",
             "",
-            "[규칙]",
-            "- 인증 정보, 계약, timeout, 실패 매핑이 확인되지 않은 연동은 완성 구현으로 작성하지 않는다.",
-            "- 계약이 없으면 class/method 경계만 작성하고 본문은 `pass` 또는 해당 언어의 미구현 표현으로 둔다.",
-            "- TODO 주석에는 필요한 입력, 기대 출력, upstream endpoint 또는 SDK method, timeout, retry, error mapping을 명확히 적는다.",
+            "[구현 규칙]",
+            "- 확인된 인증 정보, 계약, timeout, 실패 매핑을 기준으로 외부 호출을 구현한다.",
             "- Service는 비즈니스 의도를 드러내는 좁은 메서드로 외부 연동을 호출한다.",
             "- Upstream DTO는 내부 DTO로 변환한 뒤 호출자에게 반환한다.",
-            "",
-            "[Python 뼈대]",
-            "```python",
-            "def request_external_job(self, request_dto: ExternalJobRequestDto) -> ExternalJobResponseDto:",
-            '    """외부 시스템에 작업 생성을 요청한다."""',
-            "    # TODO: upstream endpoint, request field, response field, timeout, retry, failure mapping 정의 필요.",
-            "    pass",
-            "```",
+            "- Request/Response schema와 연동 문서는 실제 구현과 함께 갱신한다.",
             "",
             "[금지]",
-            "- 외부 API fake 구현",
-            "- upstream 데이터처럼 보이는 임의 샘플 데이터 생성",
             "- controller 또는 UI component에서 외부 HTTP/SDK 직접 호출",
         ]
-        if not config.external_api_enabled:
-            lines.extend(
-                [
-                    "",
-                    "[나중에 외부 API가 추가되는 경우]",
-                    "- 연동을 도입하기 전에 프로젝트 설정과 문서를 먼저 갱신한다.",
-                ]
-            )
         for profile in profiles:
             lines.extend(["", f"[{profile.display_name} 연동 메모]"])
             lines.extend(self._bullets(self._profile_external_rules(profile, config.language)))
@@ -978,9 +951,11 @@ class TemplateRenderer:
                 "- Directory path",
                 "- Major file path",
                 "- Responsibility",
-                "- Owner layer or feature",
+                "- Owner feature and layer",
                 "- Notes about important dependencies",
                 "",
+                "Use feature/domain folders as the outer boundary and document layer folders underneath each feature.",
+                "",
                 "## Current Structure",
                 "| Path | Type | Responsibility | Owner | Notes |",
                 "| --- | --- | --- | --- | --- |",
@@ -999,9 +974,11 @@ class TemplateRenderer:
             "- 디렉토리 경로",
             "- 주요 파일 경로",
             "- 책임",
-            "- 담당 계층 또는 기능",
+            "- 담당 기능 및 계층",
             "- 중요한 의존성 메모",
             "",
+            "기능/도메인 폴더를 바깥 경계로 두고, 각 기능 하위의 계층 폴더를 문서화한다.",
+            "",
             "## 현재 구조",
             "| Path | Type | Responsibility | Owner | Notes |",
             "| --- | --- | --- | --- | --- |",
@@ -1033,6 +1010,7 @@ class TemplateRenderer:
                 "## Layer Direction",
                 "- Document the real dependency direction used by this project.",
                 "- Explain what each layer may import and what it must not import.",
+                "- Keep feature/domain folders as ownership boundaries and place each feature's layers underneath them.",
                 "",
                 "## Profile Architecture Notes",
             ]
@@ -1071,6 +1049,7 @@ class TemplateRenderer:
             "## 계층 방향",
             "- 이 프로젝트가 실제로 사용하는 의존성 방향을 기록한다.",
             "- 각 계층이 import할 수 있는 대상과 금지 대상을 설명한다.",
+            "- 기능/도메인 폴더를 소유권 경계로 두고 각 기능 하위에 계층 폴더를 둔다.",
             "",
             "## 프로필별 아키텍처 메모",
         ]
@@ -1590,7 +1569,7 @@ class TemplateRenderer:
                     "   - API design",
                     "   - Service logic",
                     "   - Controller/route/UI boundary work",
-                    "   - External integration skeleton",
+                    "   - External integration",
                     "   - Refactoring",
                     "   - Documentation",
                     "5. Apply the `.codex` rules that match the task type before editing files.",
@@ -1604,7 +1583,7 @@ class TemplateRenderer:
                     "- Do not invent behavior that is not defined by the request or reference documents.",
                     "- Do not treat `.codex/ref_docs` as generated project documentation; it is a user-managed reference space.",
                     "- Keep project specs in root `docs/`.",
-                    "- For external integrations without a confirmed contract, write only class/method boundaries and TODOs; leave the body unimplemented.",
+                    "- For external integrations, implement the confirmed contract through a dedicated client/adapter and keep its documentation synchronized.",
                     "- After code changes, update required documentation in the same task.",
                     "",
                     "Response behavior:",
@@ -1643,7 +1622,7 @@ class TemplateRenderer:
                 "   - API 설계",
                 "   - 서비스 로직 작성",
                 "   - 컨트롤러/라우트/UI 경계 작업",
-                "   - 외부 연동 메서드 뼈대 작성",
+                "   - 외부 연동 구현",
                 "   - 리팩토링",
                 "   - 문서화",
                 "5. 판단한 작업 유형에 맞는 `.codex` 규칙을 우선 적용하라.",
@@ -1658,7 +1637,7 @@ class TemplateRenderer:
                 "- 요청이나 참고 문서에 없는 기능을 임의로 추가하지 않는다.",
                 "- `.codex/ref_docs`를 생성된 프로젝트 명세 위치로 취급하지 않는다. 이 위치는 사용자 관리 참고자료 공간이다.",
                 "- 프로젝트 명세는 프로젝트 루트의 `docs/`에 유지한다.",
-                "- 계약이 확인되지 않은 외부 연동은 class/method 경계와 TODO만 작성하고 본문은 미구현으로 둔다.",
+                "- 외부 연동은 확인된 계약을 전용 client/adapter로 구현하고 관련 문서를 실제 동작과 함께 갱신한다.",
                 "- 코드 수정 후 필요한 문서도 같은 작업 안에서 함께 수정한다.",
                 "",
                 "응답 방식도 아래를 따라라.",
@@ -1837,7 +1816,7 @@ class TemplateRenderer:
                 "fullstack-fastapi-react": (
                     "Backend owns private upstream integrations; frontend calls backend services only.",
                     "Document any backend-to-upstream mapping in docs/api/specification.md when it affects public behavior.",
-                    "Keep frontend mocks aligned with backend API contracts.",
+                    "Keep frontend API contract tests aligned with backend API contracts.",
                 ),
             }
             return rules.get(profile.key, ("Keep external integrations behind framework-appropriate adapter boundaries.",))
@@ -1876,7 +1855,7 @@ class TemplateRenderer:
             "fullstack-fastapi-react": (
                 "Private upstream integration은 backend가 소유하고 frontend는 backend service만 호출한다.",
                 "공개 동작에 영향을 주는 backend-to-upstream mapping은 docs/api/specification.md에 문서화한다.",
-                "Frontend mock은 backend API contract와 불일치하지 않게 관리한다.",
+                "Frontend API contract tests는 backend API contract와 불일치하지 않게 관리한다.",
             ),
         }
         return rules.get(profile.key, ("외부 연동은 framework에 맞는 adapter 경계 뒤에 둔다.",))

{codex_rule_maker-0.2.0 → codex_rule_maker-0.4.0}/codex_rule_maker.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-rule-maker
-Version: 0.2.0
+Version: 0.4.0
 Summary: CLI tool that generates a .codex folder with AI developer rules and project reference documents.
 Author: codex-rule-maker
 Project-URL: Homepage, https://github.com/Sharon77770/codex_rule_maker
@@ -21,13 +21,17 @@ Classifier: Topic :: Software Development :: Code Generators
 Classifier: Topic :: Software Development :: Documentation
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Provides-Extra: dev
 Requires-Dist: build<2,>=1; extra == "dev"
 Requires-Dist: pytest<9,>=7; extra == "dev"
 Requires-Dist: twine<7,>=5; extra == "dev"
+Dynamic: license-file
 
 # codex-rule-maker
 
+현재 버전: `0.4.0`
+
 `codex-rule-maker`는 프로젝트 루트에 `.codex` 규칙 폴더와 `docs/` 프로젝트 문서 템플릿을 자동 구성하는 Python CLI 도구입니다. 사용자가 프로젝트 이름, 설명, 스택, DB, 인증 여부, 외부 API 여부, 문서화 수준, 문서 언어를 입력하면 Codex가 작업 전에 읽을 개발 규칙과 프로젝트 문서 구조를 생성합니다.
 
 ## 설치
@@ -222,19 +226,22 @@ docs/
 
 ## 지원 프레임워크 프로필
 
-- `fastapi`: controller/service/repository/schema/entity 계층 분리
-- `python`: 일반 Python package/module/service/adapter/CLI 경계 분리
-- `springboot`: controller/service/repository/entity/dto 계층 분리
-- `react`: component/page/hook/service/store 분리
-- `nextjs`: App Router, Server Component와 Client Component 구분
-- `node-express`: route/controller/service/repository 분리
-- `fullstack-fastapi-react`: FastAPI 백엔드와 React 프론트엔드 규칙 동시 적용
+- `fastapi`: 기능 폴더 하위 controller/service/repository/schema/entity 분리
+- `python`: 프레임워크 없는 Python 프로젝트의 기능/도메인 폴더 하위 service/adapter/model/CLI 경계 분리
+- `typescript-javascript`: 프레임워크 없는 TypeScript/JavaScript 프로젝트의 기능/도메인 폴더 하위 service/adapter/model 경계 분리
+- `springboot`: 기능 package 하위 controller/service/repository/entity/dto 분리
+- `react`: 기능 폴더 하위 page/component/hook/service/store 분리
+- `nextjs`: App Router 유지, 기능 폴더 하위 component/service/repository/type 분리
+- `node-express`: 기능 폴더 하위 route/controller/service/repository 분리
+- `fullstack-fastapi-react`: FastAPI 백엔드와 React 프론트엔드 모두 기능 폴더 하위 계층 분리 적용
 
 여러 프로필은 comma로 조합할 수 있습니다.
 
 ```bash
 codex-init --stack fastapi,react
 codex-init --stack python
+codex-init --stack typescript
+codex-init --stack javascript
 codex-init --stack fullstack-fastapi-react
 codex-init --stack nextjs
 ```
@@ -245,7 +252,7 @@ codex-init --stack nextjs
 - `--language en`을 사용하면 영어 문서를 생성합니다.
 - `--docs strict`는 코드 변경 후 문서 업데이트 필수 규칙을 포함합니다.
 - `--auth yes`는 인증/권한 규칙을 포함합니다.
-- `--external-api yes`는 외부 연동 계층 분리 규칙을 포함합니다.
+- `--external-api yes`는 확인된 계약을 기준으로 실제 외부 연동을 구현하기 위한 client/adapter 및 계약 문서 규칙을 포함합니다.
 - `--db mysql`처럼 DB를 지정하면 DB, Repository, Schema 관련 규칙을 포함합니다.
 - 프로젝트 명세 템플릿은 `.codex/ref_docs`가 아니라 `docs/architecture`, `docs/api`, `docs/database`에 생성됩니다.
 

{codex_rule_maker-0.2.0 → codex_rule_maker-0.4.0}/codex_rule_maker.egg-info/SOURCES.txt

@@ -1,3 +1,4 @@
+LICENSE
 README.md
 pyproject.toml
 codex_builder/__init__.py

{codex_rule_maker-0.2.0 → codex_rule_maker-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codex-rule-maker"
-version = "0.2.0"
+version = "0.4.0"
 description = "CLI tool that generates a .codex folder with AI developer rules and project reference documents."
 readme = "README.md"
 requires-python = ">=3.9"

{codex_rule_maker-0.2.0 → codex_rule_maker-0.4.0}/tests/test_builder.py

@@ -72,6 +72,46 @@ def test_python_profile_generation(tmp_path):
     assert "CLI 입력은 domain/service logic에 전달하기 전에 별도 input model로 변환한다" in domain_rules
 
 
+def test_typescript_javascript_profile_generation(tmp_path):
+    config = ProjectConfig(project_name="sample-script", stack=("typescript",))
+
+    CodexBuilder().build(config, target_dir=tmp_path)
+
+    architecture_rules = (tmp_path / ".codex" / "ai_rule_developer" / "ARCHITECTURE_RULES.md").read_text(encoding="utf-8")
+    service_rules = (tmp_path / ".codex" / "ai_rule_developer" / "SERVICE_LAYER_RULES.md").read_text(encoding="utf-8")
+
+    assert "TypeScript/JavaScript" in service_rules
+    assert "Entrypoint -> Application Service -> Domain/Adapter -> External System" in architecture_rules
+    assert "프레임워크 전역 객체" in service_rules
+
+
+def test_spacing_rules_use_three_and_five_units(tmp_path):
+    config = ProjectConfig(project_name="sample-spacing")
+
+    CodexBuilder().build(config, target_dir=tmp_path)
+
+    code_style = (tmp_path / ".codex" / "ai_rule_developer" / "CODE_STYLE_RULES.md").read_text(encoding="utf-8")
+
+    assert "메서드 간 5칸 공백" in code_style
+    assert "로직 블록 간에는 formatter가 허용하는 범위에서 3칸 공백" in code_style
+    assert "2칸 공백" not in code_style
+
+
+def test_external_integration_rules_do_not_defer_to_mock_or_skeleton(tmp_path):
+    config = ProjectConfig(project_name="sample-integration", external_api_enabled=True)
+
+    CodexBuilder().build(config, target_dir=tmp_path)
+
+    integration_rules = (tmp_path / ".codex" / "ai_rule_developer" / "EXTERNAL_INTEGRATION_RULES.md").read_text(encoding="utf-8").lower()
+    start_prompt = (tmp_path / ".codex" / "codex_start_prompt.txt").read_text(encoding="utf-8").lower()
+
+    assert "mock" not in integration_rules
+    assert "skeleton" not in integration_rules
+    assert "pass" not in integration_rules
+    assert "외부 연동 구현" in start_prompt
+    assert "external integration skeleton" not in start_prompt
+
+
 def test_react_profile_generation(tmp_path):
     config = ProjectConfig(project_name="sample-web", stack=("react",))
 

{codex_rule_maker-0.2.0 → codex_rule_maker-0.4.0}/tests/test_cli.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Optional
 
-from codex_builder.cli import main
+from codex_builder.cli import build_parser, main
 
 
 def test_cli_generates_with_options_only(tmp_path):
@@ -32,6 +32,14 @@ def test_cli_generates_with_options_only(tmp_path):
     assert (tmp_path / "docs" / "api" / "specification.md").exists()
 
 
+def test_cli_profile_choices_include_plain_python_and_typescript_javascript():
+    help_text = build_parser().format_help()
+
+    assert "python (Python)" in help_text
+    assert "typescript-javascript" in help_text
+    assert "TypeScript/JavaScript" in help_text
+
+
 def test_cli_generates_python_profile(tmp_path):
     result = main(
         [