icdev 0.0.3__py3-none-any.whl

tools/writing/signal_registrar.py

@@ -0,0 +1,167 @@
+"""WriteGuard Signal Registrar — Innovation Engine bridge (D-WG-14, D360).
+
+Registers high-frequency writing findings as innovation signals,
+enabling the Innovation Engine to detect patterns and generate solutions.
+"""
+
+import json
+import logging
+import sqlite3
+import uuid
+from collections import Counter
+from datetime import datetime
+from pathlib import Path
+
+
+DB_PATH = Path(__file__).resolve().parent.parent.parent / "data" / "icdev.db"
+
+
+def _get_db(db_path=None):
+    """Get database connection."""
+    path = db_path or DB_PATH
+    return sqlite3.connect(str(path))
+
+
+def _now():
+    """Current timestamp."""
+    return datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def register_high_frequency_findings(min_count=5, days_back=30, db_path=None):
+    """Scan recent analysis findings for high-frequency patterns.
+
+    Findings that appear >= min_count times in the past days_back days
+    are registered as innovation signals for trend detection.
+
+    Args:
+        min_count: Minimum occurrence count to qualify.
+        days_back: Window in days to scan.
+        db_path: Optional database path.
+
+    Returns:
+        dict with 'signals_registered', 'patterns'.
+    """
+    conn = _get_db(db_path)
+    try:
+        # Count finding patterns by rule_id + category
+        rows = conn.execute(
+            """SELECT rule_id, category, severity, message, COUNT(*) as cnt
+               FROM wg_analysis_findings
+               WHERE created_at >= datetime('now', ?)
+                 AND rule_id != ''
+               GROUP BY rule_id, category
+               HAVING COUNT(*) >= ?
+               ORDER BY cnt DESC
+               LIMIT 20""",
+            (f"-{days_back} days", min_count),
+        ).fetchall()
+
+        if not rows:
+            return {"signals_registered": 0, "patterns": []}
+
+        registered = []
+
+        for row in rows:
+            rule_id = row[0]
+            category = row[1]
+            severity = row[2]
+            message = row[3]
+            count = row[4]
+
+            # Check if already registered recently
+            existing = conn.execute(
+                """SELECT id FROM innovation_signals
+                   WHERE source_type = 'writing_analysis'
+                     AND content_hash = ?
+                     AND created_at >= datetime('now', '-7 days')""",
+                (f"wg:{rule_id}",),
+            ).fetchone()
+
+            if existing:
+                continue
+
+            # Calculate signal score based on frequency and severity
+            severity_weight = {
+                "critical": 1.0, "high": 0.8, "medium": 0.5,
+                "low": 0.3, "info": 0.1,
+            }.get(severity, 0.3)
+
+            frequency_score = min(1.0, count / 50.0)  # Normalize to 50 max
+            signal_score = round(
+                frequency_score * 0.6 + severity_weight * 0.4, 2
+            )
+
+            signal_id = f"sig-wg-{uuid.uuid4().hex[:12]}"
+            title = f"Writing pattern: {rule_id} ({category})"
+            description = (
+                f"Found {count} occurrences of '{message[:100]}' "
+                f"in the last {days_back} days. "
+                f"Category: {category}, severity: {severity}."
+            )
+
+            try:
+                conn.execute(
+                    """INSERT INTO innovation_signals
+                       (id, source, source_type, title, description, url,
+                        raw_content, content_hash, relevance_score, status,
+                        created_at)
+                       VALUES (?,?,?,?,?,?,?,?,?,?,?)""",
+                    (signal_id, "writeguard", "writing_analysis",
+                     title, description, "",
+                     json.dumps({
+                         "rule_id": rule_id, "category": category,
+                         "severity": severity, "count": count,
+                         "message": message,
+                     }),
+                     f"wg:{rule_id}", signal_score, "new", _now()),
+                )
+
+                registered.append({
+                    "signal_id": signal_id,
+                    "rule_id": rule_id,
+                    "category": category,
+                    "count": count,
+                    "score": signal_score,
+                })
+            except Exception:
+                logging.getLogger(__name__).debug("Failed to register signal for rule %s", rule_id, exc_info=True)
+                continue
+
+        conn.commit()
+
+        return {
+            "signals_registered": len(registered),
+            "patterns": registered,
+            "scan_window_days": days_back,
+            "min_threshold": min_count,
+        }
+
+    except Exception as exc:
+        return {"signals_registered": 0, "patterns": [], "error": str(exc)}
+    finally:
+        conn.close()
+
+
+def get_writing_signals(limit=20, db_path=None):
+    """List recent innovation signals from WriteGuard.
+
+    Returns:
+        list of signal dicts.
+    """
+    conn = _get_db(db_path)
+    try:
+        rows = conn.execute(
+            """SELECT id, title, description, relevance_score, status, created_at
+               FROM innovation_signals
+               WHERE source_type = 'writing_analysis'
+               ORDER BY created_at DESC
+               LIMIT ?""",
+            (limit,),
+        ).fetchall()
+
+        cols = ["id", "title", "description", "relevance_score",
+                "status", "created_at"]
+        return [dict(zip(cols, row)) for row in rows]
+
+    finally:
+        conn.close()

