aiwcli 0.9.8 → 0.10.0

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

@@ -22,13 +22,25 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
 try:
-    from .atomic_write import atomic_write
     from .constants import ENABLE_ROBUST_PLAN_WRITES
 except ImportError:
     # When imported directly via sys.path (not as a package)
-    from atomic_write import atomic_write
     from constants import ENABLE_ROBUST_PLAN_WRITES
 
+# Import atomic_write from shared lib (canonical copy)
+try:
+    from ...lib.base.atomic_write import atomic_write
+except ImportError:
+    # Fallback for direct execution
+    _shared_lib = Path(__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 utilities from shared lib (with Windows bug fixes)
 try:
     from ...lib.base.utils import (
@@ -38,6 +50,7 @@ try:
         sanitize_filename,
         sanitize_title,
     )
+    from ...lib.base.logger import log_debug, log_info, log_warn, log_error
 except ImportError:
     # Fallback for direct execution
     import sys
@@ -51,6 +64,7 @@ except ImportError:
         sanitize_filename,
         sanitize_title,
     )
+    from base.logger import log_debug, log_info, log_warn, log_error
 
 
 # ---------------------------
@@ -138,25 +152,40 @@ def is_plan_already_reviewed(session_id: str, plan_hash: str) -> bool:
         return False
 
 
+def was_plan_previously_denied(session_id: str, plan_hash: str) -> bool:
+    """Check if this plan hash was previously reviewed and denied."""
+    marker_path = get_review_marker_path(session_id)
+    if not marker_path.exists():
+        return False
+    try:
+        data = json.loads(marker_path.read_text(encoding="utf-8"))
+        return data.get("plan_hash") == plan_hash and data.get("decision") == "deny"
+    except Exception:
+        return False
+
+
 def mark_plan_reviewed(
     session_id: str,
     plan_hash: str,
     hook_name: str = "cc-native",
     iteration_state: Optional[Dict[str, Any]] = None,
+    decision: str = "allow",
 ) -> None:
-    """Mark this plan as reviewed (stores hash in marker file).
+    """Mark this plan as reviewed (stores hash and decision in marker file).
 
     Args:
         session_id: The session identifier
         plan_hash: Hash of the plan content
         hook_name: Name of the hook (for logging)
         iteration_state: Optional iteration state dict with current, max, verdict info
+        decision: Review decision - "allow" or "deny"
     """
     marker = get_review_marker_path(session_id)
     try:
         data: Dict[str, Any] = {
             "plan_hash": plan_hash,
             "reviewed_at": datetime.now().isoformat(),
+            "decision": decision,
         }
 
         # Include iteration info if provided
@@ -173,45 +202,43 @@ def mark_plan_reviewed(
 
         marker.write_text(json.dumps(data), encoding="utf-8")
         iter_info = f" (iteration {data.get('iteration', {}).get('current', '?')}/{data.get('iteration', {}).get('max', '?')})" if iteration_state else ""
-        eprint(f"[{hook_name}] Created review marker: {marker} (hash: {plan_hash}){iter_info}")
+        log_info(hook_name, f"Created review marker: {marker} (hash: {plan_hash}){iter_info}")
     except Exception as e:
-        eprint(f"[{hook_name}] Warning: failed to create review marker: {e}")
+        log_warn(hook_name, f"Failed to create review marker: {e}")
 
 
 # ---------------------------
-# Questions offered state
+# Questions asked state
 # ---------------------------
 
-def get_questions_marker_path(session_id: str) -> Path:
-    """Get path to questions-offered marker file for this session."""
+def get_questions_asked_marker_path(session_id: str) -> Path:
+    """Get path to questions-asked marker file for this session."""
     safe_id = re.sub(r'[^a-zA-Z0-9_-]', '_', session_id)[:32]
-    return Path(tempfile.gettempdir()) / f"cc-native-questions-offered-{safe_id}.json"
+    return Path(tempfile.gettempdir()) / f"cc-native-questions-asked-{safe_id}.json"
 
 
-def was_questions_offered(session_id: str) -> bool:
-    """Check if clarifying questions were already offered this session.
+def was_questions_asked(session_id: str) -> bool:
+    """Check if AskUserQuestion was called this session.
 
     Returns False on any error (fail-safe: allow feature to work).
     """
     try:
-        marker = get_questions_marker_path(session_id)
-        return marker.exists()
+        return get_questions_asked_marker_path(session_id).exists()
     except Exception:
         return False
 
 
