aiwcli 0.9.7 → 0.10.0

package/dist/templates/_shared/lib/templates/persona_questions.py

@@ -1,113 +0,0 @@
-"""Persona-based question templates for plan clarification.
-
-Uses distinct reasoning lenses to surface hidden constraints and assumptions.
-"""
-
-from dataclasses import dataclass
-from typing import List, Dict
-
-
-@dataclass
-class PersonaQuestion:
-    """A clarifying question from a specific persona lens."""
-
-    persona: str
-    display_name: str
-    question: str
-    purpose: str
-
-
-CLARIFICATION_PERSONAS: Dict[str, List[PersonaQuestion]] = {
-    "problem_validator": [
-        PersonaQuestion(
-            persona="problem_validator",
-            display_name="Questioning the Problem",
-            question="Can you describe the problem you're trying to solve without mentioning the solution?",
-            purpose="Separates problem from solution to check alignment",
-        ),
-        PersonaQuestion(
-            persona="problem_validator",
-            display_name="Challenging the Approach",
-            question="What's the simplest possible way to achieve this outcome that we haven't considered?",
-            purpose="Identifies potential over-engineering",
-        ),
-    ],
-    "assumption_validator": [
-        PersonaQuestion(
-            persona="assumption_validator",
-            display_name="Surfacing Assumptions",
-            question="What must already be true about your users, systems, or constraints for this to succeed?",
-            purpose="Surfaces foundational assumptions that could invalidate the plan",
-        ),
-        PersonaQuestion(
-            persona="assumption_validator",
-            display_name="Hidden Dependencies",
-            question="What are you assuming 'everyone knows' about this problem that might not be documented?",
-            purpose="Uncovers implicit knowledge that needs to be made explicit",
-        ),
-    ],
-    "user_advocate": [
-        PersonaQuestion(
-            persona="user_advocate",
-            display_name="Understanding Users",
-            question="Who specifically will use this, and what problem does it solve for them today?",
-            purpose="Grounds the plan in actual user needs",
-        ),
-        PersonaQuestion(
-            persona="user_advocate",
-            display_name="Impact Assessment",
-            question="If we did nothing, what would happen? Who would be affected?",
-            purpose="Establishes urgency and stakes",
-        ),
-    ],
-    "tradeoff_illuminator": [
-        PersonaQuestion(
-            persona="tradeoff_illuminator",
-            display_name="Revealing Trade-offs",
-            question="What are you willing to sacrifice (scope, time, quality, features) to make this work?",
-            purpose="Forces explicit prioritization",
-        ),
-        PersonaQuestion(
-            persona="tradeoff_illuminator",
-            display_name="Foreclosed Options",
-            question="What becomes harder or impossible to do later if we proceed this way?",
-            purpose="Surfaces opportunity costs and lock-in risks",
-        ),
-    ],
-}
-
-
-def get_all_persona_questions() -> List[PersonaQuestion]:
-    """Get all persona questions as a flat list."""
-    questions = []
-    for persona_qs in CLARIFICATION_PERSONAS.values():
-        questions.extend(persona_qs)
-    return questions
-
-
-def format_questions_for_prompt() -> str:
-    """Format persona questions for injection into Claude prompt."""
-    lines = [
-        "### Persona-Based Clarifying Questions",
-        "",
-        "Ask 5-8 questions from these perspectives using AskUserQuestion:",
-        "",
-    ]
-
-    for persona_qs in CLARIFICATION_PERSONAS.values():
-        for q in persona_qs:
-            lines.append(f"**{q.display_name}**")
-            lines.append(f'- Q: "{q.question}"')
-            lines.append(f"- Purpose: {q.purpose}")
-            lines.append("")
-
-    lines.extend(
-        [
-            "**Guidance:**",
-            "- Select questions most relevant to THIS plan (skip if already answered)",
-            "- Ask one at a time with clear context",
-            "- Use answers to refine the plan before ExitPlanMode",
-        ]
-    )
-
-    return "\n".join(lines)

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

