modify harness framework

scripts/execute.py

@@ -8,10 +8,8 @@ Usage:
 
 import argparse
 import contextlib
-import fnmatch
 import json
 import os
-import re
 import subprocess
 import sys
 import threading
@@ -24,6 +22,10 @@ from typing import Optional
 ROOT = Path(__file__).resolve().parent.parent
 
 
+class CodexEnvironmentError(RuntimeError):
+    """재시도로 해결할 수 없는 Codex CLI 환경 오류."""
+
+
 @contextlib.contextmanager
 def progress_indicator(label: str):
     """터미널 진행 표시기. with 문으로 사용하며 .elapsed 로 경과 시간을 읽는다."""
@@ -56,10 +58,6 @@ class StepExecutor:
     """Phase 디렉토리 안의 step들을 순차 실행하는 하네스."""
 
     MAX_RETRIES = 3
-    VALIDATION_COMMANDS = (
-        [sys.executable, "-m", "unittest", "discover", "-s", "scripts", "-p", "test_*.py"],
-        [sys.executable, "scripts/validate_workspace.py"],
-    )
     FEAT_MSG = "feat({phase}): step {num} — {name}"
     CHORE_MSG = "chore({phase}): step {num} output"
     TZ = timezone(timedelta(hours=9))
@@ -89,7 +87,6 @@ class StepExecutor:
     def run(self):
         self._print_header()
         self._check_blockers()
-        self._assert_clean_worktree("before branch checkout")
         self._checkout_branch()
         guardrails = self._load_guardrails()
         self._ensure_created_at()
@@ -117,117 +114,8 @@ class StepExecutor:
         cmd = ["git"] + list(args)
         return subprocess.run(cmd, cwd=self._root, capture_output=True, text=True)
 
-    def _validate_before_commit(self, commit_message: str):
-        print(f"  Validation before commit: {commit_message}")
-        for cmd in self.VALIDATION_COMMANDS:
-            r = subprocess.run(cmd, cwd=self._root, capture_output=True, text=True)
-            if r.returncode != 0:
-                print(f"  ERROR: validation failed before commit: {' '.join(cmd)}")
-                if r.stdout:
-                    print(r.stdout[-2000:])
-                if r.stderr:
-                    print(r.stderr[-2000:])
-                sys.exit(1)
-
-    def _branch_name(self) -> str:
-        slug = re.sub(r"[^A-Za-z0-9._-]+", "-", self._phase_name.strip())
-        slug = slug.strip("/.-")
-        if not slug:
-            slug = self._phase_dir_name
-        return f"codex/{slug}"
-
-    def _assert_clean_worktree(self, context: str):
-        r = self._run_git("status", "--porcelain")
-        if r.returncode != 0:
-            print("  ERROR: git status failed.")
-            print(f"  {r.stderr.strip()}")
-            sys.exit(1)
-        dirty = r.stdout.strip()
-        if dirty:
-            print(f"  ERROR: dirty worktree detected {context}.")
-            print("  Commit, stash, or remove these changes before running scripts/execute.py:")
-            for line in dirty.splitlines():
-                print(f"    {line}")
-            sys.exit(1)
-
-    @staticmethod
-    def _normalize_rel_path(path: str) -> str:
-        return path.replace("\\", "/").lstrip("./")
-
-    def _path_allowed(self, path: str, patterns: list[str]) -> bool:
-        rel = self._normalize_rel_path(path)
-        for raw in patterns:
-            pattern = self._normalize_rel_path(str(raw))
-            if not pattern:
-                continue
-            if pattern.endswith("/") and rel.startswith(pattern):
-                return True
-            if any(ch in pattern for ch in "*?[") and fnmatch.fnmatchcase(rel, pattern):
-                return True
-            if rel == pattern:
-                return True
-        return False
-
-    def _validate_step_allowlist(self, step: dict):
-        allowed = step.get("allowed_paths")
-        if (
-            not isinstance(allowed, list)
-            or not allowed
-            or not all(isinstance(p, str) and p.strip() for p in allowed)
-        ):
-            print(f"  ERROR: Step {step.get('step')} must define non-empty allowed_paths.")
-            sys.exit(1)
-
-    def _changed_paths(self) -> list[str]:
-        paths: list[str] = []
-        tracked = self._run_git("diff", "--name-only")
-        if tracked.returncode != 0:
-            print("  ERROR: git diff --name-only failed.")
-            print(f"  {tracked.stderr.strip()}")
-            sys.exit(1)
-        paths.extend(tracked.stdout.splitlines())
-
-        staged = self._run_git("diff", "--cached", "--name-only")
-        if staged.returncode != 0:
-            print("  ERROR: git diff --cached --name-only failed.")
-            print(f"  {staged.stderr.strip()}")
-            sys.exit(1)
-        paths.extend(staged.stdout.splitlines())
-
-        untracked = self._run_git("ls-files", "--others", "--exclude-standard")
-        if untracked.returncode != 0:
-            print("  ERROR: git ls-files --others failed.")
-            print(f"  {untracked.stderr.strip()}")
-            sys.exit(1)
-        paths.extend(untracked.stdout.splitlines())
-
-        return sorted({self._normalize_rel_path(p) for p in paths if p.strip()})
-
-    def _housekeeping_paths(self, step_num: int) -> set[str]:
-        return {
-            f"phases/{self._phase_dir_name}/index.json",
-            f"phases/{self._phase_dir_name}/step{step_num}-output.json",
-            "phases/index.json",
-        }
-
-    def _classify_step_changes(self, step_num: int, step: dict, changed_paths: list[str]) -> tuple[list[str], list[str], list[str]]:
-        allowed_patterns = step.get("allowed_paths", [])
-        housekeeping_set = self._housekeeping_paths(step_num)
-        allowed: list[str] = []
-        housekeeping: list[str] = []
-        disallowed: list[str] = []
-        for path in changed_paths:
-            rel = self._normalize_rel_path(path)
-            if rel in housekeeping_set:
-                housekeeping.append(rel)
-            elif self._path_allowed(rel, allowed_patterns):
-                allowed.append(rel)
-            else:
-                disallowed.append(rel)
-        return allowed, housekeeping, disallowed
-
     def _checkout_branch(self):