-def mark_questions_offered(session_id: str) -> bool:
-    """Mark that questions were offered. Returns True on success.
+def mark_questions_asked(session_id: str) -> bool:
+    """Mark that AskUserQuestion was called. Returns True on success.
 
     Only stores timestamp, no user data. Returns False on error.
     """
     try:
-        marker = get_questions_marker_path(session_id)
-        data = {"offered_at": datetime.now().isoformat()}
-        marker.write_text(json.dumps(data), encoding="utf-8")
+        marker = get_questions_asked_marker_path(session_id)
+        marker.write_text(json.dumps({"asked_at": datetime.now().isoformat()}), encoding="utf-8")
         return True
     except Exception as e:
-        eprint(f"[utils] Failed to write questions marker: {e}")
+        log_warn("utils", f"Failed to write questions-asked marker: {e}")
         return False
 
 
@@ -257,17 +284,17 @@ def parse_json_maybe(text: str, require_fields: Optional[List[str]] = None) -> O
                 if isinstance(parsed, dict):
                     obj = parsed
                     parse_method = "heuristic"
-                    eprint(f"[parse] Used heuristic extraction (chars {start}-{end})")
+                    log_debug("parse", f"Used heuristic extraction (chars {start}-{end})")
             except Exception:
-                eprint(f"[parse] Heuristic extraction failed for candidate at chars {start}-{end}")
+                log_debug("parse", f"Heuristic extraction failed for candidate at chars {start}-{end}")
                 return None
 
     # If we parsed something, validate required fields
     if obj and require_fields:
         missing = [f for f in require_fields if f not in obj or not obj[f]]
         if missing:
-            eprint(f"[parse] WARNING: parsed JSON ({parse_method}) missing/empty fields: {missing}")
-            eprint(f"[parse] Keys present: {list(obj.keys())}")
+            log_warn("parse", f"Parsed JSON ({parse_method}) missing/empty fields: {missing}")
+            log_debug("parse", f"Keys present: {list(obj.keys())}")
 
     return obj
 
@@ -281,7 +308,7 @@ def coerce_to_review(obj: Optional[Dict[str, Any]], default_fix_msg: str = "Retr
         'default' if it was defaulted due to missing/empty summary.
     """
     if not obj:
-        eprint("[coerce] WARNING: No object provided to coerce_to_review")
+        log_warn("coerce", "No object provided to coerce_to_review")
         return False, "error", {
             "verdict": "fail",
             "summary": "No structured output returned.",
@@ -293,19 +320,19 @@ def coerce_to_review(obj: Optional[Dict[str, Any]], default_fix_msg: str = "Retr
 
     verdict = obj.get("verdict")
     if verdict not in ("pass", "warn", "fail"):
-        eprint(f"[coerce] WARNING: Invalid or missing verdict '{verdict}', defaulting to 'warn'")
+        log_warn("coerce", f"Invalid or missing verdict '{verdict}', defaulting to 'warn'")
         verdict = "warn"
 
     # Log when fields are being defaulted
     summary_raw = str(obj.get("summary", "")).strip()
     if not summary_raw:
-        eprint("[coerce] WARNING: summary missing or empty from parsed output, using default")
+        log_warn("coerce", "summary missing or empty from parsed output, using default")
         # Add diagnostic output
-        eprint(f"[coerce] Raw object keys: {list(obj.keys()) if obj else 'None'}")
+        log_debug("coerce", f"Raw object keys: {list(obj.keys()) if obj else 'None'}")
         if obj:
-            eprint(f"[coerce] verdict={obj.get('verdict')}, issues_count={len(obj.get('issues', []))}")
+            log_debug("coerce", f"verdict={obj.get('verdict')}, issues_count={len(obj.get('issues', []))}")
     if not obj.get("issues"):
-        eprint("[coerce] INFO: issues array empty or missing")
+        log_debug("coerce", "issues array empty or missing")
 
     norm = {
         "verdict": verdict,
@@ -331,6 +358,48 @@ def worst_verdict(verdicts: List[str]) -> str:
     return worst
 
 
+def compute_review_decision(
+    all_verdicts: List[str],
+    warn_threshold: float = 0.5,
+) -> Tuple[bool, str, float]:
+    """Verdict aggregation: only fail triggers a block.
+
+    Fail Veto: Any fail -> deny. From safety engineering (ISO 61508) —
+    critical alarms use zero-tolerance.
+
+    Warns are informational only — the warn_ratio is computed for logging
+    and visibility but does NOT trigger blocking.
+
+    Error exclusion: Detectors that produce no signal (error/skip) are excluded
+    from the denominator. They provide no information about plan quality.
+
+    Args:
+        all_verdicts: List of verdict strings from all reviewers.
+        warn_threshold: Kept for backward compatibility. No longer used for blocking.
+
+    Returns:
+        Tuple of (should_deny, reason, score).
+        - should_deny: True if the plan should be denied.
+        - reason: "fail_veto", "acceptable", or "no_signal".
+        - score: 1.0 for fail_veto, warn_ratio for informational cases, 0.0 for no_signal.
+    """
+    # Exclude non-signal verdicts
+    signal_verdicts = [v for v in all_verdicts if v in ("pass", "warn", "fail")]
+
+    if not signal_verdicts:
+        return False, "no_signal", 0.0
+
+    # Only fail blocks — warns are informational
+    fail_count = signal_verdicts.count("fail")
+    if fail_count > 0:
+        return True, "fail_veto", 1.0
+
+    # Warn ratio still computed for logging/visibility, but does NOT block
+    warn_count = signal_verdicts.count("warn")
+    warn_ratio = warn_count / len(signal_verdicts)
+    return False, "acceptable", warn_ratio
+
+
 # ---------------------------
 # Artifact writing
 # ---------------------------
@@ -541,6 +610,104 @@ def format_combined_markdown(
     return "\n".join(lines).strip() + "\n"
 
 
+def build_inline_review_summary(
+    combined: CombinedReviewResult,
+    max_issues: int = 5,
+    max_chars: int = 800,
+) -> str:
+    """Build compact inline summary of HIGH-severity review findings for additionalContext.
+
+    Returns an overall verdict line plus up to 5 high-severity issues as bullet points.
+    Per-reviewer verdicts, missing sections, and key questions are omitted from inline
+    output (they remain in the full review artifact on disk).
+
+    Args:
+        combined: The combined review result from all reviewers.
+        max_issues: Maximum number of high-severity issues to include.
+        max_chars: Character budget for the summary (truncated if exceeded).
+
+    Returns:
+        Compact summary string, or empty string if no high-severity findings.
+    """
+    # Collect HIGH severity issues across all reviewers
+    all_reviewers: List[ReviewerResult] = []
+    all_reviewers.extend(combined.cli_reviewers.values())
+    all_reviewers.extend(combined.agents.values())
+
+    high_issues: List[Dict[str, Any]] = []
+    for r in all_reviewers:
+        if not r.data:
+            continue
+        for issue in r.data.get("issues", []):
+            if issue.get("severity") == "high":
+                high_issues.append({**issue, "_reviewer": r.name})
+
+    parts: List[str] = []
+
+    # Overall verdict line
+    parts.append(f"**Plan Review: {combined.overall_verdict.upper()}**"
+                 + (f" ({len(high_issues)} high-severity issue{'s' if len(high_issues) != 1 else ''})"
+                    if high_issues else ""))
+
+    # High-severity issue bullets (max 5)
+    for issue in high_issues[:max_issues]:
+        cat = issue.get("category", "general")
+        text = issue.get("issue", "")
+        fix = issue.get("suggested_fix", "")
+        reviewer = issue.get("_reviewer", "unknown")
+        line = f"- [{cat}] {text}"
+        if fix:
+            line += f" \u2192 {fix}"
+        line += f" ({reviewer})"
+        parts.append(line)
+    remaining = len(high_issues) - max_issues
+    if remaining > 0:
+        parts.append(f"  ...and {remaining} more")
+
+    result = "\n".join(parts)
+    if len(result) > max_chars:
+        result = result[:max_chars - 3] + "..."
+    return result
+
+
+def extract_top_issues_text(
+    combined: CombinedReviewResult,
+    max_count: int = 3,
+    severity: str = "high",
+) -> str:
+    """Extract top issues as a compact text string for permissionDecisionReason.
+
+    Args:
+        combined: The combined review result.
+        max_count: Maximum number of issues to include.
+        severity: Severity level to filter for.
+
+    Returns:
+        Compact semicolon-separated issue text.
+    """
+    all_reviewers: List[ReviewerResult] = []
+    all_reviewers.extend(combined.cli_reviewers.values())
+    all_reviewers.extend(combined.agents.values())
+
+    issues: List[str] = []
+    for r in all_reviewers:
+        if not r.data:
+            continue
+        for issue in r.data.get("issues", []):
+            if issue.get("severity") == severity:
+                text = issue.get("issue", "").strip()
+                if text:
+                    issues.append(text)
+            if len(issues) >= max_count:
+                break
+        if len(issues) >= max_count:
+            break
+
+    if not issues:
+        return "Review found critical issues"
+    return "; ".join(issues)
+
+
 def _append_review_details(
     lines: List[str],
     data: Dict[str, Any],
@@ -748,13 +915,13 @@ def write_combined_artifacts(
     if not out_dir:
         raise ValueError("Either context_reviews_dir or review_folder is required")
 
-    eprint(f"[utils] Using review folder: {out_dir}")
+    log_debug("utils", f"Using review folder: {out_dir}")
 
     # Check directory creation explicitly
     try:
         out_dir.mkdir(parents=True, exist_ok=True)
     except PermissionError as e:
-        eprint(f"[utils] FATAL: Cannot create directory {out_dir}: {e}")
+        log_error("utils", f"Cannot create directory {out_dir}: {e}")
         raise
 
     # JSON write with atomic operation - use combined.json for folder-based
@@ -769,7 +936,7 @@ def write_combined_artifacts(
         else:
             json_path.write_text(json.dumps(json_data, indent=2, ensure_ascii=False), encoding="utf-8")
     except Exception as e:
-        eprint(f"[utils] FATAL: Failed to write {json_path.name}: {e}")
+        log_error("utils", f"Failed to write {json_path.name}: {e}")
         raise
 
     # Markdown write with atomic operation - use combined.md for folder-based
@@ -784,7 +951,7 @@ def write_combined_artifacts(
         else:
             md_path.write_text(md_content, encoding="utf-8")
     except Exception as e:
-        eprint(f"[utils] FATAL: Failed to write {md_path.name}: {e}")
+        log_error("utils", f"Failed to write {md_path.name}: {e}")
         raise
 
     # Individual reviewer writes (non-critical - continue on failure)
@@ -796,11 +963,11 @@ def write_combined_artifacts(
                 if ENABLE_ROBUST_PLAN_WRITES:
                     success, error = atomic_write(reviewer_path, content)
                     if not success:
-                        eprint(f"[utils] WARNING: Failed to write {reviewer_path.name}: {error}")
+                        log_warn("utils", f"Failed to write {reviewer_path.name}: {error}")
                 else:
                     reviewer_path.write_text(content, encoding="utf-8")
             except Exception as e:
-                eprint(f"[utils] WARNING: Failed to write {reviewer_path.name}: {e}")
+                log_warn("utils", f"Failed to write {reviewer_path.name}: {e}")
                 # Continue - individual reviewer failures not critical
     for name, r in result.agents.items():
         if r.data:
@@ -810,11 +977,11 @@ def write_combined_artifacts(
                 if ENABLE_ROBUST_PLAN_WRITES:
                     success, error = atomic_write(reviewer_path, content)
                     if not success:
-                        eprint(f"[utils] WARNING: Failed to write {reviewer_path.name}: {error}")
+                        log_warn("utils", f"Failed to write {reviewer_path.name}: {error}")
                 else:
                     reviewer_path.write_text(content, encoding="utf-8")
             except Exception as e:
-                eprint(f"[utils] WARNING: Failed to write {reviewer_path.name}: {e}")
+                log_warn("utils", f"Failed to write {reviewer_path.name}: {e}")
                 # Continue - individual reviewer failures not critical
 
     # Generate index.md for folder-based reviews
@@ -825,11 +992,11 @@ def write_combined_artifacts(
             if ENABLE_ROBUST_PLAN_WRITES:
                 success, error = atomic_write(index_path, index_content)
                 if not success:
-                    eprint(f"[utils] WARNING: Failed to write index.md: {error}")
+                    log_warn("utils", f"Failed to write index.md: {error}")
             else:
                 index_path.write_text(index_content, encoding="utf-8")
         except Exception as e:
-            eprint(f"[utils] WARNING: Failed to write index.md: {e}")
+            log_warn("utils", f"Failed to write index.md: {e}")
 
         return index_path
 
@@ -849,7 +1016,7 @@ def load_config(project_dir: Path) -> Dict[str, Any]:
         with open(settings_path, "r", encoding="utf-8") as f:
             return json.load(f)
     except Exception as e:
-        eprint(f"[cc-native] Failed to load config: {e}")
+        log_warn("cc-native", f"Failed to load config: {e}")
         return {}
 
 

package/dist/templates/cc-native/_cc-native/plan-review.config.json

@@ -13,7 +13,6 @@
         "timeout": 120
       }
     },
-    "blockOnFail": false,
     "display": {
       "maxIssues": 12,
       "maxMissingSections": 12,
@@ -23,7 +22,7 @@
   "agentReview": {
     "enabled": true,
     "timeout": 180,
-    "blockOnFail": true,
+    "warnThreshold": 0.01,
     "orchestrator": {
       "enabled": true,
       "model": "haiku",

package/oclif.manifest.json

@@ -401,5 +401,5 @@
       ]
     }
   },
-  "version": "0.9.8"
+  "version": "0.10.0"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aiwcli",
   "description": "AI Workflow CLI - Command-line interface for AI-powered workflows",
-  "version": "0.9.8",
+  "version": "0.10.0",
   "author": "jofu-tofu",
   "bin": {
     "aiw": "./bin/run.js"