icdev 0.0.3__py3-none-any.whl

tools/testing/utils.py

@@ -0,0 +1,229 @@
+# [TEMPLATE: CUI // SP-CTI]
+# SPARKPILOT Testing Utilities
+# Adapted from ADW utils.py for Gov/DoD testing workflows
+
+"""Utility functions for SPARKPILOT testing framework.
+
+Provides JSON parsing (handles markdown wrapping), logger setup,
+safe subprocess environments, and run ID generation.
+"""
+
+import json
+import logging
+import os
+import re
+import sys
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, TypeVar, Type, Union, Dict
+
+T = TypeVar('T')
+
+# Project root — tools/testing/utils.py → go up 2 levels
+PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
+
+
+def make_run_id() -> str:
+    """Generate a short 8-character UUID for test run tracking."""
+    return str(uuid.uuid4())[:8]
+
+
+def setup_logger(run_id: str, phase: str = "test_run") -> logging.Logger:
+    """Set up logger that writes to both console and file.
+
+    Adapted from ADW setup_logger pattern with dual-output (file + console).
+
+    Args:
+        run_id: The test run ID
+        phase: Phase name (test_run, health_check, e2e_test, etc.)
+
+    Returns:
+        Configured logger instance
+    """
+    # Create log directory: .tmp/test_runs/{run_id}/{phase}/
+    log_dir = PROJECT_ROOT / ".tmp" / "test_runs" / run_id / phase
+    log_dir.mkdir(parents=True, exist_ok=True)
+
+    log_file = log_dir / "execution.log"
+
+    # Create logger with unique name
+    logger = logging.getLogger(f"icdev_{run_id}_{phase}")
+    logger.setLevel(logging.DEBUG)
+
+    # Clear any existing handlers to avoid duplicates
+    logger.handlers.clear()
+
+    # File handler - captures everything
+    file_handler = logging.FileHandler(str(log_file), mode='a')
+    file_handler.setLevel(logging.DEBUG)
+
+    # Console handler - INFO and above
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(logging.INFO)
+
+    # Format with timestamp for file
+    file_formatter = logging.Formatter(
+        '%(asctime)s - %(levelname)s - %(message)s',
+        datefmt='%Y-%m-%d %H:%M:%S'
+    )
+
+    # Simpler format for console
+    console_formatter = logging.Formatter('%(message)s')
+
+    file_handler.setFormatter(file_formatter)
+    console_handler.setFormatter(console_formatter)
+
+    logger.addHandler(file_handler)
+    logger.addHandler(console_handler)
+
+    logger.info(f"SPARKPILOT Test Logger initialized - Run: {run_id}, Phase: {phase}")
+    logger.debug(f"Log file: {log_file}")
+
+    return logger
+
+
+def get_logger(run_id: str, phase: str = "test_run") -> logging.Logger:
+    """Get existing logger by run ID and phase."""
+    return logging.getLogger(f"icdev_{run_id}_{phase}")
+
+
+def parse_json(text: str, target_type: Type[T] = None) -> Union[T, Any]:
+    """Parse JSON that may be wrapped in markdown code blocks.
+
+    Directly adapted from ADW parse_json — handles:
+    - Raw JSON
+    - JSON wrapped in ```json ... ```
+    - JSON wrapped in ``` ... ```
+    - JSON with extra whitespace or newlines
+
+    Args:
+        text: String containing JSON, possibly wrapped in markdown
+        target_type: Optional Pydantic model or List[Model] to validate into
+
+    Returns:
+        Parsed JSON object, optionally validated as target_type
+
+    Raises:
+        ValueError: If JSON cannot be parsed from the text
+    """
+    # Try to extract JSON from markdown code blocks
+    code_block_pattern = r'```(?:json)?\s*\n(.*?)\n```'
+    match = re.search(code_block_pattern, text, re.DOTALL)
+
+    if match:
+        json_str = match.group(1).strip()
+    else:
+        json_str = text.strip()
+
+    # Try to find JSON array or object boundaries if not already clean
+    if not (json_str.startswith('[') or json_str.startswith('{')):
+        # Look for JSON array
+        array_start = json_str.find('[')
+        array_end = json_str.rfind(']')
+
+        # Look for JSON object
+        obj_start = json_str.find('{')
+        obj_end = json_str.rfind('}')
+
+        # Determine which comes first and extract accordingly
+        if array_start != -1 and (obj_start == -1 or array_start < obj_start):
+            if array_end != -1:
+                json_str = json_str[array_start:array_end + 1]
+        elif obj_start != -1:
+            if obj_end != -1:
+                json_str = json_str[obj_start:obj_end + 1]
+
+    try:
+        result = json.loads(json_str)
+
+        # If target_type is provided and has __origin__ (e.g., List[SomeType])
+        if target_type and hasattr(target_type, '__origin__'):
+            if target_type.__origin__ is list:
+                item_type = target_type.__args__[0]
+                if hasattr(item_type, 'model_validate'):
+                    result = [item_type.model_validate(item) for item in result]
+                elif hasattr(item_type, 'parse_obj'):
+                    result = [item_type.parse_obj(item) for item in result]
+        elif target_type:
+            if hasattr(target_type, 'model_validate'):
+                result = target_type.model_validate(result)
+            elif hasattr(target_type, 'parse_obj'):
+                result = target_type.parse_obj(result)
+
+        return result
+    except json.JSONDecodeError as e:
+        raise ValueError(f"Failed to parse JSON: {e}. Text was: {json_str[:200]}...")
+
+
+def get_safe_subprocess_env() -> Dict[str, str]:
+    """Get filtered environment variables safe for subprocess execution.
+
+    Adapted from ADW get_safe_subprocess_env with SPARKPILOT-specific variables.
+    Prevents accidental exposure of sensitive credentials to subprocesses.
+
+    Returns:
+        Dictionary containing only required environment variables
+    """
+    safe_env_vars = {
+        # SPARKPILOT Configuration
+        "ICDEV_DB_PATH": os.getenv("ICDEV_DB_PATH", str(PROJECT_ROOT / "data" / "icdev.db")),
+        "ICDEV_PROJECT_ROOT": os.getenv("ICDEV_PROJECT_ROOT", str(PROJECT_ROOT)),
+
+        # Anthropic / Bedrock Configuration
+        "ANTHROPIC_API_KEY": os.getenv("ANTHROPIC_API_KEY"),
+        "AWS_ACCESS_KEY_ID": os.getenv("AWS_ACCESS_KEY_ID"),
+        "AWS_SECRET_ACCESS_KEY": os.getenv("AWS_SECRET_ACCESS_KEY"),
+        "AWS_DEFAULT_REGION": os.getenv("AWS_DEFAULT_REGION", "us-gov-west-1"),
+
+        # Claude Code Configuration
+        "CLAUDE_CODE_PATH": os.getenv("CLAUDE_CODE_PATH", "claude"),
+        "CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR": os.getenv(
+            "CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR", "true"
+        ),
+
+        # GitLab Configuration (optional)
+        "GITLAB_TOKEN": os.getenv("GITLAB_TOKEN"),
+        "GITLAB_URL": os.getenv("GITLAB_URL"),
+
+        # Essential system environment variables
+        "HOME": os.getenv("HOME") or os.getenv("USERPROFILE"),
+        "USER": os.getenv("USER") or os.getenv("USERNAME"),
+        "PATH": os.getenv("PATH"),
+        "SHELL": os.getenv("SHELL"),
+        "TERM": os.getenv("TERM"),
+        "LANG": os.getenv("LANG"),
+
+        # Windows-specific — needed for Python user site-packages and gh keyring
+        "USERPROFILE": os.getenv("USERPROFILE"),
+        "APPDATA": os.getenv("APPDATA"),
+        "LOCALAPPDATA": os.getenv("LOCALAPPDATA"),
+        "SYSTEMROOT": os.getenv("SYSTEMROOT"),
+        "TEMP": os.getenv("TEMP"),
+        "TMP": os.getenv("TMP"),
+
+        # GitHub CLI — needed for gh auth keyring access
+        "GH_TOKEN": os.getenv("GH_TOKEN") or os.getenv("GITHUB_PAT"),
+
+        # Python-specific
+        "PYTHONPATH": os.getenv("PYTHONPATH"),
+        "PYTHONUNBUFFERED": "1",
+
+        # Working directory
+        "PWD": os.getcwd(),
+    }
+
+    # Filter out None values
+    return {k: v for k, v in safe_env_vars.items() if v is not None}
+
+
+def timestamp_iso() -> str:
+    """Return current UTC timestamp in ISO 8601 format."""
+    return datetime.now(timezone.utc).isoformat() + "Z"
+
+
+def ensure_run_dir(run_id: str) -> Path:
+    """Ensure test run directory exists and return its path."""
+    run_dir = PROJECT_ROOT / ".tmp" / "test_runs" / run_id
+    run_dir.mkdir(parents=True, exist_ok=True)
+    return run_dir