-        branch = self._branch_name()
+        branch = f"feat-{self._phase_name}"
 
         r = self._run_git("rev-parse", "--abbrev-ref", "HEAD")
         if r.returncode != 0:
@@ -249,45 +137,28 @@ class StepExecutor:
 
         print(f"  Branch: {branch}")
 
-    def _stage_paths(self, paths: list[str]):
-        if not paths:
-            return
-        r = self._run_git("add", "--", *paths)
-        if r.returncode != 0:
-            print("  ERROR: git add failed.")
-            print(f"  {r.stderr.strip()}")
-            sys.exit(1)
+    def _commit_step(self, step_num: int, step_name: str):
+        output_rel = f"phases/{self._phase_dir_name}/step{step_num}-output.json"
+        index_rel = f"phases/{self._phase_dir_name}/index.json"
 
-    def _commit_step(self, step: dict, step_name: str):
-        step_num = step["step"]
-        changed = self._changed_paths()
-        allowed, housekeeping, disallowed = self._classify_step_changes(step_num, step, changed)
-        if disallowed:
-            print(f"  ERROR: Step {step_num} modified files outside allowed_paths:")
-            for path in disallowed:
-                print(f"    {path}")
-            sys.exit(1)
+        self._run_git("add", "-A")
+        self._run_git("reset", "HEAD", "--", output_rel)
+        self._run_git("reset", "HEAD", "--", index_rel)
 
-        if allowed:
+        if self._run_git("diff", "--cached", "--quiet").returncode != 0:
             msg = self.FEAT_MSG.format(phase=self._phase_name, num=step_num, name=step_name)
-            self._validate_before_commit(msg)
-            self._stage_paths(allowed)
-            if self._run_git("diff", "--cached", "--quiet").returncode != 0:
-                r = self._run_git("commit", "-m", msg)
-                if r.returncode != 0:
-                    print(f"  ERROR: code commit failed: {r.stderr.strip()}")
-                    sys.exit(1)
+            r = self._run_git("commit", "-m", msg)
+            if r.returncode == 0:
                 print(f"  Commit: {msg}")
+            else:
+                print(f"  WARN: 코드 커밋 실패: {r.stderr.strip()}")
 
-        if housekeeping:
+        self._run_git("add", "-A")
+        if self._run_git("diff", "--cached", "--quiet").returncode != 0:
             msg = self.CHORE_MSG.format(phase=self._phase_name, num=step_num)
-            self._validate_before_commit(msg)
-            self._stage_paths(housekeeping)
-            if self._run_git("diff", "--cached", "--quiet").returncode != 0:
-                r = self._run_git("commit", "-m", msg)
-                if r.returncode != 0:
-                    print(f"  ERROR: housekeeping commit failed: {r.stderr.strip()}")
-                    sys.exit(1)
+            r = self._run_git("commit", "-m", msg)
+            if r.returncode != 0:
+                print(f"  WARN: housekeeping 커밋 실패: {r.stderr.strip()}")
 
     # --- top-level index ---
 
@@ -311,11 +182,16 @@ class StepExecutor:
         sections = []
         agents_md = ROOT / "AGENTS.md"
         if agents_md.exists():
-            sections.append(f"## 프로젝트 규칙 (AGENTS.md)\n\n{agents_md.read_text(encoding='utf-8')}")
+            sections.append(
+                "## 프로젝트 규칙 (AGENTS.md)\n\n"
+                f"{agents_md.read_text(encoding='utf-8')}"
+            )
         docs_dir = ROOT / "docs"
         if docs_dir.is_dir():
             for doc in sorted(docs_dir.glob("*.md")):