tools/writing/snippet_manager.py

@@ -0,0 +1,276 @@
+"""WriteGuard Snippet Manager — CRUD + search for reusable writing templates (D-WG-7).
+
+Pattern: knowledge_base.py (D358).
+"""
+
+import json
+import sqlite3
+import uuid
+from datetime import UTC, datetime
+from pathlib import Path
+
+
+DB_PATH = Path(__file__).resolve().parent.parent.parent / "data" / "icdev.db"
+
+CATEGORIES = (
+    "boilerplate", "transition", "introduction", "conclusion",
+    "methodology", "compliance", "evidence", "custom",
+)
+
+
+def _get_db(db_path=None):
+    """Get database connection."""
+    path = db_path or DB_PATH
+    return sqlite3.connect(str(path))
+
+
+def _now():
+    """Current timestamp."""
+    return datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def add_snippet(title, content, category, domain="general", tags=None,
+                tenant_id="", project_id="", created_by="",
+                classification="CUI", db_path=None):
+    """Add a new snippet.
+
+    Returns:
+        dict with snippet details.
+    """
+    if category not in CATEGORIES:
+        return {"error": f"Invalid category: {category}. Must be one of {CATEGORIES}"}
+
+    snippet_id = f"wg-sn-{uuid.uuid4().hex[:12]}"
+    tags_json = json.dumps(tags or [])
+    now = _now()
+
+    conn = _get_db(db_path)
+    try:
+        conn.execute(
+            """INSERT INTO wg_snippets
+               (id, title, content, category, domain, tags, usage_count, status,
+                tenant_id, project_id, created_by, classification, created_at, updated_at)
+               VALUES (?, ?, ?, ?, ?, ?, 0, 'active', ?, ?, ?, ?, ?, ?)""",
+            (snippet_id, title, content, category, domain, tags_json,
+             tenant_id, project_id, created_by, classification, now, now),
+        )
+        conn.commit()
+        return {"id": snippet_id, "title": title, "category": category, "status": "created"}
+    except Exception as e:
+        return {"error": str(e)}
+    finally:
+        conn.close()
+
+
+def get_snippet(snippet_id, db_path=None):
+    """Get a snippet by ID.
+
+    Returns:
+        dict with snippet data, or error.
+    """
+    conn = _get_db(db_path)
+    try:
+        row = conn.execute(
+            "SELECT * FROM wg_snippets WHERE id=?", (snippet_id,)
+        ).fetchone()
+
+        if not row:
+            return {"error": f"Snippet not found: {snippet_id}"}
+
+        cols = [d[0] for d in conn.execute("SELECT * FROM wg_snippets LIMIT 0").description]
+        result = dict(zip(cols, row))
+
+        # Parse tags JSON
+        try:
+            result["tags"] = json.loads(result.get("tags", "[]"))
+        except (json.JSONDecodeError, TypeError):
+            result["tags"] = []
+
+        return result
+    finally:
+        conn.close()
+
+
+def list_snippets(category=None, domain=None, status="active",
+                  tenant_id=None, db_path=None):
+    """List snippets with optional filters.
+
+    Returns:
+        list of snippet summary dicts.
+    """
+    conn = _get_db(db_path)
+    try:
+        query = "SELECT id, title, category, domain, usage_count, status, created_at FROM wg_snippets"
+        params = []
+        conditions = []
+
+        if category:
+            conditions.append("category=?")
+            params.append(category)
+        if domain:
+            conditions.append("domain=?")
+            params.append(domain)
+        if status:
+            conditions.append("status=?")
+            params.append(status)
+        if tenant_id:
+            conditions.append("tenant_id=?")
+            params.append(tenant_id)
+
+        if conditions:
+            query += " WHERE " + " AND ".join(conditions)
+
+        query += " ORDER BY usage_count DESC, created_at DESC"
+
+        rows = conn.execute(query, params).fetchall()
+        cols = ["id", "title", "category", "domain", "usage_count", "status", "created_at"]
+        return [dict(zip(cols, row)) for row in rows]
+    finally:
+        conn.close()
+
+
+def search_snippets(query_text, top_k=10, db_path=None):
+    """Search snippets by keyword matching.
+
+    Simple keyword search — RAG semantic search integration happens at
+    the analysis_engine level via RAGRetriever.
+
+    Returns:
+        list of matching snippets.
+    """
+    if not query_text or not query_text.strip():
+        return []
+
+    conn = _get_db(db_path)
+    try:
+        # Keyword search on title, content, tags
+        keywords = query_text.lower().split()
+        conditions = []
+        params = []
+
+        for kw in keywords[:5]:  # Max 5 keywords
+            conditions.append(
+                "(LOWER(title) LIKE ? OR LOWER(content) LIKE ? OR LOWER(tags) LIKE ?)"
+            )
+            like = f"%{kw}%"
+            params.extend([like, like, like])
+
+        if not conditions:
+            return []
+
+        where_clause = ' OR '.join(conditions)
+        query = (
+            "SELECT id, title, content, category, domain, tags, usage_count"
+            " FROM wg_snippets"
+            " WHERE status='active' AND (" + where_clause + ")"
+            " ORDER BY usage_count DESC"
+            " LIMIT ?"
+        )
+        params.append(top_k)
+
+        rows = conn.execute(query, params).fetchall()
+        cols = ["id", "title", "content", "category", "domain", "tags", "usage_count"]
+        results = []
+        for row in rows:
+            d = dict(zip(cols, row))
+            try:
+                d["tags"] = json.loads(d.get("tags", "[]"))
+            except (json.JSONDecodeError, TypeError):
+                d["tags"] = []
+            results.append(d)
+
+        return results
+    finally:
+        conn.close()
+
+
+def update_snippet(snippet_id, title=None, content=None, category=None,
+                   tags=None, db_path=None):
+    """Update snippet fields.
+
+    Returns:
+        dict with update status.
+    """
+    conn = _get_db(db_path)
+    try:
+        # Check snippet exists
+        existing = conn.execute(
+            "SELECT id FROM wg_snippets WHERE id=?", (snippet_id,)
+        ).fetchone()
+        if not existing:
+            return {"error": f"Snippet not found: {snippet_id}"}
+
+        updates = []
+        params = []
+
+        if title is not None:
+            updates.append("title=?")
+            params.append(title)
+        if content is not None:
+            updates.append("content=?")
+            params.append(content)
+        if category is not None:
+            if category not in CATEGORIES:
+                return {"error": f"Invalid category: {category}"}
+            updates.append("category=?")
+            params.append(category)
+        if tags is not None:
+            updates.append("tags=?")
+            params.append(json.dumps(tags))
+
+        if not updates:
+            return {"error": "No fields to update"}
+
+        updates.append("updated_at=?")
+        params.append(_now())
+        params.append(snippet_id)
+
+        set_clause = ', '.join(updates)
+        conn.execute(
+            "UPDATE wg_snippets SET " + set_clause + " WHERE id=?", params
+        )
+        conn.commit()
+        return {"id": snippet_id, "status": "updated"}
+    except Exception as e:
+        return {"error": str(e)}
+    finally:
+        conn.close()
+
+
+def increment_usage(snippet_id, db_path=None):
+    """Increment usage count when a snippet is used.
+
+    Returns:
+        dict with new usage count.
+    """
+    conn = _get_db(db_path)
+    try:
+        conn.execute(
+            "UPDATE wg_snippets SET usage_count = usage_count + 1 WHERE id=?",
+            (snippet_id,),
+        )
+        conn.commit()
+        row = conn.execute(
+            "SELECT usage_count FROM wg_snippets WHERE id=?", (snippet_id,)
+        ).fetchone()
+        return {"id": snippet_id, "usage_count": row[0] if row else 0}
+    finally:
+        conn.close()
+
+
+def archive_snippet(snippet_id, db_path=None):
+    """Archive a snippet (soft delete).
+
+    Returns:
+        dict with archive status.
+    """
+    conn = _get_db(db_path)
+    try:
+        conn.execute(
+            "UPDATE wg_snippets SET status='archived', updated_at=? WHERE id=?",
+            (_now(), snippet_id),
+        )
+        conn.commit()
+        return {"id": snippet_id, "status": "archived"}
+    finally:
+        conn.close()

