aiwcli 0.9.8 → 0.10.1

package/dist/templates/cc-native/_cc-native/lib/reviewers/agent.py

@@ -15,10 +15,15 @@ from typing import Any, Dict, Optional
 _lib_dir = Path(__file__).resolve().parent.parent
 sys.path.insert(0, str(_lib_dir))
 
-from utils import ReviewerResult, eprint, parse_json_maybe, coerce_to_review
+from utils import ReviewerResult, parse_json_maybe, coerce_to_review
 from debug import debug_log, debug_raw
 from .base import AgentConfig, AGENT_REVIEW_PROMPT_PREFIX
 
+# Import logger
+_shared_logger = Path(__file__).resolve().parent.parent.parent.parent / "_shared" / "lib"
+sys.path.insert(0, str(_shared_logger))
+from base.logger import log_debug, log_info, log_warn, log_error
+
 # Import shared subprocess utilities
 _shared_lib = Path(__file__).resolve().parent.parent.parent.parent / "_shared" / "lib" / "base"
 sys.path.insert(0, str(_shared_lib))
@@ -43,18 +48,18 @@ def _parse_claude_output(raw: str) -> Optional[Dict[str, Any]]:
         result = json.loads(raw)
         if isinstance(result, dict):
             if "structured_output" in result:
-                eprint("[parse] Found structured_output in root dict")
+                log_debug("agent", "Found structured_output in root dict", component="parse")
                 return result["structured_output"]
             if result.get("type") == "assistant":
                 message = result.get("message", {})
                 content = message.get("content", [])
                 for item in content:
                     if isinstance(item, dict) and item.get("name") == "StructuredOutput":
-                        eprint("[parse] Found StructuredOutput in assistant message content")
+                        log_debug("agent", "Found StructuredOutput in assistant message content", component="parse")
                         return item.get("input", {})
-                eprint("[parse] Assistant message found but no StructuredOutput tool use in content")
+                log_debug("agent", "Assistant message found but no StructuredOutput tool use in content", component="parse")
         elif isinstance(result, list):
-            eprint(f"[parse] Received list of {len(result)} events, searching for assistant message")
+            log_debug("agent", f"Received list of {len(result)} events, searching for assistant message", component="parse")
             for i, event in enumerate(result):
                 if not isinstance(event, dict):
                     continue
@@ -63,16 +68,16 @@ def _parse_claude_output(raw: str) -> Optional[Dict[str, Any]]:
                     content = message.get("content", [])
                     for item in content:
                         if isinstance(item, dict) and item.get("name") == "StructuredOutput":
-                            eprint(f"[parse] Found StructuredOutput in event[{i}] assistant message")
+                            log_debug("agent", f"Found StructuredOutput in event[{i}] assistant message", component="parse")
                             return item.get("input", {})
-            eprint("[parse] No StructuredOutput found in any assistant message in event list")
+            log_debug("agent", "No StructuredOutput found in any assistant message in event list", component="parse")
     except json.JSONDecodeError as e:
-        eprint(f"[parse] JSON decode error: {e}")
+        log_warn("agent", f"JSON decode error: {e}", component="parse")
     except Exception as e:
-        eprint(f"[parse] Unexpected error during structured parsing: {e}")
+        log_error("agent", f"Unexpected error during structured parsing: {e}", component="parse")
 
     # Fallback to heuristic extraction with required field validation
-    eprint("[parse] No structured output found, falling back to heuristic JSON extraction")
+    log_debug("agent", "No structured output found, falling back to heuristic JSON extraction", component="parse")
     return parse_json_maybe(raw, require_fields=["verdict", "summary"])
 
 
@@ -99,7 +104,7 @@ def run_agent_review(
     """
     claude_path = shutil.which("claude")
     if claude_path is None:
-        eprint(f"[{agent.name}] Claude CLI not found on PATH")
+        log_warn(agent.name, "Claude CLI not found on PATH")
         return ReviewerResult(
             name=agent.name,
             ok=False,
@@ -109,7 +114,7 @@ def run_agent_review(
             err="claude CLI not found on PATH",
         )
 
-    eprint(f"[{agent.name}] Found Claude CLI at: {claude_path}")
+    log_debug(agent.name, f"Found Claude CLI at: {claude_path}")
 
     # User prompt - direct instruction to call StructuredOutput immediately
     prompt = f"""IMMEDIATELY call StructuredOutput with your review of the plan below.
@@ -139,7 +144,7 @@ PLAN:
         full_prompt = AGENT_REVIEW_PROMPT_PREFIX + "\n\n---\n\n" + agent.system_prompt
         cmd_args.extend(["--system-prompt", full_prompt])
 
-    eprint(f"[{agent.name}] Running with model: {agent.model}, timeout: {timeout}s")
+    log_info(agent.name, f"Running with model: {agent.model}, timeout: {timeout}s")
 
     # Get environment for internal subprocess (bypasses hooks)
     env = get_internal_subprocess_env()
@@ -156,16 +161,16 @@ PLAN:
             env=env,
         )
     except subprocess.TimeoutExpired:
