zotvault 0.9.1__tar.gz

zotvault-0.9.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jongmin Baek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

zotvault-0.9.1/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: zotvault
+Version: 0.9.1
+Summary: Local-first paper pipeline orchestrator between Zotero and Obsidian: detect, note, fetch PDF, queue AI analysis, index.
+Author: Jongmin Baek
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/jbaek-dev/ZotVault
+Project-URL: Changelog, https://github.com/jbaek-dev/ZotVault/blob/main/CHANGELOG.md
+Keywords: zotero,obsidian,papers,research,pkm,local-first
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: MacOS
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: tray
+Requires-Dist: pystray>=0.19; extra == "tray"
+Requires-Dist: Pillow>=9; extra == "tray"
+Dynamic: license-file
+
+# ZotVault
+
+**Local-first paper pipeline orchestrator between [Zotero](https://www.zotero.org/) and [Obsidian](https://obsidian.md/).**
+
+ZotVault watches your Zotero library and, for every new paper, automatically: creates an Obsidian note, secures a PDF (open-access first, politely rate-limited), puts the paper on an AI-analysis queue, and keeps your vault's index current. Around that core loop it adds one-shot DOI/arXiv adding, paper search, a local dashboard, arXiv keyword alerts, an in-library citation graph, embedding-based related-paper suggestions, and synthesis-cluster proposals.
+
+Everything runs on your machine. No cloud accounts required, no API keys required for the core loop, **zero runtime dependencies** (Python ≥ 3.9 standard library only).
+
+```
+[search]                       [collect]                [archive]           [wiki]
+arXiv / S2 / Crossref  ──▶  dashboard / CLI / agent ──▶  Zotero (BBT)  ──▶  Obsidian vault
+        ▲                        │ you approve             │ sqlite poll        │
+        └── arXiv alert inbox ───┘                         ▼                    ▼
+                                            daemon: note → PDF (OA→proxy) → queue → index
+                                                     + citation graph · related · synthesis
+```
+
+## Features
+
+- **One-shot add** — `zotvault add 10.1103/PhysRevB.1.1 arXiv:2405.01234`: metadata via Crossref/DataCite/arXiv → straight into Zotero through the same local channel the browser connector uses — including the OA PDF when one exists (Zotero downloads it itself, like the browser connector). Duplicates are detected before saving; a pipeline cycle runs immediately after the add. Optional [translation-server](https://github.com/zotero/translation-server) support for arbitrary URL imports.
+- **Automatic wiki-fication** — new Zotero items become Obsidian notes (template-compatible, atomic writes). Existing notes are **never rewritten**; your manual sections are structurally safe.
+- **Edit-safe highlight sync** — Zotero PDF highlights land in ONE marker-delimited block per note (grouped by color, deep links back to the exact annotation), kept in sync incl. deletions. Figure/area annotations are embedded as images (copied from Zotero's cache). Color groups can be renamed to *your* semantics (`label_red = "Core Claims"`). Everything outside the block is untouchable; unmarked legacy notes are opt-in (`[annotations] adopt_existing`). See [docs/MIGRATION.md](docs/MIGRATION.md).
+- **PDF resolution, politely** — Zotero attachment → cache → arXiv → Unpaywall → (opt-in) institutional proxy with browser-session cookies. Sequential, delayed, daily-capped: designed to *not* get your campus blocked. See [docs/PROXY.md](docs/PROXY.md).
+- **AI-analysis queue** — ZotVault doesn't run an LLM; it feeds yours. `zotvault queue --json` lists unanalyzed papers with readable PDF paths; when your agent (e.g. Claude batch) writes `*_analysis.md`, completion is auto-detected.
+- **Dashboard** — `zotvault web` → http://127.0.0.1:8377 : search → tick → add, queue, alerts inbox, suggestions, audit trail. Localhost only.
+- **arXiv alerts** — daily keyword digest into a review inbox. Nothing enters Zotero without your click (propose, don't execute).
+- **Alert triage (assist)** — optionally, a *small* local Ollama model scores inbox candidates 0–10 for relevance under a strict JSON contract (constrained decoding + validation + one retry); the dashboard sorts by score. Advisory only, off by default.
+- **Citation graph** — Semantic Scholar citation counts + who-cites-whom *within your library*, regenerated into `Citation_Graph.md`.
+- **Related papers** — local [Ollama](https://ollama.com) embeddings over your analysis notes → `Related_Suggestions.md` link candidates. Free, offline.
+- **Synthesis suggestions** — clusters analyzed-but-unsynthesized papers into proposed review topics.
+- **Auditable** — every automatic action lands in a SQLite trace (`zotvault trace`).
+
+## Requirements
+
+- Python ≥ 3.9 (CLI is cross-platform; the double-click app + `install-daemon` autostart are macOS today)
+- Zotero desktop with **[Better BibTeX](https://retorque.re/zotero-better-bibtex/)** — **required**: it is ZotVault's citekey source. Without it, items can't be named and nothing syncs (ZotVault will mark them `blocked` and tell you).
+- An Obsidian vault (any folder). ZotVault writes per-paper notes under `<papers_subdir>/<citekey>/` — configure the paths; it does not impose a vault structure.
+- Optional: `pdftotext` (poppler) for full-text AI analysis, Ollama (related papers / local analysis), an institutional web proxy for licensed PDFs.
+
+## Quick start
+
+```bash
+git clone https://github.com/jbaek-dev/ZotVault && cd ZotVault
+pip install .                          # or: pipx install .   /   uv tool install .
+zotvault init                          # writes ~/.zotvault/config.toml
+# edit: [vault] dir, [pdf] unpaywall_email  (+ [alerts] keywords if you want digests)
+zotvault doctor                        # verifies Zotero, Better BibTeX, vault paths
+zotvault run-once --dry-run
+zotvault run-once
+```
+
+**Run it continuously.** Two options on every platform:
+
+- **System tray** (recommended): `pip install ".[tray]"` then `zotvault tray` — daemon + tray icon with Open Dashboard / Run now / Pause / Quit. The only third-party packages ZotVault can use, and only if you opt in.
+- **OS service:** `zotvault install-daemon` — macOS writes a launchd plist, Linux writes a systemd user unit, Windows prints the Task Scheduler command. Never auto-loads; it tells you the enable command.
+
+macOS extra: double-click ZotVault.app (`bash scripts/build_app.sh`).
+
+Every command also works without installing, via `python3 -m zotvault.cli <cmd>`.
+
+## Commands
+
+| command | what it does |
+|---|---|
+| `init` / `doctor` | config file / environment health check |
+| `run-once [--dry-run]` / `daemon` | one cycle / poll loop (+dashboard thread) |
+| `install-daemon` | autostart: launchd plist (macOS) / systemd unit (Linux) / schtasks cmd (Windows) |
+| `tray` | daemon + system-tray icon (needs `pip install ".[tray]"`) |
+| `add <ids…> [--dry-run]` | resolve DOI/arXiv/URL → save to Zotero |
+| `search <query> [--source arxiv\|s2\|crossref]` | search with in-library marks |
+| `web` | dashboard server in the foreground |
+| `queue [--json]` | papers awaiting AI analysis |
+| `alerts [--fetch\|--approve N\|--dismiss N]` | arXiv digest inbox |
+| `enrich [--limit N]` | citation graph + embeddings + suggestion notes |
+| `assist [--limit N]` | score pending alerts with the small local model |
+| `related <citekey>` / `synthesis [--write]` | similarity / cluster proposals |
+| `status` / `trace [--limit N]` | state summary / audit trail |
+
+## Design guarantees
+
+- **Read-only toward Zotero's data.** Library reads use a temp snapshot of `zotero.sqlite`; adds go through Zotero's own connector endpoint (Zotero writes its DB itself). ZotVault never touches `storage/`; downloaded PDFs live in `~/.zotvault/pdfs/`.
+- **Vault safety.** Existing notes are never rewritten; auto-notes (`Citation_Graph.md`, `Related_Suggestions.md`, `_Synthesis_Suggestions.md`) are clearly marked and ZotVault-owned; index.md is only patched via a strict counter regex; log.md is append-only; `--dry-run` previews; no delete code path exists.
+- **Polite networking.** OA-first, sequential fetches, delays, hard daily caps (separate, stricter cap for the proxy), honest User-Agent, backs off on HTTP 429.
+- **Nothing personal in code.** All user-specific values live in `~/.zotvault/config.toml`.
+
+## Agent integration
+
+Any agent can drive ZotVault through the localhost API (`/api/search`, `/api/add`, `/api/queue`, `/api/status`). A ready-made tool module for the Polaris local agent (not yet public) lives in that repo (`polaris/tools/zotvault_tools.py`): search results show up with in-library marks, and adding requires the user to have explicitly picked papers.
+
+## Tests
+
+```bash
+python3 -m unittest discover -s tests -v   # 101 tests, no network needed
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE). Changelog in [CHANGELOG.md](CHANGELOG.md).

zotvault-0.9.1/README.md

@@ -0,0 +1,98 @@
+# ZotVault
+
+**Local-first paper pipeline orchestrator between [Zotero](https://www.zotero.org/) and [Obsidian](https://obsidian.md/).**
+
+ZotVault watches your Zotero library and, for every new paper, automatically: creates an Obsidian note, secures a PDF (open-access first, politely rate-limited), puts the paper on an AI-analysis queue, and keeps your vault's index current. Around that core loop it adds one-shot DOI/arXiv adding, paper search, a local dashboard, arXiv keyword alerts, an in-library citation graph, embedding-based related-paper suggestions, and synthesis-cluster proposals.
+
+Everything runs on your machine. No cloud accounts required, no API keys required for the core loop, **zero runtime dependencies** (Python ≥ 3.9 standard library only).
+
+```
+[search]                       [collect]                [archive]           [wiki]
+arXiv / S2 / Crossref  ──▶  dashboard / CLI / agent ──▶  Zotero (BBT)  ──▶  Obsidian vault
+        ▲                        │ you approve             │ sqlite poll        │
+        └── arXiv alert inbox ───┘                         ▼                    ▼
+                                            daemon: note → PDF (OA→proxy) → queue → index
+                                                     + citation graph · related · synthesis
+```
+
+## Features
+
+- **One-shot add** — `zotvault add 10.1103/PhysRevB.1.1 arXiv:2405.01234`: metadata via Crossref/DataCite/arXiv → straight into Zotero through the same local channel the browser connector uses — including the OA PDF when one exists (Zotero downloads it itself, like the browser connector). Duplicates are detected before saving; a pipeline cycle runs immediately after the add. Optional [translation-server](https://github.com/zotero/translation-server) support for arbitrary URL imports.
+- **Automatic wiki-fication** — new Zotero items become Obsidian notes (template-compatible, atomic writes). Existing notes are **never rewritten**; your manual sections are structurally safe.
+- **Edit-safe highlight sync** — Zotero PDF highlights land in ONE marker-delimited block per note (grouped by color, deep links back to the exact annotation), kept in sync incl. deletions. Figure/area annotations are embedded as images (copied from Zotero's cache). Color groups can be renamed to *your* semantics (`label_red = "Core Claims"`). Everything outside the block is untouchable; unmarked legacy notes are opt-in (`[annotations] adopt_existing`). See [docs/MIGRATION.md](docs/MIGRATION.md).
+- **PDF resolution, politely** — Zotero attachment → cache → arXiv → Unpaywall → (opt-in) institutional proxy with browser-session cookies. Sequential, delayed, daily-capped: designed to *not* get your campus blocked. See [docs/PROXY.md](docs/PROXY.md).
+- **AI-analysis queue** — ZotVault doesn't run an LLM; it feeds yours. `zotvault queue --json` lists unanalyzed papers with readable PDF paths; when your agent (e.g. Claude batch) writes `*_analysis.md`, completion is auto-detected.
+- **Dashboard** — `zotvault web` → http://127.0.0.1:8377 : search → tick → add, queue, alerts inbox, suggestions, audit trail. Localhost only.
+- **arXiv alerts** — daily keyword digest into a review inbox. Nothing enters Zotero without your click (propose, don't execute).
+- **Alert triage (assist)** — optionally, a *small* local Ollama model scores inbox candidates 0–10 for relevance under a strict JSON contract (constrained decoding + validation + one retry); the dashboard sorts by score. Advisory only, off by default.
+- **Citation graph** — Semantic Scholar citation counts + who-cites-whom *within your library*, regenerated into `Citation_Graph.md`.
+- **Related papers** — local [Ollama](https://ollama.com) embeddings over your analysis notes → `Related_Suggestions.md` link candidates. Free, offline.
+- **Synthesis suggestions** — clusters analyzed-but-unsynthesized papers into proposed review topics.
+- **Auditable** — every automatic action lands in a SQLite trace (`zotvault trace`).
+
+## Requirements
+
+- Python ≥ 3.9 (CLI is cross-platform; the double-click app + `install-daemon` autostart are macOS today)
+- Zotero desktop with **[Better BibTeX](https://retorque.re/zotero-better-bibtex/)** — **required**: it is ZotVault's citekey source. Without it, items can't be named and nothing syncs (ZotVault will mark them `blocked` and tell you).
+- An Obsidian vault (any folder). ZotVault writes per-paper notes under `<papers_subdir>/<citekey>/` — configure the paths; it does not impose a vault structure.
+- Optional: `pdftotext` (poppler) for full-text AI analysis, Ollama (related papers / local analysis), an institutional web proxy for licensed PDFs.
+
+## Quick start
+
+```bash
+git clone https://github.com/jbaek-dev/ZotVault && cd ZotVault
+pip install .                          # or: pipx install .   /   uv tool install .
+zotvault init                          # writes ~/.zotvault/config.toml
+# edit: [vault] dir, [pdf] unpaywall_email  (+ [alerts] keywords if you want digests)
+zotvault doctor                        # verifies Zotero, Better BibTeX, vault paths
+zotvault run-once --dry-run
+zotvault run-once
+```
+
+**Run it continuously.** Two options on every platform:
+
+- **System tray** (recommended): `pip install ".[tray]"` then `zotvault tray` — daemon + tray icon with Open Dashboard / Run now / Pause / Quit. The only third-party packages ZotVault can use, and only if you opt in.
+- **OS service:** `zotvault install-daemon` — macOS writes a launchd plist, Linux writes a systemd user unit, Windows prints the Task Scheduler command. Never auto-loads; it tells you the enable command.
+
+macOS extra: double-click ZotVault.app (`bash scripts/build_app.sh`).
+
+Every command also works without installing, via `python3 -m zotvault.cli <cmd>`.
+
+## Commands
+
+| command | what it does |
+|---|---|
+| `init` / `doctor` | config file / environment health check |
+| `run-once [--dry-run]` / `daemon` | one cycle / poll loop (+dashboard thread) |
+| `install-daemon` | autostart: launchd plist (macOS) / systemd unit (Linux) / schtasks cmd (Windows) |
+| `tray` | daemon + system-tray icon (needs `pip install ".[tray]"`) |
+| `add <ids…> [--dry-run]` | resolve DOI/arXiv/URL → save to Zotero |
+| `search <query> [--source arxiv\|s2\|crossref]` | search with in-library marks |
+| `web` | dashboard server in the foreground |
+| `queue [--json]` | papers awaiting AI analysis |
+| `alerts [--fetch\|--approve N\|--dismiss N]` | arXiv digest inbox |
+| `enrich [--limit N]` | citation graph + embeddings + suggestion notes |
+| `assist [--limit N]` | score pending alerts with the small local model |
+| `related <citekey>` / `synthesis [--write]` | similarity / cluster proposals |
+| `status` / `trace [--limit N]` | state summary / audit trail |
+
+## Design guarantees
+
+- **Read-only toward Zotero's data.** Library reads use a temp snapshot of `zotero.sqlite`; adds go through Zotero's own connector endpoint (Zotero writes its DB itself). ZotVault never touches `storage/`; downloaded PDFs live in `~/.zotvault/pdfs/`.
+- **Vault safety.** Existing notes are never rewritten; auto-notes (`Citation_Graph.md`, `Related_Suggestions.md`, `_Synthesis_Suggestions.md`) are clearly marked and ZotVault-owned; index.md is only patched via a strict counter regex; log.md is append-only; `--dry-run` previews; no delete code path exists.
+- **Polite networking.** OA-first, sequential fetches, delays, hard daily caps (separate, stricter cap for the proxy), honest User-Agent, backs off on HTTP 429.
+- **Nothing personal in code.** All user-specific values live in `~/.zotvault/config.toml`.
+
+## Agent integration
+
+Any agent can drive ZotVault through the localhost API (`/api/search`, `/api/add`, `/api/queue`, `/api/status`). A ready-made tool module for the Polaris local agent (not yet public) lives in that repo (`polaris/tools/zotvault_tools.py`): search results show up with in-library marks, and adding requires the user to have explicitly picked papers.
+
+## Tests
+
+```bash
+python3 -m unittest discover -s tests -v   # 101 tests, no network needed
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE). Changelog in [CHANGELOG.md](CHANGELOG.md).

zotvault-0.9.1/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "zotvault"
+version = "0.9.1"
+description = "Local-first paper pipeline orchestrator between Zotero and Obsidian: detect, note, fetch PDF, queue AI analysis, index."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Jongmin Baek" }]
+keywords = ["zotero", "obsidian", "papers", "research", "pkm", "local-first"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: MacOS",
+    "Topic :: Scientific/Engineering",
+]
+
+[project.urls]
+Homepage = "https://github.com/jbaek-dev/ZotVault"
+Changelog = "https://github.com/jbaek-dev/ZotVault/blob/main/CHANGELOG.md"
+
+[project.optional-dependencies]
+tray = ["pystray>=0.19", "Pillow>=9"]
+
+[project.scripts]
+zotvault = "zotvault.cli:main"
+
+[tool.setuptools]
+packages = ["zotvault"]
+
+[tool.setuptools.package-data]
+zotvault = ["static/*.html"]

zotvault-0.9.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

zotvault-0.9.1/tests/test_alerts.py

@@ -0,0 +1,57 @@
+import tempfile
+import unittest
+from pathlib import Path
+
+from zotvault.alerts import store_entries
+from zotvault.state import State
+
+
+def entry(aid, published="2026-07-04", title="T"):
+    return {"arxiv_id": aid, "title": title, "summary": "s", "published": published,
+            "authors": ["A B"], "doi": "", "pdf_url": "", "categories": []}
+
+
+class TestAlerts(unittest.TestCase):
+    def setUp(self):
+        self.td = tempfile.TemporaryDirectory()
+        self.state = State(Path(self.td.name) / "s.db")
+
+    def tearDown(self):
+        self.state.close()
+        self.td.cleanup()
+
+    def test_store_dedupe_cutoff_library(self):
+        self.state.upsert_item(1, item_key="K", citekey="InLib2026", arxiv_id="2406.00001")
+        seen = self.state.alert_seen_ids()
+        lib = self.state.arxiv_map()
+        entries = [
+            entry("2407.00001v1"),                      # new -> stored
+            entry("2407.00001v2"),                      # same base id -> skipped
+            entry("2406.00001"),                        # already in library -> skipped
+            entry("2401.00009", published="2026-01-01"),  # too old -> skipped
+        ]
+        added = store_entries(entries, "valleytronics", "cond-mat.mes-hall",
+                              cutoff="2026-07-01", seen=seen, in_library=lib,
+                              state=self.state)
+        self.assertEqual(added, 1)
+        rows = self.state.alerts_list("pending")
+        self.assertEqual(len(rows), 1)
+        self.assertEqual(rows[0]["arxiv_id"], "2407.00001")
+        self.assertIn("valleytronics", rows[0]["matched"])
+        # second fetch: no duplicates
+        added2 = store_entries([entry("2407.00001v3")], "kw", "",
+                               cutoff="2026-07-01", seen=self.state.alert_seen_ids(),
+                               in_library=lib, state=self.state)
+        self.assertEqual(added2, 0)
+
+    def test_status_flow(self):
+        store_entries([entry("2407.11111")], "kw", "", "2026-07-01",
+                      set(), {}, self.state)
+        row = self.state.alerts_list("pending")[0]
+        self.state.alert_set_status(row["id"], "dismissed")
+        self.assertEqual(self.state.alerts_list("pending"), [])
+        self.assertEqual(len(self.state.alerts_list("dismissed")), 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

zotvault-0.9.1/tests/test_analysis_queue.py

@@ -0,0 +1,51 @@
+import tempfile
+import unittest
+from pathlib import Path
+
+from zotvault import analysis_queue
+
+
+def make_vault(td: Path):
+    papers = td / "30_Resources" / "Papers" / "zotero"
+    a = papers / "Kim2026"
+    a.mkdir(parents=True)
+    (a / "Kim2026.md").write_text("note", encoding="utf-8")
+    (a / "Kim2026_claude_analysis.md").write_text("analysis", encoding="utf-8")
+    b = papers / "Lee2025"
+    b.mkdir(parents=True)
+    (b / "Lee2025.md").write_text("note", encoding="utf-8")
+    c = papers / "Park2024"
+    c.mkdir(parents=True)  # folder without note (edge case)
+    return papers
+
+
+class TestQueue(unittest.TestCase):
+    def test_scan_pending_progress(self):
+        with tempfile.TemporaryDirectory() as td:
+            papers = make_vault(Path(td))
+            entries = analysis_queue.scan(papers)
+            self.assertEqual(len(entries), 3)
+            by_key = {e.citekey: e for e in entries}
+            self.assertTrue(by_key["Kim2026"].analyzed)
+            self.assertFalse(by_key["Lee2025"].analyzed)
+            self.assertTrue(by_key["Lee2025"].has_note)
+            self.assertFalse(by_key["Park2024"].has_note)
+            pend = analysis_queue.pending(papers)
+            self.assertEqual({e.citekey for e in pend}, {"Lee2025", "Park2024"})
+            self.assertEqual(analysis_queue.progress(papers), (1, 3))
+
+    def test_analysis_file_for(self):
+        with tempfile.TemporaryDirectory() as td:
+            papers = make_vault(Path(td))
+            hit = analysis_queue.analysis_file_for(papers, "Kim2026")
+            self.assertIsNotNone(hit)
+            self.assertTrue(hit.name.endswith("_claude_analysis.md"))
+            self.assertIsNone(analysis_queue.analysis_file_for(papers, "Lee2025"))
+            self.assertIsNone(analysis_queue.analysis_file_for(papers, "Nope2000"))
+
+    def test_missing_dir(self):
+        self.assertEqual(analysis_queue.scan(Path("/nonexistent/papers")), [])
+
+
+if __name__ == "__main__":
+    unittest.main()

zotvault-0.9.1/tests/test_analyze.py

@@ -0,0 +1,137 @@
+import tempfile
+import unittest
+from pathlib import Path
+from unittest import mock
+
+from zotvault import analyze
+from zotvault.config import Config
+from zotvault.state import State
+
+
+def make_cfg(td: Path, engine: str = "ollama", model: str = "testmodel") -> Config:
+    cfg = Config()
+    cfg.vault_dir = td
+    cfg.state_db = td / "state.db"
+    cfg.pdf_dir = td / "pdfs"
+    cfg.analysis_engine = engine
+    cfg.analysis_model = model
+    cfg.analysis_daily_limit = 2
+    return cfg
+
+
+def make_paper(papers: Path, citekey: str, with_analysis: bool = False) -> Path:
+    folder = papers / citekey
+    folder.mkdir(parents=True, exist_ok=True)
+    (folder / (citekey + ".md")).write_text(
+        '---\ntitle: "T"\nauthors: "A"\nyear: "2024"\n---\n\n'
+        "## 📄 Abstract\nThis paper studies things in detail and reports results.\n\n---\n",
+        encoding="utf-8")
+    if with_analysis:
+        (folder / (citekey + "_claude_analysis.md")).write_text("x", encoding="utf-8")
+    return folder
+
+
+LONG_BODY = "## 🧠 Core Summary (neutral)\n" + ("Solid neutral sentences. " * 20)
+
+
+class TestHelpers(unittest.TestCase):
+    def test_engine_suffix_defaults(self):
+        cfg = Config()
+        for engine, want in (("claude-cli", "claude"), ("anthropic", "claude"),
+                             ("ollama", "ollama"), ("openai-compatible", "ai")):
+            cfg.analysis_engine = engine
+            cfg.analysis_suffix = ""
+            self.assertEqual(analyze.engine_suffix(cfg), want)
+        cfg.analysis_suffix = "custom"
+        self.assertEqual(analyze.engine_suffix(cfg), "custom")
+
+    def test_prompt_build_and_wrap(self):
+        cfg = Config()
+        cfg.analysis_engine = "ollama"
+        cfg.analysis_model = "m1"
+        prompt = analyze.build_prompt(
+            {"title": "T", "authors": "A", "year": "2024", "journal": "J",
+             "doi": "10.1/x", "citekey": "K2024"},
+            "FULLTEXT HERE", "full-text", cfg)
+        self.assertIn("Title: T", prompt)
+        self.assertIn("FULLTEXT HERE", prompt)
+        note = analyze.wrap_note("## body", "K2024", "full-text", cfg)
+        self.assertIn("type: ai_analysis", note)
+        self.assertIn("source: ollama:m1", note)
+        self.assertIn('citekey: "K2024"', note)
+        self.assertIn('input_basis: "full-text"', note)
+        self.assertIn("immutable: true", note)
+
+    def test_generate_dispatch_none(self):
+        cfg = Config()
+        with self.assertRaises(ValueError):
+            analyze.generate("hi", cfg)
+
+
+class TestAnalyzeOne(unittest.TestCase):
+    def test_skip_existing(self):
+        with tempfile.TemporaryDirectory() as td:
+            td = Path(td)
+            cfg = make_cfg(td)
+            papers = cfg.papers_dir
+            folder = make_paper(papers, "Kim2026", with_analysis=True)
+            state = State(cfg.state_db)
+            status, _ = analyze.analyze_one("Kim2026", folder, None, cfg, state)
+            state.close()
+            self.assertEqual(status, "exists")
+
+    def test_write_via_abstract_fallback(self):
+        with tempfile.TemporaryDirectory() as td:
+            td = Path(td)
+            cfg = make_cfg(td)
+            folder = make_paper(cfg.papers_dir, "Lee2025")
+            state = State(cfg.state_db)
+            with mock.patch.object(analyze, "_gen_ollama", return_value=LONG_BODY):
+                status, detail = analyze.analyze_one("Lee2025", folder, None, cfg, state)
+            self.assertEqual(status, "written", detail)
+            target = folder / "Lee2025_ollama_analysis.md"
+            self.assertTrue(target.exists())
+            text = target.read_text(encoding="utf-8")
+            self.assertIn('input_basis: "abstract+metadata only"', text)
+            self.assertEqual(state.analyses_today(), 1)
+            state.close()
+
+    def test_short_output_rejected(self):
+        with tempfile.TemporaryDirectory() as td:
+            td = Path(td)
+            cfg = make_cfg(td)
+            folder = make_paper(cfg.papers_dir, "Park2024")
+            state = State(cfg.state_db)
+            with mock.patch.object(analyze, "_gen_ollama", return_value="ok"):
+                status, detail = analyze.analyze_one("Park2024", folder, None, cfg, state)
+            state.close()
+            self.assertEqual(status, "error")
+            self.assertFalse((folder / "Park2024_ollama_analysis.md").exists())
+
+
+class TestBatch(unittest.TestCase):
+    def test_engine_none_refuses(self):
+        with tempfile.TemporaryDirectory() as td:
+            cfg = make_cfg(Path(td), engine="none")
+            state = State(cfg.state_db)
+            out = analyze.run_batch(cfg, state)
+            state.close()
+            self.assertEqual(out[0]["status"], "error")
+
+    def test_budget_enforced(self):
+        with tempfile.TemporaryDirectory() as td:
+            td = Path(td)
+            cfg = make_cfg(td)  # daily_limit = 2
+            for ck in ("A2020", "B2021", "C2022"):
+                make_paper(cfg.papers_dir, ck)
+            state = State(cfg.state_db)
+            with mock.patch.object(analyze, "_gen_ollama", return_value=LONG_BODY):
+                results = analyze.run_batch(cfg, state)
+            state.close()
+            statuses = sorted(r["status"] for r in results)
+            self.assertEqual(statuses.count("written"), 2)
+            self.assertEqual(statuses.count("deferred"), 1)
+
+
+if __name__ == "__main__":
+    unittest.main()