-                sections.append(f"## {doc.stem}\n\n{doc.read_text(encoding='utf-8')}")
+                sections.append(
+                    f"## {doc.stem}\n\n{doc.read_text(encoding='utf-8')}"
+                )
         return "\n\n---\n\n".join(sections) if sections else ""
 
     @staticmethod
@@ -330,11 +206,7 @@ class StepExecutor:
         return "## 이전 Step 산출물\n\n" + "\n".join(lines) + "\n\n"
 
     def _build_preamble(self, guardrails: str, step_context: str,
-                        allowed_paths: list[str],
                         prev_error: Optional[str] = None) -> str:
-        commit_example = self.FEAT_MSG.format(
-            phase=self._phase_name, num="N", name="<step-name>"
-        )
         retry_section = ""
         if prev_error:
             retry_section = (
@@ -345,9 +217,6 @@ class StepExecutor:
             f"당신은 {self._project} 프로젝트의 개발자입니다. 아래 step을 수행하세요.\n\n"
             f"{guardrails}\n\n---\n\n"
             f"{step_context}{retry_section}"
-            f"## Step file allowlist\n\n"
-            f"This step may modify only these repository-relative paths:\n"
-            f"{chr(10).join(f'- {p}' for p in allowed_paths)}\n\n"
             f"## 작업 규칙\n\n"
             f"1. 이전 step에서 작성된 코드를 확인하고 일관성을 유지하라.\n"
             f"2. 이 step에 명시된 작업만 수행하라. 추가 기능이나 파일을 만들지 마라.\n"
@@ -357,8 +226,8 @@ class StepExecutor:
             f"   - AC 통과 → \"completed\" + \"summary\" 필드에 이 step의 산출물을 한 줄로 요약\n"
             f"   - {self.MAX_RETRIES}회 수정 시도 후에도 실패 → \"error\" + \"error_message\" 기록\n"
             f"   - 사용자 개입이 필요한 경우 (API 키, 인증, 수동 설정 등) → \"blocked\" + \"blocked_reason\" 기록 후 즉시 중단\n"
-            f"6. 모든 변경사항을 커밋하라:\n"
-            f"   {commit_example}\n\n---\n\n"
+            f"6. 변경사항을 직접 커밋하지 마라. Git 커밋과 timestamp는 실행기가 처리한다.\n\n"
+            f"---\n\n"
         )
 
     # --- Codex 호출 ---
@@ -372,10 +241,30 @@ class StepExecutor:
             sys.exit(1)
 
         prompt = preamble + step_file.read_text(encoding="utf-8")
-        result = subprocess.run(
-            ["codex", "exec", "--dangerously-bypass-approvals-and-sandbox", "--json", prompt],
-            cwd=self._root, capture_output=True, text=True, timeout=1800,
-        )
+        command = [
+            "codex",
+            "exec",
+            "--json",
+            "--sandbox",
+            "workspace-write",
+            "--dangerously-bypass-hook-trust",
+            "--cd",
+            self._root,
+            "-",
+        ]
+        try:
+            result = subprocess.run(
+                command,
+                cwd=self._root,
+                input=prompt,
+                capture_output=True,
+                text=True,
+                timeout=1800,
+            )
+        except FileNotFoundError as exc:
+            raise CodexEnvironmentError(
+                "Codex CLI를 찾을 수 없습니다. codex를 설치하고 PATH를 확인하세요."
+            ) from exc
 
         if result.returncode != 0:
             print(f"\n  WARN: Codex가 비정상 종료됨 (code {result.returncode})")
@@ -388,11 +277,28 @@ class StepExecutor:
             "stdout": result.stdout, "stderr": result.stderr,
         }
         out_path = self._phase_dir / f"step{step_num}-output.json"
-        with open(out_path, "w", encoding="utf-8") as f:
-            json.dump(output, f, indent=2, ensure_ascii=False)
+        self._write_json(out_path, output)
 
         return output
 
+    @staticmethod
+    def _codex_environment_failure(output: dict) -> Optional[str]:
+        if output.get("exitCode", 0) == 0:
+            return None
+        diagnostic = (
+            f"{output.get('stderr', '')}\n{output.get('stdout', '')}"
+        ).lower()
+        markers = {
+            "not logged in": "Codex 인증이 필요합니다.",
+            "authentication": "Codex 인증에 실패했습니다.",
+            "unexpected argument": "현재 Codex CLI가 필요한 옵션을 지원하지 않습니다.",
+            "unrecognized option": "현재 Codex CLI가 필요한 옵션을 지원하지 않습니다.",
+        }
+        for marker, message in markers.items():
+            if marker in diagnostic:
+                return message
+        return None
+
     # --- 헤더 & 검증 ---
 
     def _print_header(self):