-        eprint(f"[{agent.name}] TIMEOUT after {timeout}s")
+        log_warn(agent.name, f"TIMEOUT after {timeout}s")
         return ReviewerResult(agent.name, False, "error", {}, "", f"{agent.name} timed out after {timeout}s")
     except Exception as ex:
-        eprint(f"[{agent.name}] EXCEPTION: {ex}")
+        log_error(agent.name, f"Exception: {ex}")
         return ReviewerResult(agent.name, False, "error", {}, "", f"{agent.name} failed to run: {ex}")
 
-    eprint(f"[{agent.name}] Exit code: {p.returncode}")
-    eprint(f"[{agent.name}] stdout length: {len(p.stdout or '')} chars")
+    log_debug(agent.name, f"Exit code: {p.returncode}")
+    log_debug(agent.name, f"stdout length: {len(p.stdout or '')} chars")
     if p.stderr:
-        eprint(f"[{agent.name}] stderr: {p.stderr[:500]}")
+        log_debug(agent.name, f"stderr: {p.stderr[:500]}")
 
     raw = (p.stdout or "").strip()
     err = (p.stderr or "").strip()
@@ -184,7 +189,7 @@ PLAN:
         })
 
     if raw:
-        eprint(f"[{agent.name}] stdout preview: {raw[:500]}")
+        log_debug(agent.name, f"stdout preview: {raw[:500]}")
 
     obj = _parse_claude_output(raw)
 
@@ -201,9 +206,9 @@ PLAN:
         })
 
     if obj:
-        eprint(f"[{agent.name}] Parsed JSON successfully, verdict: {obj.get('verdict', 'N/A')}")
+        log_info(agent.name, f"Parsed JSON successfully, verdict: {obj.get('verdict', 'N/A')}")
     else:
-        eprint(f"[{agent.name}] Failed to parse JSON from output")
+        log_warn(agent.name, "Failed to parse JSON from output")
 
     ok, verdict, norm = coerce_to_review(obj, "Retry or check agent configuration.")
 

package/dist/templates/cc-native/_cc-native/lib/reviewers/codex.py

@@ -16,9 +16,14 @@ from typing import Any, Dict
 _lib_dir = Path(__file__).resolve().parent.parent
 sys.path.insert(0, str(_lib_dir))
 
-from utils import ReviewerResult, eprint, parse_json_maybe, coerce_to_review
+from utils import ReviewerResult, parse_json_maybe, coerce_to_review
 from .base import REVIEW_PROMPT_PREFIX
 
