eno-service 0.1.0__tar.gz

eno_service-0.1.0/.gitignore

@@ -0,0 +1,18 @@
+__pycache__/
+*.pyc
+.venv/
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+*.egg-info/
+dist/
+build/
+.somm/
+.claude/worktrees/
+.playwright-mcp/
+.env
+
+# obsidian plugin build artifacts (when packages/eno-plugin/ lands)
+node_modules/
+packages/eno-plugin/main.js
+packages/eno-plugin/*.zip

eno_service-0.1.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: eno-service
+Version: 0.1.0
+Summary: eno-service — FastAPI face on eno's read endpoints
+License: MIT
+Requires-Python: >=3.12
+Requires-Dist: enowiki==0.1.0
+Requires-Dist: fastapi>=0.115
+Requires-Dist: uvicorn>=0.30
+Provides-Extra: test
+Requires-Dist: httpx>=0.27; extra == 'test'

eno_service-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "eno-service"
+version = "0.1.0"
+description = "eno-service — FastAPI face on eno's read endpoints"
+requires-python = ">=3.12"
+license = { text = "MIT" }
+dependencies = [
+    "enowiki==0.1.0",  # the core package (imports as `eno`)
+    "fastapi>=0.115",
+    "uvicorn>=0.30",
+]
+
+[project.optional-dependencies]
+test = ["httpx>=0.27"]
+
+[project.scripts]
+eno-serve = "eno_service.server:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/eno_service"]

eno_service-0.1.0/src/eno_service/__init__.py

@@ -0,0 +1,3 @@
+"""eno-service — FastAPI face on eno's read endpoints."""
+
+__version__ = "0.1.0"

eno_service-0.1.0/src/eno_service/server.py

@@ -0,0 +1,272 @@
+"""FastAPI server exposing eno's read endpoints.
+
+Per-request sqlite connection. WAL mode means concurrent reads are fine; the
+slight overhead of opening a connection per request is microseconds at vault scale.
+The service is read-only in v0 — `POST /index` is the one mutating exception.
+"""
+
+import os
+from contextlib import contextmanager
+from dataclasses import asdict
+
+from eno import garden, hygiene, queries, writes
+from eno.config import index_path, vault_dir
+from eno.db import open_index
+from eno.excerpt import excerpt as build_excerpt
+from eno.indexer import index_vault
+from eno.views import Proposal
+from fastapi import FastAPI, HTTPException, Query
+from pydantic import BaseModel
+
+
+@contextmanager
+def _db():
+    conn = open_index(index_path(vault_dir()))
+    try:
+        yield conn
+    finally:
+        conn.close()
+
+
+def create_app() -> FastAPI:
+    app = FastAPI(title="eno-service", version="0.0.1")
+
+    @app.get("/health")
+    def health():
+        return {"ok": True, "vault": str(vault_dir())}
+
+    @app.get("/search")
+    def search(q: str, kind: str = "title", limit: int = 20):
+        try:
+            with _db() as db:
+                return [asdict(h) for h in queries.search(db, q, kind=kind, limit=limit)]
+        except ValueError as e:
+            raise HTTPException(status_code=400, detail=str(e)) from e
+
+    @app.get("/note")
+    def note(path: str, excerpt: int = 1):
+        with _db() as db:
+            view = queries.note(db, path)
+        if not view:
+            raise HTTPException(status_code=404, detail=f"note not found: {path}")
+        if excerpt:
+            view.excerpt = build_excerpt(vault_dir(), path)
+        return asdict(view)
+
+    @app.get("/neighbors")
+    def neighbors(path: str):
+        with _db() as db:
+            n = queries.neighbors(db, path)
+        if not n:
+            raise HTTPException(status_code=404, detail=f"note not found: {path}")
+        return asdict(n)
+
+    @app.get("/orphans")
+    def orphans(folder: str | None = None, min_words: int = 0, limit: int = 100):
+        with _db() as db:
+            return [
+                asdict(r)
+                for r in queries.orphans(
+                    db, folder=folder, min_words=min_words, limit=limit
+                )
+            ]
+
+    @app.get("/stubs")
+    def stubs(max_words: int = 80, limit: int = 100):
+        with _db() as db:
+            return [
+                asdict(r) for r in queries.stubs(db, max_words=max_words, limit=limit)
+            ]
+
+    @app.get("/stale")
+    def stale(
+        older_than_days: int = 180,
+        stages: list[str] | None = Query(default=None),
+        limit: int = 100,
+    ):
+        with _db() as db:
+            return [
+                asdict(r)
+                for r in queries.stale(
+                    db, older_than_days=older_than_days, stages=stages, limit=limit
+                )
+            ]
+
+    @app.get("/broken-links")
+    def broken_links(limit: int = 200):
+        with _db() as db:
+            return [asdict(r) for r in queries.broken_links(db, limit=limit)]
+
+    @app.get("/frontier")
+    def frontier(
+        folder: str | None = None,
+        halflife_days: float = 30.0,
+        limit: int = 20,
+        include_nonpositive: bool = False,
+        exclude_types: list[str] | None = Query(default=None),
+    ):
+        with _db() as db:
+            return [
+                asdict(r)
+                for r in queries.frontier(
+                    db,
+                    folder=folder,
+                    halflife_days=halflife_days,
+                    limit=limit,
+                    include_nonpositive=include_nonpositive,
+                    exclude_types=exclude_types,
+                )
+            ]
+
+    @app.get("/hot")
+    def hot(agent_name: str = ""):
+        with _db() as db:
+            return asdict(queries.hot(db, agent_name=agent_name))
+
+    class TilingBody(BaseModel):
+        threshold: float = 0.80
+        error_threshold: float = 0.90
+        folder: str | None = None
+        min_words: int = 80
+        model: str = "nomic-embed-text"
+
+    @app.post("/tiling")
+    def tiling_endpoint(body: TilingBody | None = None):
+        from eno import tiling as tiling_mod
+        body = body or TilingBody()
+        with _db() as db:
+            return asdict(
+                tiling_mod.find_semantic_duplicates(
+                    db,
+                    vault_dir(),
+                    threshold=body.threshold,
+                    error_threshold=body.error_threshold,
+                    folder=body.folder,
+                    min_words=body.min_words,
+                    model=body.model,
+                )
+            )
+
+    @app.get("/classify-broken-links")
+    def classify_broken_links_endpoint():
+        with _db() as db:
+            drift, concepts = garden.classify_broken_links(db)
+        return {
+            "drift": [asdict(d) for d in drift],
+            "concepts": [asdict(c) for c in concepts],
+        }
+
+    @app.get("/hygiene")
+    def hygiene_endpoint():
+        with _db() as db:
+            return asdict(queries.hygiene(db))
+
+    @app.post("/index")
+    def index(full: bool = False):
+        stats = index_vault(vault_dir(), full=full)
+        return asdict(stats)
+
+    class ProposeBody(BaseModel):
+        include_unknown: bool = False
+
+    @app.post("/hygiene/propose")
+    def hygiene_propose(body: ProposeBody | None = None):
+        body = body or ProposeBody()
+        with _db() as db:
+            return asdict(
+                hygiene.propose_all(db, include_unknown=body.include_unknown)
+            )
+
+    class ProposalIn(BaseModel):
+        path: str
+        add: dict[str, str]
+        confidence: str = "medium"
+        reason: str = ""
+
+    class ApplyBody(BaseModel):
+        proposals: list[ProposalIn]
+        dry_run: bool = False
+
+    @app.post("/hygiene/apply")
+    def hygiene_apply(body: ApplyBody):
+        proposals = [
+            Proposal(
+                path=p.path, add=p.add, confidence=p.confidence, reason=p.reason
+            )
+            for p in body.proposals
+        ]
+        results = hygiene.apply_all(vault_dir(), proposals, dry_run=body.dry_run)
+        return {"results": [asdict(r) for r in results]}
+
+    class GardenBody(BaseModel):
+        folder: str | None = None
+        resurfacing_min_words: int = 1000
+        stub_max_words: int = 80
+        stale_days: int = 180
+        drift_threshold: float = 0.85
+        duplicate_threshold: float = 0.80
+
+    @app.post("/garden")
+    def garden_endpoint(body: GardenBody | None = None):
+        body = body or GardenBody()
+        with _db() as db:
+            return asdict(garden.garden(db, **body.model_dump()))
+
+    class CreateBody(BaseModel):
+        path: str
+        body: str
+        frontmatter: dict | None = None
+        overwrite: bool = False
+        author: str | None = None
+
+    @app.post("/note/create")
+    def create_note_endpoint(body: CreateBody):
+        result = writes.create_note(
+            vault_dir(),
+            body.path,
+            body.body,
+            frontmatter=body.frontmatter,
+            overwrite=body.overwrite,
+            author=body.author,
+        )
+        if result.ok:
+            index_vault(vault_dir())
+            result.indexed = True
+        return asdict(result)
+
+    class AppendBody(BaseModel):
+        path: str
+        content: str
+        under_heading: str | None = None
+
+    @app.post("/note/append")
+    def append_to_note_endpoint(body: AppendBody):
+        result = writes.append_to_note(
+            vault_dir(),
+            body.path,
+            body.content,
+            under_heading=body.under_heading,
+        )
+        if result.ok:
+            index_vault(vault_dir())
+            result.indexed = True
+        return asdict(result)
+
+    return app
+
+
+def serve(host: str = "127.0.0.1", port: int = 7891) -> None:
+    import uvicorn
+
+    uvicorn.run(create_app(), host=host, port=port, log_level="info")
+
+
+def main() -> None:
+    """uv-friendly entrypoint reading host/port from env."""
+    host = os.environ.get("ENO_SERVICE_HOST", "127.0.0.1")
+    port = int(os.environ.get("ENO_SERVICE_PORT", "7891"))
+    serve(host=host, port=port)
+
+
+if __name__ == "__main__":
+    main()

eno_service-0.1.0/tests/test_server.py

@@ -0,0 +1,213 @@
+"""End-to-end server tests via FastAPI's TestClient. Confirms wiring,
+not query semantics (those live in test_queries.py)."""
+
+from pathlib import Path
+
+import pytest
+from eno.indexer import index_vault
+from eno_service.server import create_app
+from fastapi.testclient import TestClient
+
+
+@pytest.fixture()
+def vault(tmp_path: Path, monkeypatch) -> Path:
+    (tmp_path / "Alpha.md").write_text(
+        "---\norigin: human\nstage: active\n---\n# Alpha\n\nlink to [[Beta]] and [[Ghost]]\n"
+    )
+    (tmp_path / "Beta.md").write_text("# Beta\n\nback to [[Alpha]]\n")
+    (tmp_path / "Orphan.md").write_text("# Orphan\n\nnothing inbound")
+    monkeypatch.setenv("ENO_VAULT_DIR", str(tmp_path))
+    monkeypatch.setenv("ENO_DIR", str(tmp_path / ".eno"))
+    index_vault(tmp_path)
+    return tmp_path
+
+
+@pytest.fixture()
+def client(vault: Path) -> TestClient:
+    return TestClient(create_app())
+
+
+def test_health(client: TestClient):
+    r = client.get("/health")
+    assert r.status_code == 200
+    body = r.json()
+    assert body["ok"] is True
+
+
+def test_search(client: TestClient):
+    r = client.get("/search", params={"q": "alpha"})
+    assert r.status_code == 200
+    paths = [h["path"] for h in r.json()]
+    assert "Alpha.md" in paths
+
+
+def test_note_returns_view_with_excerpt(client: TestClient):
+    r = client.get("/note", params={"path": "Alpha.md"})
+    assert r.status_code == 200
+    body = r.json()
+    assert body["title"] == "Alpha"
+    assert body["frontmatter"]["origin"] == "human"
+    assert body["excerpt"]
+
+
+def test_note_404(client: TestClient):
+    r = client.get("/note", params={"path": "Nope.md"})
+    assert r.status_code == 404
+
+
+def test_neighbors(client: TestClient):
+    r = client.get("/neighbors", params={"path": "Alpha.md"})
+    assert r.status_code == 200
+    body = r.json()
+    assert any(b["path"] == "Beta.md" for b in body["backlinks"])
+    assert any(o["path"] == "Beta.md" for o in body["outbound"])
+
+
+def test_orphans(client: TestClient):
+    r = client.get("/orphans")
+    assert r.status_code == 200
+    paths = [n["path"] for n in r.json()]
+    assert "Orphan.md" in paths
+
+
+def test_broken_links(client: TestClient):
+    r = client.get("/broken-links")
+    assert r.status_code == 200
+    targets = [b["target_text"] for b in r.json()]
+    assert "Ghost" in targets
+
+
+def test_hot(client: TestClient):
+    r = client.get("/hot", params={"agent_name": "Weaver"})
+    assert r.status_code == 200
+    body = r.json()
+    assert body["agent_name"] == "Weaver"
+    assert body["generated_at"]
+    # Fixture has Alpha→Beta+Ghost (out=1, in=1, score=0 → not in default frontier),
+    # but recent_appends should at least include some notes.
+    assert isinstance(body["frontier"], list)
+    assert isinstance(body["recent_appends"], list)
+    assert isinstance(body["top_concepts"], list)
+    assert isinstance(body["agent_recent"], list)
+
+
+def test_frontier(client: TestClient):
+    r = client.get("/frontier")
+    assert r.status_code == 200
+    body = r.json()
+    assert isinstance(body, list)
+    # Alpha → Beta + Ghost: out=1 (Beta resolves; Ghost doesn't), in=1 (Beta).
+    # Score = 0 by default; expect Alpha excluded unless include_nonpositive.
+    r2 = client.get("/frontier", params={"include_nonpositive": "true"})
+    assert r2.status_code == 200
+    paths = [f["path"] for f in r2.json()]
+    assert "Alpha.md" in paths
+
+
+def test_hygiene(client: TestClient):
+    r = client.get("/hygiene")
+    assert r.status_code == 200
+    body = r.json()
+    assert body["counts"]["total"] == 3
+    # Beta and Orphan lack frontmatter
+    assert body["counts"]["origin"] == 2
+
+
+def test_search_unknown_kind_400(client: TestClient):
+    r = client.get("/search", params={"q": "x", "kind": "bogus"})
+    assert r.status_code == 400
+
+
+def test_hygiene_propose(client: TestClient):
+    r = client.post("/hygiene/propose", json={"include_unknown": False})
+    assert r.status_code == 200
+    body = r.json()
+    assert "proposals" in body
+    assert body["total_notes"] >= 3
+    paths = {p["path"] for p in body["proposals"]}
+    # Alpha already has origin → not in proposals
+    assert "Alpha.md" not in paths
+    # Orphan and Beta lack origin → eligible
+    assert "Beta.md" in paths or "Orphan.md" in paths
+
+
+def test_classify_broken_links_endpoint(client: TestClient):
+    r = client.get("/classify-broken-links")
+    assert r.status_code == 200
+    body = r.json()
+    assert "drift" in body
+    assert "concepts" in body
+    # Alpha has [[Ghost]] which doesn't resolve and doesn't fuzzy-match anything
+    targets = [c["target_text"] for c in body["concepts"]]
+    assert "Ghost" in targets
+
+
+def test_garden_endpoint(client: TestClient):
+    r = client.post("/garden", json={})
+    assert r.status_code == 200
+    body = r.json()
+    assert "resurfacing" in body
+    assert "concepts" in body
+    assert "drift" in body
+    assert "duplicates" in body
+    assert "stubs" in body
+    assert "stale" in body
+    assert "stats" in body
+
+
+def test_create_note_endpoint(vault: Path, client: TestClient):
+    r = client.post(
+        "/note/create",
+        json={
+            "path": "FromService.md",
+            "body": "service-created body",
+            "author": "TestAgent",
+        },
+    )
+    assert r.status_code == 200
+    data = r.json()
+    assert data["ok"]
+    assert data["indexed"]
+    assert (vault / "FromService.md").exists()
+    assert "[[TestAgent]]" in (vault / "FromService.md").read_text()
+
+
+def test_create_note_endpoint_refuses_existing(vault: Path, client: TestClient):
+    r = client.post(
+        "/note/create",
+        json={"path": "Alpha.md", "body": "should not overwrite"},
+    )
+    assert r.status_code == 200
+    assert r.json()["ok"] is False
+
+
+def test_append_to_note_endpoint(vault: Path, client: TestClient):
+    r = client.post(
+        "/note/append",
+        json={"path": "Beta.md", "content": "new line via service"},
+    )
+    assert r.status_code == 200
+    assert r.json()["ok"]
+    assert "new line via service" in (vault / "Beta.md").read_text()
+
+
+def test_hygiene_apply(vault: Path, client: TestClient):
+    proposals = [
+        {
+            "path": "Beta.md",
+            "add": {"origin": "human"},
+            "confidence": "medium",
+            "reason": "test",
+        }
+    ]
+    r = client.post(
+        "/hygiene/apply", json={"proposals": proposals, "dry_run": False}
+    )
+    assert r.status_code == 200
+    results = r.json()["results"]
+    assert results[0]["ok"]
+    assert results[0]["applied"] == {"origin": "human"}
+    # Verify the file was actually mutated
+    new = (vault / "Beta.md").read_text()
+    assert "origin: human" in new
+    assert new.startswith("---\n")