@clawos-dev/clawd 0.2.47-beta.71.63ae386 → 0.2.47

package/dist/persona-defaults/persona-researcher/.claude/skills/deep-research/tests/test_citation_manager.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+"""Smoke tests for citation_manager.py CLI."""
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import unittest
+
+SCRIPT = os.path.join(os.path.dirname(__file__), '..', 'scripts', 'citation_manager.py')
+
+
+def run_cm(*args: str) -> dict:
+    """Run citation_manager.py with args, return parsed JSON from stdout."""
+    result = subprocess.run(
+        [sys.executable, SCRIPT, *args],
+        capture_output=True, text=True,
+    )
+    if result.returncode != 0:
+        raise RuntimeError(f'Exit {result.returncode}: {result.stderr}')
+    return json.loads(result.stdout) if result.stdout.strip().startswith(('{', '[')) else result.stdout
+
+
+class TestInitRun(unittest.TestCase):
+    def test_creates_manifest_and_artifacts(self):
+        with tempfile.TemporaryDirectory() as d:
+            out = run_cm('init-run', '--out-dir', d, '--query', 'test question', '--mode', 'deep')
+            self.assertEqual(out['status'], 'ok')
+
+            # Manifest exists and has correct fields
+            manifest = json.load(open(os.path.join(d, 'run_manifest.json')))
+            self.assertEqual(manifest['version'], '3.0.0')
+            self.assertEqual(manifest['query'], 'test question')
+            self.assertEqual(manifest['mode'], 'deep')
+            self.assertIsNotNone(manifest['started_at'])
+            self.assertIsNone(manifest['finished_at'])
+            self.assertEqual(manifest['artifact_paths']['sources'], 'sources.jsonl')
+
+            # Empty JSONL files exist
+            for name in ('sources.jsonl', 'evidence.jsonl', 'claims.jsonl'):
+                path = os.path.join(d, name)
+                self.assertTrue(os.path.exists(path), f'{name} missing')
+                self.assertEqual(os.path.getsize(path), 0)
+
+
+class TestRegisterSource(unittest.TestCase):
+    def setUp(self):
+        self.tmpdir = tempfile.mkdtemp()
+        run_cm('init-run', '--out-dir', self.tmpdir, '--query', 'test')
+
+    def tearDown(self):
+        import shutil
+        shutil.rmtree(self.tmpdir, ignore_errors=True)
+
+    def test_register_and_dedup(self):
+        src = json.dumps({
+            'raw_url': 'https://arxiv.org/abs/2305.14251',
+            'title': 'FActScore',
+            'source_type': 'academic',
+            'year': '2023',
+        })
+        out1 = run_cm('register-source', '--json', src, '--dir', self.tmpdir)
+        self.assertEqual(out1['status'], 'registered')
+        self.assertEqual(len(out1['source_id']), 16)
+        self.assertTrue(out1['canonical_locator'].startswith('arxiv:'))
+
+        # Same URL -> duplicate
+        out2 = run_cm('register-source', '--json', src, '--dir', self.tmpdir)
+        self.assertEqual(out2['status'], 'duplicate')
+        self.assertEqual(out2['source_id'], out1['source_id'])
+
+    def test_doi_canonicalization(self):
+        src = json.dumps({
+            'raw_url': 'https://doi.org/10.1038/s41586-023-06745-9',
+            'title': 'Some Nature paper',
+        })
+        out = run_cm('register-source', '--json', src, '--dir', self.tmpdir)
+        self.assertTrue(out['canonical_locator'].startswith('doi:10.1038/'))
+
+    def test_url_normalization(self):
+        src1 = json.dumps({
+            'raw_url': 'https://Example.Com/article?utm_source=google&id=42',
+            'title': 'Test',
+        })
+        src2 = json.dumps({
+            'raw_url': 'https://example.com/article?id=42&utm_medium=email',
+            'title': 'Test duplicate',
+        })
+        out1 = run_cm('register-source', '--json', src1, '--dir', self.tmpdir)
+        out2 = run_cm('register-source', '--json', src2, '--dir', self.tmpdir)
+        # Both should resolve to same canonical locator -> same source_id
+        self.assertEqual(out1['source_id'], out2['source_id'])
+        self.assertEqual(out2['status'], 'duplicate')
+
+
+class TestAssignDisplayNumbers(unittest.TestCase):
+    def test_assigns_in_order(self):
+        with tempfile.TemporaryDirectory() as d:
+            run_cm('init-run', '--out-dir', d, '--query', 'test')
+
+            for i, url in enumerate(['https://a.com/1', 'https://b.com/2', 'https://c.com/3']):
+                run_cm('register-source', '--json', json.dumps({
+                    'raw_url': url, 'title': f'Source {i+1}',
+                }), '--dir', d)
+
+            mapping = run_cm('assign-display-numbers', '--dir', d)
+            self.assertEqual(len(mapping), 3)
+            # Values should be 1, 2, 3
+            self.assertEqual(sorted(mapping.values()), [1, 2, 3])
+
+
+class TestExportBibliography(unittest.TestCase):
+    def test_markdown_export(self):
+        with tempfile.TemporaryDirectory() as d:
+            run_cm('init-run', '--out-dir', d, '--query', 'test')
+            run_cm('register-source', '--json', json.dumps({
+                'raw_url': 'https://arxiv.org/abs/2305.14251',
+                'title': 'FActScore',
+                'authors': ['Min, S.', 'Krishna, K.'],
+                'year': '2023',
+                'source_type': 'academic',
+            }), '--dir', d)
+
+            out = run_cm('export-bibliography', '--dir', d, '--style', 'markdown')
+            self.assertIn('[1]', out)
+            self.assertIn('FActScore', out)
+            self.assertIn('Min, S. & Krishna, K.', out)
+
+    def test_json_export(self):
+        with tempfile.TemporaryDirectory() as d:
+            run_cm('init-run', '--out-dir', d, '--query', 'test')
+            run_cm('register-source', '--json', json.dumps({
+                'raw_url': 'https://example.com/paper',
+                'title': 'Test Paper',
+            }), '--dir', d)
+
+            out = run_cm('export-bibliography', '--dir', d, '--style', 'json')
+            self.assertEqual(len(out), 1)
+            self.assertEqual(out[0]['display_number'], 1)
+            self.assertEqual(out[0]['title'], 'Test Paper')
+
+
+class TestCanonicalization(unittest.TestCase):
+    """Unit tests for canonicalize_locator without running the CLI."""
+
+    @classmethod
+    def setUpClass(cls):
+        sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'scripts'))
+        from citation_manager import canonicalize_locator, compute_source_id
+        cls.canonicalize = staticmethod(canonicalize_locator)
+        cls.compute_id = staticmethod(compute_source_id)
+
+    def test_doi_from_url(self):
+        canonicalize_locator = self.canonicalize
+        self.assertEqual(
+            canonicalize_locator('https://doi.org/10.1038/s41586-023-06745-9'),
+            'doi:10.1038/s41586-023-06745-9',
+        )
+        self.assertEqual(
+            canonicalize_locator('https://dx.doi.org/10.1234/test.'),
+            'doi:10.1234/test',
+        )
+
+    def test_arxiv_from_url(self):
+        canonicalize_locator = self.canonicalize
+        self.assertEqual(
+            canonicalize_locator('https://arxiv.org/abs/2305.14251v2'),
+            'arxiv:2305.14251v2',
+        )
+        self.assertEqual(
+            canonicalize_locator('arxiv:2401.15884'),
+            'arxiv:2401.15884',
+        )
+
+    def test_url_strips_tracking(self):
+        canonicalize_locator = self.canonicalize
+        result = canonicalize_locator('https://Example.Com/page?utm_source=x&key=val')
+        self.assertNotIn('utm_source', result)
+        self.assertIn('key=val', result)
+        self.assertTrue(result.startswith('https://example.com'))
+
+    def test_url_strips_fragment(self):
+        canonicalize_locator = self.canonicalize
+        result = canonicalize_locator('https://example.com/page#section')
+        self.assertNotIn('#section', result)
+
+    def test_url_strips_trailing_slash(self):
+        canonicalize_locator = self.canonicalize
+        result = canonicalize_locator('https://example.com/page/')
+        self.assertFalse(result.endswith('/'))
+
+
+if __name__ == '__main__':
+    unittest.main()