tools/writing/style_enforcer.py

@@ -0,0 +1,220 @@
+"""WriteGuard Style Enforcer — Evaluate text against resolved style guide rules (D-WG-3).
+
+Takes resolved cascade output and checks text compliance with each rule dimension.
+Generates findings per violation.
+"""
+
+import re
+
+import yaml
+
+from tools.writing.grammar_checker import check_passive_voice, check_sentence_length
+from tools.writing.readability_scorer import score_readability
+
+
+def enforce_style(text, resolved_guide):
+    """Check text against a resolved style guide.
+
+    Args:
+        text: Input text to check.
+        resolved_guide: dict from style_guide_manager.resolve_cascade()['resolved_guide'].
+
+    Returns:
+        dict with 'findings' list, 'compliance_score', and 'summary'.
+    """
+    if not text or not text.strip():
+        return {"findings": [], "compliance_score": 1.0, "summary": {}}
+
+    rules = resolved_guide if isinstance(resolved_guide, dict) else {}
+    findings = []
+    checks_passed = 0
+    checks_total = 0
+
+    # 1. Readability checks
+    readability_rules = rules.get("rules", {}).get("readability", {})
+    if readability_rules:
+        scores = score_readability(text)
+        max_grade = readability_rules.get("max_grade_level", 16)
+        target_grade = readability_rules.get("target_grade_level", 12)
+        min_ease = readability_rules.get("min_flesch_ease", 30)
+
+        checks_total += 3
+
+        if scores["grade_level"] > max_grade:
+            findings.append({
+                "category": "readability",
+                "severity": "high",
+                "message": f"Grade level {scores['grade_level']} exceeds maximum {max_grade}.",
+                "rule_id": "STYLE-READ-001",
+                "context": f"FK={scores['flesch_kincaid_grade']}, Fog={scores['gunning_fog']}",
+            })
+        else:
+            checks_passed += 1
+
+        if scores["grade_level"] > target_grade:
+            findings.append({
+                "category": "readability",
+                "severity": "medium",
+                "message": f"Grade level {scores['grade_level']} exceeds target {target_grade}.",
+                "rule_id": "STYLE-READ-002",
+                "context": f"Consider simplifying for better readability.",
+            })
+        else:
+            checks_passed += 1
+
+        if scores["flesch_reading_ease"] < min_ease:
+            findings.append({
+                "category": "readability",
+                "severity": "medium",
+                "message": f"Flesch Reading Ease {scores['flesch_reading_ease']} below minimum {min_ease}.",
+                "rule_id": "STYLE-READ-003",
+                "context": f"Lower scores indicate harder-to-read text.",
+            })
+        else:
+            checks_passed += 1
+
+    # 2. Sentence structure checks
+    sentence_rules = rules.get("rules", {}).get("sentences", {})
+    if sentence_rules:
+        max_words = sentence_rules.get("max_words", 40)
+        max_passive_pct = sentence_rules.get("max_passive_voice_pct", 30)
+
+        sl = check_sentence_length(text, max_words=max_words)
+        pv = check_passive_voice(text)
+
+        checks_total += 2
+
+        if sl["long_sentences"]:
+            count = len(sl["long_sentences"])
+            findings.append({
+                "category": "sentence_length",
+                "severity": "medium",
+                "message": f"{count} sentence(s) exceed {max_words} words (max: {sl['max_length']}).",
+                "rule_id": "STYLE-SENT-001",
+                "context": f"Avg sentence length: {sl['avg_length']} words.",
+            })
+        else:
+            checks_passed += 1
+
+        if pv["passive_pct"] > max_passive_pct:
+            findings.append({
+                "category": "passive_voice",
+                "severity": "medium",
+                "message": f"Passive voice at {pv['passive_pct']}% exceeds maximum {max_passive_pct}%.",
+                "rule_id": "STYLE-PASS-001",
+                "context": f"{pv['passive_count']} of {pv['total_sentences']} sentences use passive voice.",
+            })
+        else:
+            checks_passed += 1
+
+    # 3. Word choice checks
+    word_rules = rules.get("rules", {}).get("word_choice", {})
+    if word_rules:
+        # Check contractions
+        if word_rules.get("avoid_contractions", False):
+            checks_total += 1
+            contraction_pattern = re.compile(
+                r"\b(?:can't|won't|don't|doesn't|didn't|isn't|aren't|wasn't|weren't|"
+                r"hasn't|haven't|hadn't|shouldn't|wouldn't|couldn't|they're|we're|"
+                r"you're|I'm|he's|she's|it's|we've|they've|you've|I've|we'll|"
+                r"they'll|you'll|I'll|he'll|she'll|who's|what's|that's|there's|"
+                r"here's|let's)\b"
+            )
+            contractions = contraction_pattern.findall(text)
+            if contractions:
+                findings.append({
+                    "category": "style",
+                    "severity": "low",
+                    "message": f"Found {len(contractions)} contraction(s). Style guide prohibits contractions.",
+                    "rule_id": "STYLE-WORD-001",
+                    "context": f"Examples: {', '.join(contractions[:5])}",
+                })
+            else:
+                checks_passed += 1
+
+        # Check banned words
+        banned = word_rules.get("banned_words", [])
+        if banned:
+            checks_total += 1
+            found_banned = []
+            for word in banned:
+                if re.search(rf"\b{re.escape(word)}\b", text, re.IGNORECASE):
+                    found_banned.append(word)
+            if found_banned:
+                findings.append({
+                    "category": "style",
+                    "severity": "low",
+                    "message": f"Found banned word(s): {', '.join(found_banned)}.",
+                    "rule_id": "STYLE-WORD-002",
+                    "context": "Consider using simpler alternatives.",
+                })
+            else:
+                checks_passed += 1
+
+    # 4. Tone checks
+    tone_rules = rules.get("rules", {}).get("tone", {})
+    if tone_rules:
+        if tone_rules.get("avoid_first_person", False):
+            checks_total += 1
+            first_person = re.findall(
+                r"\b(?:I think|I believe|I feel|I suggest|in my opinion|my experience)\b",
+                text, re.IGNORECASE,
+            )
+            if first_person:
+                findings.append({
+                    "category": "tone",
+                    "severity": "low",
+                    "message": f"First-person language detected ({len(first_person)} instance(s)).",
+                    "rule_id": "STYLE-TONE-001",
+                    "context": "Style guide requires organizational voice.",
+                })
+            else:
+                checks_passed += 1
+
+    # 5. CUI marking checks
+    cui_rules = rules.get("rules", {}).get("cui", {})
+    if cui_rules:
+        if cui_rules.get("marking_required", False):
+            checks_total += 1
+            has_cui = bool(re.search(r"CUI\b|Controlled Unclassified Information", text))
+            if not has_cui:
+                findings.append({
+                    "category": "cui_marking",
+                    "severity": "critical",
+                    "message": "CUI marking is required but not found in document.",
+                    "rule_id": "STYLE-CUI-001",
+                    "context": "Add 'CUI' or 'CUI // SP-CTI' banner per classification policy.",
+                })
+            else:
+                checks_passed += 1
+
+        if cui_rules.get("banner_required", False):
+            checks_total += 1
+            has_banner = bool(re.search(r"CUI\s*//", text))
+            if not has_banner:
+                findings.append({
+                    "category": "cui_marking",
+                    "severity": "high",
+                    "message": "CUI banner (CUI // category) not found at document level.",
+                    "rule_id": "STYLE-CUI-002",
+                    "context": "Add CUI banner at document header.",
+                })
+            else:
+                checks_passed += 1
+
+    # Compliance score
+    compliance_score = checks_passed / max(1, checks_total)
+
+    # Summary by severity
+    by_severity = {}
+    for f in findings:
+        sev = f["severity"]
+        by_severity[sev] = by_severity.get(sev, 0) + 1
+
+    return {
+        "findings": findings,
+        "compliance_score": round(compliance_score, 2),
+        "checks_passed": checks_passed,
+        "checks_total": checks_total,
+        "summary": by_severity,
+    }