@clawos-dev/clawd 0.2.50-beta.77.3a9364e → 0.2.51-beta.78.2024c11

package/dist/persona-defaults/persona-researcher/.claude/skills/deep-research/scripts/verify_claim_support.py

@@ -1,344 +0,0 @@
-#!/usr/bin/env python3
-"""
-Claim-Support Verification — checks whether evidence supports claims.
-
-CLI subcommands:
-  verify       Check all claims against evidence, update support_status
-  report       Generate a support verification summary
-
-Version 1 is deterministic and cheap: entity, number, date, and
-lexical-overlap checks over stored evidence. No LLM calls.
-
-Only factual claims hard-fail on unsupported status.
-Synthesis/recommendation need traceability but softer thresholds.
-"""
-
-import argparse
-import json
-import os
-import re
-import sys
-from collections import Counter
-from datetime import datetime, timezone
-
-
-# ---------------------------------------------------------------------------
-# JSONL helpers
-# ---------------------------------------------------------------------------
-
-def read_jsonl(path: str) -> list[dict]:
-    rows = []
-    if not os.path.exists(path):
-        return rows
-    with open(path) as f:
-        for line in f:
-            line = line.strip()
-            if line:
-                rows.append(json.loads(line))
-    return rows
-
-
-def write_jsonl(path: str, rows: list[dict]) -> None:
-    with open(path, 'w') as f:
-        for row in rows:
-            f.write(json.dumps(row, ensure_ascii=False) + '\n')
-
-
-# ---------------------------------------------------------------------------
-# Support verification logic
-# ---------------------------------------------------------------------------
-
-# Extract numbers (integers and decimals)
-NUMBER_RE = re.compile(r'\b\d+(?:\.\d+)?(?:%|x|X)?\b')
-
-# Extract year-like numbers
-YEAR_RE = re.compile(r'\b(19|20)\d{2}\b')
-
-# Extract capitalized entities (naive NER)
-ENTITY_RE = re.compile(r'\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*\b')
-
-# Common stop entities to ignore
-STOP_ENTITIES = frozenset([
-    'The', 'This', 'That', 'These', 'However', 'Furthermore',
-    'Moreover', 'Additionally', 'Therefore', 'Nevertheless',
-])
-
-
-def extract_tokens(text: str) -> set[str]:
-    """Extract significant lowercase tokens (>3 chars)."""
-    words = re.findall(r'\b[a-z]{4,}\b', text.lower())
-    return set(words)
-
-
-def extract_numbers(text: str) -> set[str]:
-    """Extract numeric values."""
-    return set(NUMBER_RE.findall(text))
-
-
-def extract_years(text: str) -> set[str]:
-    """Extract year mentions."""
-    return set(YEAR_RE.findall(text))
-
-
-def extract_entities(text: str) -> set[str]:
-    """Extract capitalized entity mentions."""
-    ents = set(ENTITY_RE.findall(text))
-    return ents - STOP_ENTITIES
-
-
-def compute_support_score(claim_text: str, evidence_quotes: list[str]) -> tuple[str, float, str]:
-    """
-    Compute support status for a claim given its linked evidence quotes.
-
-    Returns (status, score, notes).
-    Score range: 0.0 (no overlap) to 1.0 (strong support).
-    """
-    if not evidence_quotes:
-        return ('unsupported', 0.0, 'no evidence linked')
-
-    claim_tokens = extract_tokens(claim_text)
-    claim_numbers = extract_numbers(claim_text)
-    claim_years = extract_years(claim_text)
-    claim_entities = extract_entities(claim_text)
-
-    best_score = 0.0
-    best_notes = []
-
-    for quote in evidence_quotes:
-        ev_tokens = extract_tokens(quote)
-        ev_numbers = extract_numbers(quote)
-        ev_years = extract_years(quote)
-        ev_entities = extract_entities(quote)
-
-        # Token overlap (Jaccard-like)
-        if claim_tokens:
-            token_overlap = len(claim_tokens & ev_tokens) / len(claim_tokens)
-        else:
-            token_overlap = 0.0
-
-        # Number match
-        if claim_numbers:
-            number_match = len(claim_numbers & ev_numbers) / len(claim_numbers)
-        else:
-            number_match = 1.0  # No numbers to check
-
-        # Year match
-        if claim_years:
-            year_match = len(claim_years & ev_years) / len(claim_years)
-        else:
-            year_match = 1.0
-
-        # Entity match
-        if claim_entities:
-            entity_match = len(claim_entities & ev_entities) / len(claim_entities)
-        else:
-            entity_match = 1.0
-
-        # Weighted composite
-        score = (
-            0.4 * token_overlap +
-            0.25 * number_match +
-            0.15 * year_match +
-            0.2 * entity_match
-        )
-
-        if score > best_score:
-            best_score = score
-            best_notes = []
-            if token_overlap < 0.3:
-                best_notes.append('low lexical overlap')
-            if claim_numbers and number_match < 0.5:
-                best_notes.append('number mismatch')
-            if claim_years and year_match < 1.0:
-                best_notes.append('year mismatch')
-            if claim_entities and entity_match < 0.3:
-                best_notes.append('entity mismatch')
-
-    # Threshold decision
-    if best_score >= 0.6:
-        status = 'supported'
-    elif best_score >= 0.35:
-        status = 'partial'
-    else:
-        status = 'needs_review'
-
-    notes = '; '.join(best_notes) if best_notes else 'adequate overlap'
-    return (status, round(best_score, 3), notes)
-
-
-# ---------------------------------------------------------------------------
-# Subcommands
-# ---------------------------------------------------------------------------
-
-def cmd_verify(args: argparse.Namespace) -> None:
-    """Verify all claims against evidence, update claims.jsonl."""
-    claims_path = os.path.join(args.dir, 'claims.jsonl')
-    evidence_path = os.path.join(args.dir, 'evidence.jsonl')
-    sources_path = os.path.join(args.dir, 'sources.jsonl')
-
-    claims = read_jsonl(claims_path)
-    evidence = read_jsonl(evidence_path)
-    sources = read_jsonl(sources_path)
-
-    # Build evidence index by source_id
-    ev_by_source: dict[str, list[str]] = {}
-    ev_by_id: dict[str, dict] = {}
-    for ev in evidence:
-        sid = ev.get('source_id', '')
-        eid = ev.get('evidence_id', '')
-        ev_by_source.setdefault(sid, []).append(ev.get('quote', ''))
-        ev_by_id[eid] = ev
-
-    # Deduplicate claims
-    seen = set()
-    unique_claims = []
-    for c in claims:
-        cid = c.get('claim_id')
-        if cid not in seen:
-            seen.add(cid)
-            unique_claims.append(c)
-
-    verified = 0
-    updated_claims = []
-
-    for claim in unique_claims:
-        claim_type = claim.get('claim_type', 'factual')
-
-        # Gather evidence for this claim
-        cited_ids = claim.get('cited_source_ids', [])
-        evidence_ids = claim.get('evidence_ids', [])
-
-        # Collect evidence quotes from linked evidence_ids
-        quotes = []
-        for eid in evidence_ids:
-            if eid in ev_by_id:
-                quotes.append(ev_by_id[eid].get('quote', ''))
-
-        # Also gather from cited sources
-        for sid in cited_ids:
-            if sid in ev_by_source:
-                quotes.extend(ev_by_source[sid])
-
-        if not quotes and not cited_ids and not evidence_ids:
-            # No links at all
-            if claim_type == 'speculation':
-                claim['support_status'] = 'supported'  # Speculation doesn't need evidence
-            else:
-                claim['support_status'] = 'unsupported'
-        elif not quotes:
-            # Has cited sources but no evidence captured yet
-            claim['support_status'] = 'needs_review'
-        else:
-            status, score, notes = compute_support_score(claim['text'], quotes)
-            claim['support_status'] = status
-            claim['_support_score'] = score
-            claim['_support_notes'] = notes
-
-        verified += 1
-        updated_claims.append(claim)
-
-    # Rewrite claims.jsonl with updated statuses
-    write_jsonl(claims_path, updated_claims)
-
-    # Compute summary
-    status_counts = Counter(c.get('support_status') for c in updated_claims)
-    factual_unsupported = sum(
-        1 for c in updated_claims
-        if c.get('claim_type') == 'factual' and c.get('support_status') == 'unsupported'
-    )
-    total_factual = sum(1 for c in updated_claims if c.get('claim_type') == 'factual')
-
-    # Strict mode: fail if any factual claim is unsupported
-    passed = True
-    if args.strict and factual_unsupported > 0:
-        passed = False
-
-    print(json.dumps({
-        'status': 'pass' if passed else 'fail',
-        'verified': verified,
-        'support_status_counts': dict(status_counts),
-        'factual_unsupported': factual_unsupported,
-        'total_factual': total_factual,
-        'unsupported_rate': round(factual_unsupported / max(total_factual, 1), 3),
-    }, indent=2))
-
-    if not passed:
-        sys.exit(1)
-
-
-def cmd_report(args: argparse.Namespace) -> None:
-    """Generate human-readable support verification report."""
-    claims_path = os.path.join(args.dir, 'claims.jsonl')
-    claims = read_jsonl(claims_path)
-
-    # Deduplicate
-    seen = set()
-    unique = []
-    for c in claims:
-        cid = c.get('claim_id')
-        if cid not in seen:
-            seen.add(cid)
-            unique.append(c)
-
-    lines = ['# Claim Support Verification Report', '']
-
-    # Summary
-    status_counts = Counter(c.get('support_status') for c in unique)
-    type_counts = Counter(c.get('claim_type') for c in unique)
-    lines.append(f'**Total claims:** {len(unique)}')
-    lines.append(f'**By type:** {dict(type_counts)}')
-    lines.append(f'**By status:** {dict(status_counts)}')
-    lines.append('')
-
-    # Unsupported factual claims (the failures)
-    unsupported_factual = [
-        c for c in unique
-        if c.get('claim_type') == 'factual' and c.get('support_status') in ('unsupported', 'needs_review')
-    ]
-    if unsupported_factual:
-        lines.append('## Unsupported/Review-needed Factual Claims')
-        lines.append('')
-        for c in unsupported_factual:
-            lines.append(f'- [{c["support_status"]}] `{c["section_id"]}`: {c["text"][:100]}...')
-            if c.get('_support_notes'):
-                lines.append(f'  Notes: {c["_support_notes"]}')
-        lines.append('')
-
-    # All clear
-    if not unsupported_factual:
-        lines.append('## All factual claims have adequate support.')
-        lines.append('')
-
-    print('\n'.join(lines))
-
-
-# ---------------------------------------------------------------------------
-# CLI entry point
-# ---------------------------------------------------------------------------
-
-def main() -> None:
-    parser = argparse.ArgumentParser(
-        prog='verify_claim_support',
-        description='Claim-support verification for deep-research v3.0',
-    )
-    sub = parser.add_subparsers(dest='command', required=True)
-
-    # verify
-    p_ver = sub.add_parser('verify', help='Verify claims against evidence')
-    p_ver.add_argument('--dir', required=True, help='Run directory')
-    p_ver.add_argument('--strict', action='store_true', help='Exit 1 if any factual claim unsupported')
-
-    # report
-    p_rep = sub.add_parser('report', help='Generate verification report')
-    p_rep.add_argument('--dir', required=True, help='Run directory')
-
-    args = parser.parse_args()
-    dispatch = {
-        'verify': cmd_verify,
-        'report': cmd_report,
-    }
-    dispatch[args.command](args)
-
-
-if __name__ == '__main__':
-    main()

