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

codex_builder/__init__.py

@@ -0,0 +1,6 @@
+"""Codex folder builder package."""
+
+from codex_builder.builder import CodexBuilder
+from codex_builder.models import BuildResult, ProjectConfig
+
+__all__ = ["BuildResult", "CodexBuilder", "ProjectConfig"]

codex_builder/builder.py

@@ -0,0 +1,91 @@
+"""Filesystem builder for generated .codex folders."""
+
+from __future__ import annotations
+
+import shutil
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, Union
+
+from codex_builder.constants import CODEX_DIR_NAME
+from codex_builder.models import BuildResult, ProjectConfig
+from codex_builder.template_renderer import TemplateRenderer
+
+
+class ExistingCodexError(FileExistsError):
+    """Raised when .codex already exists and force is not enabled."""
+
+
+class CodexBuildError(RuntimeError):
+    """Raised when the builder cannot write the generated files."""
+
+
+class CodexBuilder:
+    """Create a .codex directory from a ProjectConfig."""
+
+    def __init__(self, renderer: Optional[TemplateRenderer] = None) -> None:
+        self._renderer = renderer or TemplateRenderer()
+
+    def build(
+        self,
+        config: ProjectConfig,
+        *,
+        target_dir: Optional[Union[Path, str]] = None,
+        force: bool = False,
+        backup_existing: bool = True,
+    ) -> BuildResult:
+        root = Path(target_dir or Path.cwd()).resolve()
+        codex_dir = root / CODEX_DIR_NAME
+
+        if codex_dir.exists() and not force:
+            raise ExistingCodexError(f"{codex_dir} already exists. Re-run with --force to replace it.")
+
+        rendered_files = self._renderer.render(config)
+
+        backup_dir: Optional[Path] = None
+        if codex_dir.exists():
+            backup_dir = self._replace_existing_codex(codex_dir, backup_existing=backup_existing)
+
+        try:
+            written_files: list[Path] = []
+            for relative_path, content in rendered_files.items():
+                destination = root / relative_path
+                destination.parent.mkdir(parents=True, exist_ok=True)
+                destination.write_text(content.rstrip() + "\n", encoding="utf-8")
+                written_files.append(destination)
+        except OSError as exc:
+            raise CodexBuildError(f"failed to write .codex files: {exc}") from exc
+
+        return BuildResult(
+            codex_dir=codex_dir,
+            written_files=tuple(written_files),
+            backup_dir=backup_dir,
+        )
+
+    def _replace_existing_codex(self, codex_dir: Path, *, backup_existing: bool) -> Optional[Path]:
+        if backup_existing:
+            backup_dir = self._next_backup_path(codex_dir)
+            try:
+                codex_dir.rename(backup_dir)
+            except OSError as exc:
+                raise CodexBuildError(f"failed to backup existing .codex folder: {exc}") from exc
+            return backup_dir
+
+        try:
+            if codex_dir.is_dir():
+                shutil.rmtree(codex_dir)
+            else:
+                codex_dir.unlink()
+        except OSError as exc:
+            raise CodexBuildError(f"failed to remove existing .codex path: {exc}") from exc
+        return None
+
+    def _next_backup_path(self, codex_dir: Path) -> Path:
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        base_backup = codex_dir.with_name(f"{CODEX_DIR_NAME}_backup_{timestamp}")
+        candidate = base_backup
+        index = 1
+        while candidate.exists():
+            candidate = codex_dir.with_name(f"{base_backup.name}.{index}")
+            index += 1
+        return candidate

codex_builder/cli.py