package/dist/persona-defaults/persona-researcher/.claude/skills/deep-research/tests/test_evidence_store.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python3
+"""Smoke tests for evidence_store.py CLI."""
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import unittest
+
+SCRIPT = os.path.join(os.path.dirname(__file__), '..', 'scripts', 'evidence_store.py')
+
+
+def run_es(*args: str) -> dict | list:
+    """Run evidence_store.py with args, return parsed JSON from stdout."""
+    result = subprocess.run(
+        [sys.executable, SCRIPT, *args],
+        capture_output=True, text=True,
+    )
+    if result.returncode != 0:
+        raise RuntimeError(f'Exit {result.returncode}: {result.stderr}')
+    return json.loads(result.stdout)
+
+
+class TestInit(unittest.TestCase):
+    def test_creates_empty_file(self):
+        with tempfile.TemporaryDirectory() as d:
+            out = run_es('init', '--dir', d)
+            self.assertEqual(out['status'], 'ok')
+            path = os.path.join(d, 'evidence.jsonl')
+            self.assertTrue(os.path.exists(path))
+            self.assertEqual(os.path.getsize(path), 0)
+
+
+class TestAddEvidence(unittest.TestCase):
+    def setUp(self):
+        self.tmpdir = tempfile.mkdtemp()
+        run_es('init', '--dir', self.tmpdir)
+
+    def tearDown(self):
+        shutil.rmtree(self.tmpdir, ignore_errors=True)
+
+    def test_add_and_dedup(self):
+        ev = json.dumps({
+            'source_id': 'abcdef0123456789',
+            'quote': 'FActScore decomposes generation into atomic facts.',
+            'evidence_type': 'direct_quote',
+            'locator': 'page 3',
+            'retrieval_query': 'factuality evaluation methods',
+        })
+        out1 = run_es('add', '--json', ev, '--dir', self.tmpdir)
+        self.assertEqual(out1['status'], 'added')
+        self.assertEqual(len(out1['evidence_id']), 16)
+
+        # Same quote -> duplicate
+        out2 = run_es('add', '--json', ev, '--dir', self.tmpdir)
+        self.assertEqual(out2['status'], 'duplicate')
+        self.assertEqual(out2['evidence_id'], out1['evidence_id'])
+
+    def test_whitespace_normalization(self):
+        ev1 = json.dumps({
+            'source_id': 'abcdef0123456789',
+            'quote': '  FActScore   decomposes   generation  into atomic facts.  ',
+            'evidence_type': 'direct_quote',
+        })
+        ev2 = json.dumps({
+            'source_id': 'abcdef0123456789',
+            'quote': 'FActScore decomposes generation into atomic facts.',
+            'evidence_type': 'direct_quote',
+        })
+        out1 = run_es('add', '--json', ev1, '--dir', self.tmpdir)
+        out2 = run_es('add', '--json', ev2, '--dir', self.tmpdir)
+        # Should be same ID due to normalization
+        self.assertEqual(out1['evidence_id'], out2['evidence_id'])
+        self.assertEqual(out2['status'], 'duplicate')
+
+    def test_different_sources_different_ids(self):
+        ev1 = json.dumps({
+            'source_id': 'aaaaaaaaaaaaaaaa',
+            'quote': 'Same quote text.',
+            'evidence_type': 'paraphrase',
+        })
+        ev2 = json.dumps({
+            'source_id': 'bbbbbbbbbbbbbbbb',
+            'quote': 'Same quote text.',
+            'evidence_type': 'paraphrase',
+        })
+        out1 = run_es('add', '--json', ev1, '--dir', self.tmpdir)
+        out2 = run_es('add', '--json', ev2, '--dir', self.tmpdir)
+        self.assertNotEqual(out1['evidence_id'], out2['evidence_id'])
+        self.assertEqual(out2['status'], 'added')
+
+
+class TestListAndExport(unittest.TestCase):
+    def setUp(self):
+        self.tmpdir = tempfile.mkdtemp()
+        run_es('init', '--dir', self.tmpdir)
+        # Add 3 evidence items from 2 sources
+        for src, quote in [
+            ('src_aaa', 'First quote from source A.'),
+            ('src_aaa', 'Second quote from source A.'),
+            ('src_bbb', 'Quote from source B.'),
+        ]:
+            run_es('add', '--json', json.dumps({
+                'source_id': src,
+                'quote': quote,
+                'evidence_type': 'direct_quote',
+            }), '--dir', self.tmpdir)
+
+    def tearDown(self):
+        shutil.rmtree(self.tmpdir, ignore_errors=True)
+
+    def test_list_all(self):
+        out = run_es('list', '--dir', self.tmpdir)
+        self.assertEqual(out['count'], 3)
+
+    def test_list_filtered(self):
+        out = run_es('list', '--dir', self.tmpdir, '--source-id', 'src_aaa')
+        self.assertEqual(out['count'], 2)
+
+        out = run_es('list', '--dir', self.tmpdir, '--source-id', 'src_bbb')
+        self.assertEqual(out['count'], 1)
+
+    def test_export(self):
+        out = run_es('export', '--dir', self.tmpdir)
+        self.assertIsInstance(out, list)
+        self.assertEqual(len(out), 3)
+        # Each has required fields
+        for row in out:
+            self.assertIn('evidence_id', row)
+            self.assertIn('source_id', row)
+            self.assertIn('quote', row)
+            self.assertIn('evidence_type', row)
+            self.assertIn('captured_at', row)
+
+
+class TestEvidenceID(unittest.TestCase):
+    """Unit tests for compute_evidence_id."""
+
+    @classmethod
+    def setUpClass(cls):
+        sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'scripts'))
+        from evidence_store import compute_evidence_id, normalize_quote
+        cls.compute_id = staticmethod(compute_evidence_id)
+        cls.normalize = staticmethod(normalize_quote)
+
+    def test_deterministic(self):
+        id1 = self.compute_id('src_a', 'test quote', 'page 1')
+        id2 = self.compute_id('src_a', 'test quote', 'page 1')
+        self.assertEqual(id1, id2)
+
+    def test_locator_matters(self):
+        id1 = self.compute_id('src_a', 'test quote', 'page 1')
+        id2 = self.compute_id('src_a', 'test quote', 'page 2')
+        self.assertNotEqual(id1, id2)
+
+    def test_normalize_whitespace(self):
+        self.assertEqual(
+            self.normalize('  hello   world  '),
+            'hello world',
+        )
+
+
+if __name__ == '__main__':
+    unittest.main()