@@ -436,16 +342,20 @@ class StepExecutor:
         for attempt in range(1, self.MAX_RETRIES + 1):
             index = self._read_json(self._index_file)
             step_context = self._build_step_context(index)
-            preamble = self._build_preamble(guardrails, step_context, step.get("allowed_paths", []), prev_error)
+            preamble = self._build_preamble(guardrails, step_context, prev_error)
 
             tag = f"Step {step_num}/{self._total - 1} ({done} done): {step_name}"
             if attempt > 1:
                 tag += f" [retry {attempt}/{self.MAX_RETRIES}]"
 
             with progress_indicator(tag) as pi:
-                self._invoke_codex(step, preamble)
+                output = self._invoke_codex(step, preamble)
                 elapsed = int(pi.elapsed)
 
+            environment_failure = self._codex_environment_failure(output)
+            if environment_failure:
+                raise CodexEnvironmentError(environment_failure)
+
             index = self._read_json(self._index_file)
             status = next((s.get("status", "pending") for s in index["steps"] if s["step"] == step_num), "pending")
             ts = self._stamp()
@@ -455,7 +365,7 @@ class StepExecutor:
                     if s["step"] == step_num:
                         s["completed_at"] = ts
                 self._write_json(self._index_file, index)
-                self._commit_step(step, step_name)
+                self._commit_step(step_num, step_name)
                 print(f"  ✓ Step {step_num}: {step_name} [{elapsed}s]")
                 return True
 
@@ -470,9 +380,22 @@ class StepExecutor:
                 self._update_top_index("blocked")
                 sys.exit(2)
 
+            runtime_error = ""
+            if output["exitCode"] != 0:
+                runtime_error = (
+                    output.get("stderr", "").strip()
+                    or output.get("stdout", "").strip()
+                )
             err_msg = next(
-                (s.get("error_message", "Step did not update status") for s in index["steps"] if s["step"] == step_num),
-                "Step did not update status",
+                (
+                    s.get(
+                        "error_message",
+                        runtime_error or "Step did not update status",
+                    )
+                    for s in index["steps"]
+                    if s["step"] == step_num
+                ),
+                runtime_error or "Step did not update status",
             )
 
             if attempt < self.MAX_RETRIES:
@@ -490,7 +413,7 @@ class StepExecutor:
                         s["error_message"] = f"[{self.MAX_RETRIES}회 시도 후 실패] {err_msg}"
                         s["failed_at"] = ts
                 self._write_json(self._index_file, index)
-                self._commit_step(step, step_name)
+                self._commit_step(step_num, step_name)
                 print(f"  ✗ Step {step_num}: {step_name} failed after {self.MAX_RETRIES} attempts [{elapsed}s]")
                 print(f"    Error: {err_msg}")
                 self._update_top_index("error")
@@ -506,7 +429,6 @@ class StepExecutor:
                 print("\n  All steps completed!")
                 return
 
-            self._validate_step_allowlist(pending)
             step_num = pending["step"]
             for s in index["steps"]:
                 if s["step"] == step_num and "started_at" not in s:
@@ -522,22 +444,15 @@ class StepExecutor:
         self._write_json(self._index_file, index)
         self._update_top_index("completed")
 
-        final_paths = [f"phases/{self._phase_dir_name}/index.json"]
-        if self._top_index_file.exists():
-            final_paths.append("phases/index.json")
-        self._validate_before_commit(f"chore({self._phase_name}): mark phase completed")
-        self._stage_paths(final_paths)
+        self._run_git("add", "-A")
         if self._run_git("diff", "--cached", "--quiet").returncode != 0:
             msg = f"chore({self._phase_name}): mark phase completed"
             r = self._run_git("commit", "-m", msg)
-            if r.returncode != 0:
-                print(f"  ERROR: phase completion commit failed: {r.stderr.strip()}")
-                sys.exit(1)
-            else:
+            if r.returncode == 0:
                 print(f"  ✓ {msg}")
 
         if self._auto_push:
-            branch = self._branch_name()
+            branch = f"feat-{self._phase_name}"
             r = self._run_git("push", "-u", "origin", branch)
             if r.returncode != 0:
                 print(f"\n  ERROR: git push 실패: {r.stderr.strip()}")
@@ -555,7 +470,11 @@ def main():
     parser.add_argument("--push", action="store_true", help="Push branch after completion")
     args = parser.parse_args()
 
-    StepExecutor(args.phase_dir, auto_push=args.push).run()
+    try:
+        StepExecutor(args.phase_dir, auto_push=args.push).run()
+    except CodexEnvironmentError as exc:
+        print(f"ERROR: {exc}")
+        sys.exit(1)
 
 
 if __name__ == "__main__":