tools/writeguard/__init__.py

@@ -0,0 +1 @@
+# writeguard module

tools/writeguard/main.py

@@ -0,0 +1 @@
+print('Hello from writeguard')

tools/writing/__init__.py

@@ -0,0 +1,7 @@
+"""WriteGuard — AI Writing Assistant for ICDEV (Phase 65).
+
+Air-gapped, Grammarly-like writing assistant with GovProposal integration.
+Deterministic-first pipeline with optional LLM-assisted analysis.
+"""
+
+__version__ = "1.0.0"

tools/writing/ai_content_detector.py

@@ -0,0 +1,316 @@
+"""WriteGuard AI Content Detector — Statistical AI-generated text detection (D-WG-6).
+
+Uses deterministic statistical methods: perplexity estimation, burstiness,
+n-gram repetition, and type-token ratio. No LLM needed — fully air-gap safe.
+Advisory-only per D110 — does not block, only informs.
+"""
+
+import re
+import math
+from collections import Counter
+
+
+# Common English word frequencies (top 200, for perplexity estimation)
+_COMMON_WORDS = {
+    "the": 7.0, "be": 6.5, "to": 6.4, "of": 6.3, "and": 6.2, "a": 6.1,
+    "in": 5.9, "that": 5.7, "have": 5.5, "i": 5.4, "it": 5.3, "for": 5.2,
+    "not": 5.1, "on": 5.0, "with": 4.9, "he": 4.8, "as": 4.7, "you": 4.6,
+    "do": 4.5, "at": 4.4, "this": 4.3, "but": 4.2, "his": 4.1, "by": 4.0,
+    "from": 3.9, "they": 3.8, "we": 3.7, "say": 3.6, "her": 3.5, "she": 3.4,
+    "or": 3.3, "an": 3.2, "will": 3.1, "my": 3.0, "one": 2.9, "all": 2.8,
+    "would": 2.7, "there": 2.6, "their": 2.5, "what": 2.4, "so": 2.3,
+    "up": 2.2, "out": 2.1, "if": 2.0, "about": 1.9, "who": 1.8,
+    "get": 1.7, "which": 1.6, "go": 1.5, "me": 1.4, "when": 1.3,
+    "make": 1.2, "can": 1.1, "like": 1.0, "time": 0.9, "no": 0.8,
+    "just": 0.7, "him": 0.6, "know": 0.5, "take": 0.4, "people": 0.3,
+    "into": 0.3, "year": 0.3, "your": 0.3, "good": 0.3, "some": 0.3,
+    "could": 0.3, "them": 0.3, "see": 0.3, "other": 0.3, "than": 0.3,
+    "then": 0.3, "now": 0.3, "look": 0.3, "only": 0.3, "come": 0.3,
+    "its": 0.3, "over": 0.3, "think": 0.3, "also": 0.3, "back": 0.3,
+    "after": 0.3, "use": 0.3, "two": 0.3, "how": 0.3, "our": 0.3,
+    "work": 0.3, "first": 0.3, "well": 0.3, "way": 0.3, "even": 0.3,
+    "new": 0.3, "want": 0.3, "because": 0.3, "any": 0.3, "these": 0.3,
+    "give": 0.3, "day": 0.3, "most": 0.3, "us": 0.3,
+}
+
+
+def detect_ai_content(text):
+    """Analyze text for AI-generated content indicators.
+
+    Uses 4 statistical signals:
+    1. Perplexity (word frequency deviation)
+    2. Burstiness (sentence length variance)
+    3. N-gram repetition (phrase pattern reuse)
+    4. Type-token ratio (vocabulary diversity)
+
+    Args:
+        text: Input text to analyze.
+
+    Returns:
+        dict with overall ai_score (0-1), signal scores, and interpretation.
+    """
+    if not text or not text.strip() or len(text.split()) < 20:
+        return _empty_result()
+
+    words = _get_words(text)
+    sentences = _split_sentences(text)
+
+    if len(words) < 20 or len(sentences) < 2:
+        return _empty_result()
+
+    # Signal 1: Perplexity — AI tends to use common/predictable words
+    perplexity_score = _calc_perplexity_score(words)
+
+    # Signal 2: Burstiness — AI has more uniform sentence lengths
+    burstiness_score = _calc_burstiness_score(sentences)
+
+    # Signal 3: N-gram repetition — AI repeats phrase patterns
+    ngram_score = _calc_ngram_repetition_score(words)
+
+    # Signal 4: Type-token ratio — AI has moderate, consistent vocabulary
+    ttr_score = _calc_ttr_score(words)
+
+    # Weighted composite (higher = more likely AI)
+    ai_score = (
+        perplexity_score * 0.30
+        + burstiness_score * 0.25
+        + ngram_score * 0.25
+        + ttr_score * 0.20
+    )
+
+    return {
+        "ai_score": round(ai_score, 3),
+        "interpretation": _interpret_score(ai_score),
+        "confidence": _calc_confidence(len(words), len(sentences)),
+        "signals": {
+            "perplexity": {
+                "score": round(perplexity_score, 3),
+                "description": "Word predictability (high = more predictable = more AI-like)",
+            },
+            "burstiness": {
+                "score": round(burstiness_score, 3),
+                "description": "Sentence length uniformity (high = more uniform = more AI-like)",
+            },
+            "ngram_repetition": {
+                "score": round(ngram_score, 3),
+                "description": "Phrase pattern reuse (high = more repetitive = more AI-like)",
+            },
+            "type_token_ratio": {
+                "score": round(ttr_score, 3),
+                "description": "Vocabulary diversity signal (moderate+uniform = more AI-like)",
+            },
+        },
+        "stats": {
+            "word_count": len(words),
+            "sentence_count": len(sentences),
+            "unique_words": len(set(w.lower() for w in words)),
+        },
+        "advisory": True,  # D110 — advisory only
+    }
+
+
+def _calc_perplexity_score(words):
+    """Estimate perplexity via word frequency deviation.
+
+    AI-generated text tends to use more common, predictable words.
+    Lower entropy = more predictable = higher AI score.
+    """
+    total = len(words)
+    if total == 0:
+        return 0.5
+
+    # Calculate how "common" the vocabulary is
+    common_count = 0
+    for w in words:
+        if w.lower() in _COMMON_WORDS:
+            common_count += 1
+
+    common_ratio = common_count / total
+
+    # AI text typically has common_ratio 0.55-0.70
+    # Human text typically has common_ratio 0.40-0.55
+    if common_ratio > 0.65:
+        return min(1.0, 0.5 + (common_ratio - 0.65) * 3.0)
+    elif common_ratio > 0.55:
+        return 0.3 + (common_ratio - 0.55) * 2.0
+    else:
+        return max(0.0, common_ratio * 0.5)
+
+
+def _calc_burstiness_score(sentences):
+    """Measure sentence length variance (burstiness).
+
+    Human writing has "bursty" variation in sentence length.
+    AI writing tends toward more uniform sentence lengths.
+    """
+    if len(sentences) < 3:
+        return 0.5
+
+    lengths = [len(s.split()) for s in sentences if s.strip()]
+    if not lengths or len(lengths) < 3:
+        return 0.5
+
+    mean = sum(lengths) / len(lengths)
+    if mean == 0:
+        return 0.5
+
+    # Coefficient of variation (CV)
+    variance = sum((l - mean) ** 2 for l in lengths) / len(lengths)
+    std_dev = math.sqrt(variance)
+    cv = std_dev / mean
+
+    # Human writing typically has CV 0.4-0.8
+    # AI writing typically has CV 0.15-0.35
+    if cv < 0.20:
+        return 0.9  # Very uniform = likely AI
+    elif cv < 0.35:
+        return 0.6  # Somewhat uniform
+    elif cv < 0.50:
+        return 0.3  # Normal variation
+    else:
+        return max(0.0, 0.2 - (cv - 0.50) * 0.3)  # High variation = likely human
+
+
+def _calc_ngram_repetition_score(words):
+    """Measure n-gram repetition patterns.
+
+    AI text often reuses similar phrase structures.
+    """
+    if len(words) < 20:
+        return 0.5
+
+    lower_words = [w.lower() for w in words]
+
+    # Check trigram repetition
+    trigrams = []
+    for i in range(len(lower_words) - 2):
+        trigrams.append(f"{lower_words[i]} {lower_words[i+1]} {lower_words[i+2]}")
+
+    if not trigrams:
+        return 0.5
+
+    trigram_counts = Counter(trigrams)
+    total_trigrams = len(trigrams)
+    unique_trigrams = len(trigram_counts)
+
+    # Repetition ratio
+    if total_trigrams == 0:
+        return 0.5
+
+    repetition_ratio = 1.0 - (unique_trigrams / total_trigrams)
+
+    # Also check bigram repetition
+    bigrams = []
+    for i in range(len(lower_words) - 1):
+        bigrams.append(f"{lower_words[i]} {lower_words[i+1]}")
+
+    bigram_counts = Counter(bigrams)
+    repeated_bigrams = sum(1 for count in bigram_counts.values() if count > 2)
+    bigram_repeat_ratio = repeated_bigrams / max(1, len(bigram_counts))
+
+    # Combine signals
+    score = repetition_ratio * 0.6 + bigram_repeat_ratio * 0.4
+
+    # AI text typically 0.15-0.30 repetition
+    # Human text typically 0.05-0.15
+    return min(1.0, score * 2.5)
+
+
+def _calc_ttr_score(words):
+    """Calculate Type-Token Ratio signal.
+
+    AI text often has a moderate, consistent TTR.
+    Human text varies more widely.
+    """
+    if len(words) < 20:
+        return 0.5
+
+    lower_words = [w.lower() for w in words]
+
+    # Calculate TTR on windows to handle text length
+    window_size = min(100, len(lower_words))
+    ttrs = []
+
+    for i in range(0, len(lower_words) - window_size + 1, window_size // 2):
+        window = lower_words[i : i + window_size]
+        ttr = len(set(window)) / len(window)
+        ttrs.append(ttr)
+
+    if not ttrs:
+        return 0.5
+
+    avg_ttr = sum(ttrs) / len(ttrs)
+
+    # Check consistency of TTR across windows
+    if len(ttrs) >= 2:
+        ttr_variance = sum((t - avg_ttr) ** 2 for t in ttrs) / len(ttrs)
+        ttr_cv = math.sqrt(ttr_variance) / max(0.01, avg_ttr)
+    else:
+        ttr_cv = 0.1  # Default moderate
+
+    # AI typically: TTR 0.50-0.65, low variance
+    # Human: TTR varies more, higher variance
+    ttr_signal = 0.5
+    if 0.50 <= avg_ttr <= 0.65 and ttr_cv < 0.10:
+        ttr_signal = 0.7  # Classic AI pattern
+    elif avg_ttr < 0.45 or avg_ttr > 0.75:
+        ttr_signal = 0.2  # More human-like extremes
+    elif ttr_cv > 0.15:
+        ttr_signal = 0.3  # High variation = human
+
+    return ttr_signal
+
+
+def _calc_confidence(word_count, sentence_count):
+    """Calculate confidence level based on text length.
+
+    More text = more reliable detection.
+    """
+    if word_count >= 500 and sentence_count >= 15:
+        return "high"
+    elif word_count >= 200 and sentence_count >= 8:
+        return "medium"
+    elif word_count >= 50:
+        return "low"
+    else:
+        return "very_low"
+
+
+def _interpret_score(score):
+    """Interpret AI content score."""
+    if score >= 0.75:
+        return "Likely AI-generated"
+    elif score >= 0.50:
+        return "Possibly AI-generated"
+    elif score >= 0.25:
+        return "Likely human-written"
+    else:
+        return "Very likely human-written"
+
+
+def _get_words(text):
+    """Extract words from text."""
+    return re.findall(r"[a-zA-Z']+", text)
+
+
+def _split_sentences(text):
+    """Split text into sentences."""
+    cleaned = text
+    abbrevs = ["Mr.", "Mrs.", "Ms.", "Dr.", "Jr.", "Sr.", "St.", "vs.", "etc.", "i.e.", "e.g.", "U.S.", "Gov."]
+    for abbr in abbrevs:
+        cleaned = cleaned.replace(abbr, abbr.replace(".", "<!DOT!>"))
+    sentences = re.split(r"(?<=[.!?])\s+(?=[A-Z])", cleaned)
+    sentences = [s.replace("<!DOT!>", ".") for s in sentences]
+    return [s for s in sentences if s.strip() and len(s.split()) >= 2]
+
+
+def _empty_result():
+    """Return empty result for insufficient input."""
+    return {
+        "ai_score": 0.0,
+        "interpretation": "Insufficient text for analysis (need >= 20 words)",
+        "confidence": "very_low",
+        "signals": {},
+        "stats": {"word_count": 0, "sentence_count": 0, "unique_words": 0},
+        "advisory": True,
+    }