@@ -1,68 +0,0 @@
-"""Async background archival to avoid blocking user workflow."""
-import threading
-import json
-from pathlib import Path
-from typing import Dict, Any, Callable, Optional
-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
-
-def archive_plan_async(
-    out_path: Path,
-    header: str,
-    plan: str,
-    callback: Optional[Callable] = None
-) -> None:
-    """
-    Archive plan in background thread. Non-blocking.
-
-    Args:
-        out_path: Destination file path
-        header: Plan header with metadata
-        plan: Plan content
-        callback: Optional callback(success: bool, error: str) on completion
-    """
-    if not ENABLE_ROBUST_PLAN_WRITES:
-        # Legacy behavior - write directly
-        try:
-            out_path.write_text(header + plan + "\n", encoding="utf-8")
-            if callback:
-                callback(True, None)
-        except Exception as e:
-            if callback:
-                callback(False, str(e))
-        return
-
-    def _archive_worker():
-        success, error = atomic_write(out_path, header + plan + "\n")
-
-        if not success:
-            # Write sanitized error marker (no stack traces)
-            error_marker = out_path.with_suffix('.error')
-            error_content = f"Archive failed: {error}\n"
-
-            try:
-                # Use atomic write for error marker too
-                atomic_write(
-                    error_marker,
-                    error_content,
-                    max_attempts=1  # Don't retry error marker
-                )
-            except Exception:
-                pass  # Error marker is best-effort
-
-        if callback:
-            try:
-                callback(success, error)
-            except Exception as e:
-                # Log callback failures (daemon thread would otherwise swallow)
-                import sys
-                print(f"[async_archive] Callback failed: {e}", file=sys.stderr)
-
-    # Start background thread
-    thread = threading.Thread(target=_archive_worker, daemon=False)
-    thread.start()

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

@@ -1,98 +0,0 @@
-"""Cross-platform atomic file writes with security."""
-import os
-import sys
-import tempfile
-from pathlib import Path
-from typing import Optional
-
-if sys.platform == 'win32':
-    import ctypes
-    from ctypes import wintypes
-
-    # Windows MoveFileEx flags
-    MOVEFILE_REPLACE_EXISTING = 0x1
-    MOVEFILE_WRITE_THROUGH = 0x8
-
-    def _atomic_replace_windows(src: Path, dst: Path) -> None:
-        """Atomic file replacement on Windows using MoveFileEx."""
-        kernel32 = ctypes.windll.kernel32
-
-        # Set proper function prototypes for 64-bit safety
-        kernel32.MoveFileExW.argtypes = [wintypes.LPCWSTR, wintypes.LPCWSTR, wintypes.DWORD]
-        kernel32.MoveFileExW.restype = wintypes.BOOL
-
-        result = kernel32.MoveFileExW(
-            str(src),
-            str(dst),
-            MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH
-        )
-        if not result:
-            error_code = kernel32.GetLastError()
-            # Use ctypes.WinError for human-readable error messages
-            raise ctypes.WinError(error_code)
-
-def atomic_write(
-    path: Path,
-    content: str,
-    max_attempts: int = 2,
-    backoff_ms: list = None
-) -> tuple:
-    """
-    Write file atomically with retry logic.
-
-    Returns:
-        (success: bool, error_message: Optional[str])
-    """
-    import time
-
-    if backoff_ms is None:
-        backoff_ms = [500, 1000]
-
-    for attempt in range(max_attempts):
-        try:
-            # Create temp file in same directory for atomic rename
-            temp_fd, temp_path_str = tempfile.mkstemp(
-                dir=path.parent,
-                prefix=f".{path.stem}_",
-                suffix=".tmp"
-            )
-            temp_path = Path(temp_path_str)
-
-            try:
-                # Write content to temp file
-                with os.fdopen(temp_fd, 'w', encoding='utf-8') as f:
-                    f.write(content)
-                    f.flush()
-                    os.fsync(f.fileno())  # Force write to disk
-
-                # Set restrictive permissions before rename (chmod 600)
-                os.chmod(temp_path, 0o600)
-
-                # Platform-specific atomic rename
-                if sys.platform == 'win32':
-                    _atomic_replace_windows(temp_path, path)
-                else:
-                    temp_path.replace(path)  # POSIX atomic
-
-                return (True, None)
-
-            except Exception as e:
-                # Clean up temp file on failure
-                try:
-                    temp_path.unlink()
-                except Exception:
-                    pass  # Cleanup is best-effort
-                raise
-
-        except Exception as e:
-            if attempt < max_attempts - 1:
-                # Bounds-safe backoff indexing
-                wait_ms = backoff_ms[min(attempt, len(backoff_ms) - 1)]
-                time.sleep(wait_ms / 1000.0)
-            else:
-                # Sanitize error message (no paths, no stack trace)
-                error_type = type(e).__name__
-                error_msg = str(e).split('\n')[0][:200]  # First line only, max 200 chars
-                return (False, f"{error_type}: {error_msg}")
-
-    return (False, "Max retry attempts exceeded")