+# Import logger
+_shared_logger = Path(__file__).resolve().parent.parent.parent.parent / "_shared" / "lib"
+sys.path.insert(0, str(_shared_logger))
+from base.logger import log_debug, log_info, log_warn, log_error
+
 
 def run_codex_review(
     plan: str,
@@ -41,7 +46,7 @@ def run_codex_review(
 
     codex_path = shutil.which("codex")
     if codex_path is None:
-        eprint("[codex] CLI not found on PATH")
+        log_warn("codex", "CLI not found on PATH")
         return ReviewerResult(
             name="codex",
             ok=False,
@@ -51,7 +56,7 @@ def run_codex_review(
             err="codex CLI not found on PATH",
         )
 
-    eprint(f"[codex] Found CLI at: {codex_path}")
+    log_debug("codex", f"Found CLI at: {codex_path}")
 
     prompt = f"""{REVIEW_PROMPT_PREFIX}
 Return ONLY a JSON object that matches this JSON Schema:
@@ -87,7 +92,7 @@ PLAN:
             cmd.insert(2, "--model")
             cmd.insert(3, model)
 
-        eprint(f"[codex] Running command: {' '.join(cmd)}")
+        log_debug("codex", f"Running command: {' '.join(cmd)}")
 
         try:
             p = subprocess.run(
@@ -100,13 +105,13 @@ PLAN:
                 errors='replace',
             )
         except subprocess.TimeoutExpired:
-            eprint(f"[codex] TIMEOUT after {timeout}s")
+            log_warn("codex", f"TIMEOUT after {timeout}s")
             return ReviewerResult("codex", False, "error", {}, "", f"codex timed out after {timeout}s")
         except Exception as ex:
-            eprint(f"[codex] EXCEPTION: {ex}")
+            log_error("codex", f"Exception: {ex}")
             return ReviewerResult("codex", False, "error", {}, "", f"codex failed to run: {ex}")
 
-        eprint(f"[codex] Exit code: {p.returncode}")
+        log_debug("codex", f"Exit code: {p.returncode}")
 
         raw = ""
         if out_path.exists():

package/dist/templates/cc-native/_cc-native/lib/reviewers/gemini.py

@@ -15,7 +15,12 @@ from typing import Any, Dict
 _lib_dir = Path(__file__).resolve().parent.parent
 sys.path.insert(0, str(_lib_dir))
 
-from utils import ReviewerResult, eprint, parse_json_maybe, coerce_to_review
+from utils import ReviewerResult, parse_json_maybe, coerce_to_review
+
+# Import logger
+_shared_logger = Path(__file__).resolve().parent.parent.parent.parent / "_shared" / "lib"
+sys.path.insert(0, str(_shared_logger))
+from base.logger import log_debug, log_info, log_warn, log_error
 
 
 def run_gemini_review(
@@ -39,7 +44,7 @@ def run_gemini_review(
 
     gemini_path = shutil.which("gemini")
     if gemini_path is None:
-        eprint("[gemini] CLI not found on PATH")
+        log_warn("gemini", "CLI not found on PATH")
         return ReviewerResult(
             name="gemini",
             ok=False,
@@ -49,7 +54,7 @@ def run_gemini_review(
             err="gemini CLI not found on PATH",
         )
 
-    eprint(f"[gemini] Found CLI at: {gemini_path}")
+    log_debug("gemini", f"Found CLI at: {gemini_path}")
 
     instruction = f"""
 
@@ -73,7 +78,7 @@ Return ONLY a JSON object that matches this JSON Schema (no markdown, no code fe
     if model:
         cmd.extend(["--model", model])
 
-    eprint("[gemini] Running command: gemini -y -p <instruction>")
+    log_debug("gemini", "Running command: gemini -y -p <instruction>")
 
     try:
         p = subprocess.run(
@@ -86,13 +91,13 @@ Return ONLY a JSON object that matches this JSON Schema (no markdown, no code fe
             errors='replace',
         )
     except subprocess.TimeoutExpired:
-        eprint(f"[gemini] TIMEOUT after {timeout}s")
+        log_warn("gemini", f"TIMEOUT after {timeout}s")
         return ReviewerResult("gemini", False, "error", {}, "", f"gemini timed out after {timeout}s")
     except Exception as ex:
-        eprint(f"[gemini] EXCEPTION: {ex}")
+        log_error("gemini", f"Exception: {ex}")
         return ReviewerResult("gemini", False, "error", {}, "", f"gemini failed to run: {ex}")
 
-    eprint(f"[gemini] Exit code: {p.returncode}")
+    log_debug("gemini", f"Exit code: {p.returncode}")
 
     raw = (p.stdout or "").strip()
     err = (p.stderr or "").strip()

package/dist/templates/cc-native/_cc-native/lib/state.py

@@ -15,15 +15,29 @@ from typing import Any, Dict, Optional
 
 try:
     from .constants import validate_plan_path, PLANS_DIR
-    from .atomic_write import atomic_write
 except ImportError:
     # When imported directly via sys.path (not as a package)
     from constants import validate_plan_path, PLANS_DIR
-    from atomic_write import atomic_write
 
-# Import canonical eprint from shared lib
+# Import atomic_write from shared lib (canonical copy)
+try:
+    from ...lib.base.atomic_write import atomic_write
+except ImportError:
+    # Fallback for direct execution
+    from pathlib import Path as _P
+    _shared_lib = _P(__file__).resolve().parent.parent.parent / "_shared" / "lib"
+    import importlib.util
+    _spec = importlib.util.spec_from_file_location(
+        "atomic_write", str(_shared_lib / "base" / "atomic_write.py")
+    )
+    _mod = importlib.util.module_from_spec(_spec)
+    _spec.loader.exec_module(_mod)
+    atomic_write = _mod.atomic_write
+
+# Import canonical eprint and logger from shared lib
 try:
     from ...lib.base.utils import eprint
+    from ...lib.base.logger import log_debug, log_info, log_warn, log_error
 except ImportError:
     # Fallback for direct execution
     import sys as _sys
@@ -31,6 +45,7 @@ except ImportError:
     _shared_lib = _Path(__file__).resolve().parent.parent.parent / "_shared" / "lib"
     _sys.path.insert(0, str(_shared_lib))
     from base.utils import eprint
+    from base.logger import log_debug, log_info, log_warn, log_error
 
 
 # ---------------------------
@@ -84,18 +99,18 @@ def load_state(plan_path: str) -> Optional[Dict[str, Any]]:
         if schema_version is None:
             # Existing state files without version - auto-migrate
             state["schema_version"] = STATE_SCHEMA_VERSION
-            eprint(f"[state] Migrated state file to schema v{STATE_SCHEMA_VERSION}")
+            log_info("state", f"Migrated state file to schema v{STATE_SCHEMA_VERSION}")
         elif schema_version != STATE_SCHEMA_VERSION:
-            eprint(f"[state] WARNING: Schema mismatch (expected {STATE_SCHEMA_VERSION}, got {schema_version})")
+            log_warn("state", f"Schema mismatch (expected {STATE_SCHEMA_VERSION}, got {schema_version})")
             # For now, accept with warning - add migration logic here if schema changes
 
         return state
 
     except ValueError as e:
-        eprint(f"[state] SECURITY: Invalid plan path: {e}")
+        log_error("state", f"SECURITY: Invalid plan path: {e}")
         return None
     except Exception as e:
-        eprint(f"[state] ERROR: Failed to load state: {e}")
+        log_error("state", f"Failed to load state: {e}")
         return None
 
 
@@ -119,16 +134,16 @@ def save_state(plan_path: str, state: Dict[str, Any]) -> bool:
         )
 
         if not success:
-            eprint(f"[state] Failed to save state: {error}")
+            log_error("state", f"Failed to save state: {error}")
             return False
 
         return True
 
     except ValueError as e:
-        eprint(f"[state] SECURITY: Invalid plan path: {e}")
+        log_error("state", f"SECURITY: Invalid plan path: {e}")
         return False
     except Exception as e:
-        eprint(f"[state] ERROR: {e}")
+        log_error("state", str(e))
         return False
 
 
@@ -141,13 +156,13 @@ def delete_state(plan_path: str) -> bool:
         state_file = get_state_file_path(plan_path)
         if state_file.exists():
             state_file.unlink()
-            eprint(f"[state] Deleted state file: {state_file}")
+            log_info("state", f"Deleted state file: {state_file}")
         return True
     except ValueError as e:
-        eprint(f"[state] SECURITY: Invalid plan path in delete: {e}")
+        log_error("state", f"SECURITY: Invalid plan path in delete: {e}")
         return False
     except Exception as e:
-        eprint(f"[state] Warning: failed to delete state file: {e}")
+        log_warn("state", f"Failed to delete state file: {e}")
         return False
 
 
@@ -237,7 +252,7 @@ def should_continue_iterating(
 
     # At or past max iterations - no more iterations
     if current >= max_iter:
-        eprint(f"[state] At max iterations ({current}/{max_iter}), no more iterations")
+        log_info("state", f"At max iterations ({current}/{max_iter}), no more iterations")
         return False
 
     # Check early exit on all pass
@@ -245,9 +260,9 @@ def should_continue_iterating(
     if config:
         early_exit = config.get("earlyExitOnAllPass", True)
     if early_exit and verdict == "pass":
-        eprint(f"[state] All reviewers passed and earlyExitOnAllPass=true, exiting early")
+        log_info("state", "All reviewers passed and earlyExitOnAllPass=true, exiting early")
         return False
 
     # More iterations available and verdict is not pass (or early exit disabled)
-    eprint(f"[state] Continuing to next iteration ({current + 1}/{max_iter}), verdict={verdict}")
+    log_info("state", f"Continuing to next iteration ({current + 1}/{max_iter}), verdict={verdict}")
     return True