package/dist/persona-defaults/persona-researcher/.claude/skills/deep-research/scripts/verify_html.py

@@ -1,220 +0,0 @@
-#!/usr/bin/env python3
-"""
-HTML Report Verification Script
-Validates that HTML reports are properly generated with all sections from MD
-"""
-
-import argparse
-import re
-from pathlib import Path
-from typing import List, Tuple
-
-
-class HTMLVerifier:
-    """Verify HTML research reports"""
-
-    def __init__(self, html_path: Path, md_path: Path):
-        self.html_path = html_path
-        self.md_path = md_path
-        self.errors = []
-        self.warnings = []
-
-    def verify(self) -> bool:
-        """
-        Run all verification checks
-
-        Returns:
-            True if all checks pass, False otherwise
-        """
-        print(f"\n{'='*60}")
-        print(f"HTML REPORT VERIFICATION")
-        print(f"{'='*60}\n")
-
-        print(f"HTML File: {self.html_path}")
-        print(f"MD File: {self.md_path}\n")
-
-        # Read files
-        try:
-            html_content = self.html_path.read_text()
-            md_content = self.md_path.read_text()
-        except Exception as e:
-            self.errors.append(f"Failed to read files: {e}")
-            return False
-
-        # Run checks
-        self._check_sections(html_content, md_content)
-        self._check_no_placeholders(html_content)
-        self._check_no_emojis(html_content)
-        self._check_structure(html_content)
-        self._check_citations(html_content, md_content)
-        self._check_bibliography(html_content, md_content)
-
-        # Report results
-        self._print_results()
-
-        return len(self.errors) == 0
-
-    def _check_sections(self, html: str, md: str):
-        """Verify all markdown sections are present in HTML"""
-        # Extract section headings from markdown
-        md_sections = re.findall(r'^## (.+)$', md, re.MULTILINE)
-
-        # Extract sections from HTML
-        html_sections = re.findall(r'<h2 class="section-title">(.+?)</h2>', html)
-
-        # Check if we have placeholder sections like <div class="section">#</div>
-        placeholder_sections = re.findall(r'<div class="section">#</div>', html)
-
-        if placeholder_sections:
-            self.errors.append(
-                f"Found {len(placeholder_sections)} placeholder sections (empty '#' divs) - content not converted properly"
-            )
-
-        # Compare section counts
-        if len(md_sections) > len(html_sections) + 1:  # +1 for bibliography which is separate
-            self.errors.append(
-                f"Section count mismatch: MD has {len(md_sections)} sections, HTML has only {len(html_sections)} + bibliography"
-            )
-            missing = set(md_sections) - set(html_sections)
-            if missing:
-                self.errors.append(f"Missing sections in HTML: {missing}")
-
-        # Verify Executive Summary is present
-        if "Executive Summary" in md and "Executive Summary" not in html:
-            self.errors.append("Executive Summary missing from HTML")
-
-    def _check_no_placeholders(self, html: str):
-        """Check for common placeholders that shouldn't be in final report"""
-        placeholders = [
-            '{{TITLE}}', '{{DATE}}', '{{CONTENT}}', '{{BIBLIOGRAPHY}}',
-            '{{METRICS_DASHBOARD}}', '{{SOURCE_COUNT}}', 'TODO', 'TBD',
-            'PLACEHOLDER', 'FIXME'
-        ]
-
-        found = []
-        for placeholder in placeholders:
-            if placeholder in html:
-                found.append(placeholder)
-
-        if found:
-            self.errors.append(f"Found unreplaced placeholders: {', '.join(found)}")
-
-    def _check_no_emojis(self, html: str):
-        """Verify no emojis are present in HTML"""
-        # Common emoji patterns
-        emoji_pattern = re.compile(
-            "["
-            "\U0001F600-\U0001F64F"  # emoticons
-            "\U0001F300-\U0001F5FF"  # symbols & pictographs
-            "\U0001F680-\U0001F6FF"  # transport & map symbols
-            "\U0001F1E0-\U0001F1FF"  # flags
-            "\U00002702-\U000027B0"
-            "\U000024C2-\U0001F251"
-            "]+",
-            flags=re.UNICODE
-        )
-
-        emojis = emoji_pattern.findall(html)
-        if emojis:
-            unique_emojis = set(emojis)
-            self.errors.append(f"Found {len(emojis)} emojis in HTML (should be none): {unique_emojis}")
-
-    def _check_structure(self, html: str):
-        """Verify HTML has proper structure"""
-        required_elements = [
-            ('<html', 'HTML tag'),
-            ('<head', 'head tag'),
-            ('<body', 'body tag'),
-            ('<title>', 'title tag'),
-            ('class="header"', 'header section'),
-            ('class="content"', 'content section'),
-            ('class="bibliography"', 'bibliography section'),
-        ]
-
-        for element, name in required_elements:
-            if element not in html:
-                self.errors.append(f"Missing {name} in HTML")
-
-        # Check for unclosed tags (basic check)
-        open_divs = html.count('<div')
-        close_divs = html.count('</div>')
-
-        if abs(open_divs - close_divs) > 2:  # Allow small discrepancy
-            self.warnings.append(
-                f"Possible unclosed divs: {open_divs} opening tags, {close_divs} closing tags"
-            )
-
-    def _check_citations(self, html: str, md: str):
-        """Verify citations are present"""
-        # Extract citations from markdown
-        md_citations = set(re.findall(r'\[(\d+)\]', md))
-
-        # Extract citations from HTML (excluding bibliography)
-        html_content = html.split('class="bibliography"')[0] if 'class="bibliography"' in html else html
-        html_citations = set(re.findall(r'\[(\d+)\]', html_content))
-
-        if len(md_citations) > 0 and len(html_citations) == 0:
-            self.errors.append("No citations found in HTML content (but present in MD)")
-
-        if len(md_citations) > len(html_citations) * 1.5:  # Allow some variation
-            self.warnings.append(
-                f"Fewer citations in HTML ({len(html_citations)}) than MD ({len(md_citations)})"
-            )
-
-    def _check_bibliography(self, html: str, md: str):
-        """Verify bibliography is present and formatted"""
-        if '## Bibliography' in md:
-            if 'class="bibliography"' not in html:
-                self.errors.append("Bibliography section missing from HTML")
-            elif 'class="bib-entry"' not in html:
-                self.warnings.append("Bibliography present but entries not properly formatted")
-
-    def _print_results(self):
-        """Print verification results"""
-        print(f"\n{'-'*60}")
-        print("VERIFICATION RESULTS")
-        print(f"{'-'*60}\n")
-
-        if self.errors:
-            print(f"❌ ERRORS ({len(self.errors)}):")
-            for i, error in enumerate(self.errors, 1):
-                print(f"  {i}. {error}")
-            print()
-
-        if self.warnings:
-            print(f"⚠️  WARNINGS ({len(self.warnings)}):")
-            for i, warning in enumerate(self.warnings, 1):
-                print(f"  {i}. {warning}")
-            print()
-
-        if not self.errors and not self.warnings:
-            print("✅ All checks passed! HTML report is valid.")
-            print()
-
-        print(f"{'-'*60}\n")
-
-
-def main():
-    """Main entry point"""
-    parser = argparse.ArgumentParser(description='Verify HTML research report')
-    parser.add_argument('--html', type=Path, required=True, help='Path to HTML report')
-    parser.add_argument('--md', type=Path, required=True, help='Path to markdown report')
-
-    args = parser.parse_args()
-
-    if not args.html.exists():
-        print(f"Error: HTML file not found: {args.html}")
-        return 1
-
-    if not args.md.exists():
-        print(f"Error: Markdown file not found: {args.md}")
-        return 1
-
-    verifier = HTMLVerifier(args.html, args.md)
-    success = verifier.verify()
-
-    return 0 if success else 1
-
-
-if __name__ == "__main__":
-    exit(main())