package/dist/persona-defaults/persona-researcher/.claude/skills/deep-research/tests/test_extract_claims.py

@@ -0,0 +1,213 @@
+#!/usr/bin/env python3
+"""Tests for extract_claims.py CLI."""
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import unittest
+
+SCRIPT = os.path.join(os.path.dirname(__file__), '..', 'scripts', 'extract_claims.py')
+FIXTURES = os.path.join(os.path.dirname(__file__), 'fixtures')
+
+
+def run_ec(*args: str) -> dict | list:
+    """Run extract_claims.py with args."""
+    result = subprocess.run(
+        [sys.executable, SCRIPT, *args],
+        capture_output=True, text=True,
+    )
+    if result.returncode != 0:
+        raise RuntimeError(f'Exit {result.returncode}: {result.stderr}')
+    return json.loads(result.stdout)
+
+
+SAMPLE_REPORT = """\
+---
+title: Test Research Report
+---
+
+## Executive Summary
+
+This report examines the impact of quantum computing on cryptography [1, 2]. The field has advanced significantly since 2020, with major breakthroughs in error correction.
+
+## Introduction
+
+Quantum computing represents a paradigm shift in computational capability. Researchers at Google demonstrated quantum supremacy in 2019 using a 53-qubit processor [3]. This milestone confirmed theoretical predictions made decades earlier.
+
+## Finding 1
+
+The Shor algorithm can factor large numbers exponentially faster than classical methods [4]. Current RSA-2048 encryption could be broken by a sufficiently large quantum computer. However, such machines are estimated to require millions of physical qubits [5, 6].
+
+## Finding 2
+
+Post-quantum cryptography standards should be adopted within the next 5 years. Organizations should consider hybrid classical-quantum approaches during the transition period. NIST has already standardized several lattice-based algorithms [7].
+
+## Synthesis
+
+Taken together, the evidence suggests that quantum computing poses a real but manageable threat to current cryptographic systems. The timeline for practical quantum attacks remains uncertain, but proactive migration reduces risk substantially.
+
+## Recommendations
+
+Organizations should begin evaluating post-quantum cryptography solutions immediately. Security teams should conduct a cryptographic inventory to identify vulnerable systems. Companies should consider implementing crypto-agility frameworks to enable rapid algorithm switching.
+
+## Bibliography
+
+[1] Smith et al. (2023). Quantum Computing Advances.
+[2] Johnson (2024). Cryptographic Implications.
+"""
+
+
+class TestExtract(unittest.TestCase):
+    def setUp(self):
+        self.tmpdir = tempfile.mkdtemp()
+        # Create empty claims.jsonl
+        open(os.path.join(self.tmpdir, 'claims.jsonl'), 'w').close()
+        # Write sample report
+        self.report_path = os.path.join(self.tmpdir, 'report.md')
+        with open(self.report_path, 'w') as f:
+            f.write(SAMPLE_REPORT)
+
+    def tearDown(self):
+        shutil.rmtree(self.tmpdir, ignore_errors=True)
+
+    def test_extract_finds_claims(self):
+        out = run_ec('extract', '--report', self.report_path, '--dir', self.tmpdir)
+        self.assertEqual(out['status'], 'ok')
+        self.assertGreater(out['claims_added'], 5)
+
+    def test_extract_idempotent(self):
+        out1 = run_ec('extract', '--report', self.report_path, '--dir', self.tmpdir)
+        out2 = run_ec('extract', '--report', self.report_path, '--dir', self.tmpdir)
+        self.assertEqual(out2['claims_added'], 0)
+        self.assertEqual(out2['claims_skipped'], out1['claims_added'])
+
+    def test_claim_types_assigned(self):
+        run_ec('extract', '--report', self.report_path, '--dir', self.tmpdir)
+        out = run_ec('stats', '--dir', self.tmpdir)
+        # Should have at least factual and recommendation types
+        self.assertIn('factual', out['by_type'])
+        self.assertIn('recommendation', out['by_type'])
+
+    def test_sections_detected(self):
+        run_ec('extract', '--report', self.report_path, '--dir', self.tmpdir)
+        out = run_ec('stats', '--dir', self.tmpdir)
+        self.assertIn('finding_1', out['by_section'])
+        self.assertIn('finding_2', out['by_section'])
+        self.assertIn('recommendations', out['by_section'])
+
+
+class TestAdd(unittest.TestCase):
+    def setUp(self):
+        self.tmpdir = tempfile.mkdtemp()
+        open(os.path.join(self.tmpdir, 'claims.jsonl'), 'w').close()
+
+    def tearDown(self):
+        shutil.rmtree(self.tmpdir, ignore_errors=True)
+
+    def test_add_and_dedup(self):
+        claim = json.dumps({
+            'section_id': 'finding_1',
+            'text': 'Quantum computers can break RSA encryption.',
+            'claim_type': 'factual',
+        })
+        out1 = run_ec('add', '--json', claim, '--dir', self.tmpdir)
+        self.assertEqual(out1['status'], 'added')
+        self.assertEqual(len(out1['claim_id']), 16)
+
+        out2 = run_ec('add', '--json', claim, '--dir', self.tmpdir)
+        self.assertEqual(out2['status'], 'duplicate')
+
+    def test_add_with_sources(self):
+        claim = json.dumps({
+            'section_id': 'finding_1',
+            'text': 'NIST standardized CRYSTALS-Kyber in 2024.',
+            'claim_type': 'factual',
+            'cited_source_ids': ['abcdef0123456789'],
+            'evidence_ids': ['1234567890abcdef'],
+        })
+        out = run_ec('add', '--json', claim, '--dir', self.tmpdir)
+        self.assertEqual(out['status'], 'added')
+
+
+class TestListAndStats(unittest.TestCase):
+    def setUp(self):
+        self.tmpdir = tempfile.mkdtemp()
+        open(os.path.join(self.tmpdir, 'claims.jsonl'), 'w').close()
+        # Add mixed claims
+        for sec, text, ctype in [
+            ('finding_1', 'The sky appears blue due to Rayleigh scattering.', 'factual'),
+            ('finding_1', 'Light wavelengths scatter differently in the atmosphere.', 'factual'),
+            ('synthesis', 'Overall, atmospheric optics explains most visual phenomena.', 'synthesis'),
+            ('recommendations', 'Researchers should investigate polarization effects further.', 'recommendation'),
+        ]:
+            run_ec('add', '--json', json.dumps({
+                'section_id': sec, 'text': text, 'claim_type': ctype,
+            }), '--dir', self.tmpdir)
+
+    def tearDown(self):
+        shutil.rmtree(self.tmpdir, ignore_errors=True)
+
+    def test_list_all(self):
+        out = run_ec('list', '--dir', self.tmpdir)
+        self.assertEqual(out['count'], 4)
+
+    def test_list_by_section(self):
+        out = run_ec('list', '--dir', self.tmpdir, '--section', 'finding_1')
+        self.assertEqual(out['count'], 2)
+
+    def test_list_by_type(self):
+        out = run_ec('list', '--dir', self.tmpdir, '--type', 'recommendation')
+        self.assertEqual(out['count'], 1)
+
+    def test_stats(self):
+        out = run_ec('stats', '--dir', self.tmpdir)
+        self.assertEqual(out['total'], 4)
+        self.assertEqual(out['by_type']['factual'], 2)
+        self.assertEqual(out['by_type']['synthesis'], 1)
+        self.assertEqual(out['by_type']['recommendation'], 1)
+
+
+class TestClaimID(unittest.TestCase):
+    """Unit tests for compute_claim_id."""
+
+    @classmethod
+    def setUpClass(cls):
+        sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'scripts'))
+        from extract_claims import compute_claim_id, classify_claim
+        cls.compute_id = staticmethod(compute_claim_id)
+        cls.classify = staticmethod(classify_claim)
+
+    def test_deterministic(self):
+        id1 = self.compute_id('finding_1', 'Test claim.')
+        id2 = self.compute_id('finding_1', 'Test claim.')
+        self.assertEqual(id1, id2)
+
+    def test_section_matters(self):
+        id1 = self.compute_id('finding_1', 'Same text.')
+        id2 = self.compute_id('finding_2', 'Same text.')
+        self.assertNotEqual(id1, id2)
+
+    def test_classify_recommendation(self):
+        self.assertEqual(
+            self.classify('Organizations should adopt PQC immediately.', 'recommendations'),
+            'recommendation',
+        )
+
+    def test_classify_factual(self):
+        self.assertEqual(
+            self.classify('RSA-2048 uses 2048-bit keys.', 'finding_1'),
+            'factual',
+        )
+
+    def test_classify_synthesis(self):
+        self.assertEqual(
+            self.classify('Taken together, the results indicate a clear trend.', 'synthesis'),
+            'synthesis',
+        )
+
+
+if __name__ == '__main__':
+    unittest.main()