@@ -0,0 +1,96 @@
+"""Command line interface for codex-init."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+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
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="codex-init",
+        description="Generate a .codex folder with AI developer rules and project reference documents.",
+    )
+    parser.add_argument("--name", help="Project name. Defaults to the current directory name.")
+    parser.add_argument("--description", help="Short project description.")
+    parser.add_argument(
+        "--stack",
+        help=f"Comma-separated stack profiles. Supported: {', '.join(supported_profile_names())}.",
+    )
+    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.")
+    parser.add_argument("--external-api", dest="external_api", help="Whether external API integrations are used: yes/no.")
+    parser.add_argument("--docs", dest="docs_level", help="Documentation strictness: light, standard, strict.")
+    parser.add_argument("--language", help="Document language: ko or en.")
+    parser.add_argument("--interactive", action="store_true", help="Prompt for missing values and always show final confirmation.")
+    parser.add_argument("--force", action="store_true", help="Replace an existing .codex folder. Default force behavior creates a backup.")
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="With --force, delete the existing .codex instead of backing it up.",
+    )
+    parser.add_argument(
+        "--target-dir",
+        type=Path,
+        help="Directory where .codex will be created. Defaults to the current working directory.",
+    )
+    return parser
+
+
+def main(argv: Optional[list[str]] = None) -> int:
+    raw_argv = list(sys.argv[1:] if argv is None else argv)
+    parser = build_parser()
+    args = parser.parse_args(raw_argv)
+
+    try:
+        prompt_for_missing = _should_prompt_for_missing(args, raw_argv)
+        request = PromptSession().resolve_request(
+            args,
+            prompt_for_missing=prompt_for_missing,
+            confirm_before_build=prompt_for_missing or (sys.stdin.isatty() and sys.stdout.isatty()),
+        )
+        result = CodexBuilder().build(
+            request.config,
+            target_dir=request.target_dir,
+            force=request.force,
+            backup_existing=request.backup_existing,
+        )
+    except PromptAbort as exc:
+        print(f"codex-init: {exc}")
+        return 0
+    except (ConfigError, UnknownProfileError, ExistingCodexError, CodexBuildError) as exc:
+        print(f"codex-init: error: {exc}", file=sys.stderr)
+        return 1
+
+    print(f"Generated: {result.codex_dir}")
+    if result.backup_dir is not None:
+        print(f"Backup: {result.backup_dir}")
+    print(f"Files written: {len(result.written_files)}")
+    return 0
+
+
+def _should_prompt_for_missing(args: argparse.Namespace, raw_argv: list[str]) -> bool:
+    if args.interactive:
+        return True
+    if not raw_argv:
+        return True
+
+    required_option_values = (
+        args.name,
+        args.stack,
+        args.auth,
+        args.external_api,
+        args.docs_level,
+    )
+    return any(value is None for value in required_option_values)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

codex_builder/constants.py

@@ -0,0 +1,32 @@
+"""Shared constants for generated .codex structures."""
+
+from __future__ import annotations
+
+CODEX_DIR_NAME = ".codex"
+AI_RULE_DIR_NAME = "AI_RULE_DEVELOPER"
+REF_DOCS_DIR_NAME = "REF_DOCS"
+START_PROMPT_FILE_NAME = "codex_start_prompt.txt"
+
+RULE_FILE_NAMES = (
+    "GLOBAL_RULES.md",
+    "ARCHITECTURE_RULES.md",
+    "CODE_STYLE_RULES.md",
+    "API_DESIGN_RULES.md",
+    "DOCUMENT_RULE.md",
+    "TEST_RULES.md",
+    "FRAMEWORK_RULES.md",
+)
+
+REF_DOC_FILE_NAMES = (
+    "PROJECT_OVERVIEW.md",
+    "FEATURE_SPEC.md",
+    "API_SPEC.md",
+    "DB_SPEC.md",
+)
+
+DEFAULT_LANGUAGE = "ko"
+DEFAULT_DOCS_LEVEL = "standard"
+DEFAULT_STACK = ("fastapi",)
+
+SUPPORTED_LANGUAGES = ("ko", "en")
+SUPPORTED_DOCS_LEVELS = ("light", "standard", "strict")

codex_builder/models.py

@@ -0,0 +1,110 @@
+"""Data models and value parsing helpers."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterable, Optional, Union
+
+from codex_builder.constants import (
+    DEFAULT_DOCS_LEVEL,
+    DEFAULT_LANGUAGE,
+    DEFAULT_STACK,
+    SUPPORTED_DOCS_LEVELS,
+    SUPPORTED_LANGUAGES,
+)
+
+
+class ConfigError(ValueError):
+    """Raised when a CLI or builder configuration is invalid."""
+
+
+@dataclass(frozen=True)
+class ProjectConfig:
+    """Normalized user inputs used to render the .codex document set."""
+
+    project_name: str
+    description: str = ""
+    stack: tuple[str, ...] = DEFAULT_STACK
+    database: Optional[str] = None
+    auth_enabled: bool = False
+    external_api_enabled: bool = False
+    docs_level: str = DEFAULT_DOCS_LEVEL
+    language: str = DEFAULT_LANGUAGE
+
+    def __post_init__(self) -> None:
+        project_name = self.project_name.strip()
+        if not project_name:
+            raise ConfigError("project name is required")
+
+        normalized_stack = normalize_stack(self.stack)
+        if not normalized_stack:
+            normalized_stack = DEFAULT_STACK
+
+        docs_level = self.docs_level.strip().lower()
+        if docs_level not in SUPPORTED_DOCS_LEVELS:
+            allowed = ", ".join(SUPPORTED_DOCS_LEVELS)
+            raise ConfigError(f"docs level must be one of: {allowed}")
+
+        language = self.language.strip().lower()
+        if language not in SUPPORTED_LANGUAGES:
+            allowed = ", ".join(SUPPORTED_LANGUAGES)
+            raise ConfigError(f"language must be one of: {allowed}")
+
+        database = self.database.strip().lower() if self.database else None
+
+        object.__setattr__(self, "project_name", project_name)
+        object.__setattr__(self, "description", self.description.strip())
+        object.__setattr__(self, "stack", normalized_stack)
+        object.__setattr__(self, "database", database)
+        object.__setattr__(self, "docs_level", docs_level)
+        object.__setattr__(self, "language", language)
+
+
+@dataclass(frozen=True)
+class BuildResult:
+    """Result returned after generating a .codex folder."""
+
+    codex_dir: Path
+    written_files: tuple[Path, ...]
+    backup_dir: Optional[Path] = None
+
+
+def normalize_stack(raw_stack: Optional[Union[str, Iterable[str]]]) -> tuple[str, ...]:
+    """Normalize comma-separated or iterable stack values."""
+
+    if raw_stack is None:
+        return DEFAULT_STACK
+
+    if isinstance(raw_stack, str):
+        items = raw_stack.split(",")
+    else:
+        items = []
+        for value in raw_stack:
+            items.extend(str(value).split(","))
+
+    normalized: list[str] = []
+    for item in items:
+        value = item.strip().lower()
+        if value and value not in normalized:
+            normalized.append(value)
+
+    return tuple(normalized)
+
+
+def parse_yes_no(value: Optional[Union[str, bool]], *, default: bool = False) -> bool:
+    """Parse common yes/no CLI values into a bool."""
+
+    if value is None:
+        return default
+
+    if isinstance(value, bool):
+        return value
+
+    normalized = value.strip().lower()
+    if normalized in {"y", "yes", "true", "1", "on"}:
+        return True
+    if normalized in {"n", "no", "false", "0", "off"}:
+        return False
+
+    raise ConfigError(f"expected yes/no value, got: {value}")