@archznn/crewloop-skills 0.2.0 → 0.3.0

package/servers/obsidian-mcp/tests/test_privacy.py

@@ -0,0 +1,31 @@
+import pytest
+
+from obsidian_mcp.config import Config
+from obsidian_mcp.privacy.filter import PrivacyFilter
+
+
+def test_blocks_api_key():
+    f = PrivacyFilter()
+    assert not f.is_safe("API_KEY=sk-123")
+    with pytest.raises(ValueError):
+        f.validate("API_KEY=sk-123")
+
+
+def test_allows_safe_text():
+    f = PrivacyFilter()
+    assert f.is_safe("This is a normal note about MCP.")
+
+
+def test_blocks_email():
+    f = PrivacyFilter()
+    assert not f.is_safe("Contact me at user@example.com")
+
+
+def test_blocks_secret_key_prefix():
+    f = PrivacyFilter()
+    assert not f.is_safe("Key: sk-abc123def456ghi789")
+
+
+def test_allows_tokenization_word():
+    f = PrivacyFilter()
+    assert f.is_safe("This note discusses tokenization of text.")

package/servers/obsidian-mcp/tests/test_privacy_config.py

@@ -0,0 +1,44 @@
+import pytest
+
+from obsidian_mcp.config import Config, PrivacyConfig
+from obsidian_mcp.privacy.filter import PrivacyFilter
+
+
+def test_privacy_filter_disabled_via_config():
+    config = Config(privacy={"enabled": False})
+    f = PrivacyFilter(config)
+    assert f.is_safe("API_KEY=secret")
+    f.validate("API_KEY=secret")  # no exception
+
+
+def test_privacy_filter_allow_list_bypass():
+    config = Config(privacy={"allowed_strings": ["user@example.com"]})
+    f = PrivacyFilter(config)
+    assert f.is_safe("Contact user@example.com please")
+    f.validate("Contact user@example.com please")
+
+
+def test_privacy_filter_toggle_emails():
+    config = Config(privacy={"block_emails": False})
+    f = PrivacyFilter(config)
+    assert f.is_safe("user@example.com")
+
+
+def test_privacy_filter_toggle_credit_cards():
+    config = Config(privacy={"block_credit_cards": False})
+    f = PrivacyFilter(config)
+    assert f.is_safe("1234 5678 9012 3456")
+
+
+def test_privacy_filter_default_still_blocks():
+    f = PrivacyFilter()
+    assert not f.is_safe("API_KEY=secret")
+    assert not f.is_safe("user@example.com")
+    with pytest.raises(ValueError):
+        f.validate("API_KEY=secret")
+
+
+def test_privacy_config_object():
+    config = Config(privacy=PrivacyConfig(enabled=False))
+    f = PrivacyFilter(config)
+    assert f.is_safe("anything")

package/servers/obsidian-mcp/tests/test_rag.py

@@ -0,0 +1,64 @@
+from obsidian_mcp.indexer.indexer import Indexer
+from obsidian_mcp.models import Note
+from obsidian_mcp.rag.engine import RAGEngine
+
+
+def test_text_search(indexer, vault, config, store):
+    note = Note(path="search.md", title="Search", content="Obsidian vault local second brain.")
+    vault.save(note)
+    indexer.index_note(note)
+    engine = RAGEngine(config, store)
+    results = engine.search("Obsidian", mode="text")
+    assert any(r.note_path == "search.md" for r in results)
+
+
+def test_related_notes(indexer, vault, config, store):
+    vault.save(Note(path="a.md", title="A", content="See [[b]]."))
+    vault.save(Note(path="b.md", title="B", content="Content."))
+    indexer.index_note(vault.read("a.md"))
+    indexer.index_note(vault.read("b.md"))
+    indexer.compute_backlinks()
+    engine = RAGEngine(config, store)
+    results = engine.related("a.md")
+    assert any(r.note_path == "b.md" for r in results)
+
+
+def test_graph_search(indexer, vault, config, store):
+    vault.save(Note(path="a.md", title="A", content="See [[b]]."))
+    vault.save(Note(path="b.md", title="B", content="Content."))
+    indexer.index_note(vault.read("a.md"))
+    indexer.index_note(vault.read("b.md"))
+    indexer.compute_backlinks()
+    engine = RAGEngine(config, store)
+    results = engine.search("b", mode="graph")
+    assert any(r.note_path == "b.md" for r in results)
+
+
+def test_vector_search_fallback(config, vault, store):
+    vault.save(Note(path="v.md", title="V", content="MCP local second brain"))
+    indexer = Indexer(config, vault, store)
+    indexer.index_all()
+    engine = RAGEngine(config, store)
+    results = engine.search("MCP", mode="vector")
+    assert any(r.note_path == "v.md" for r in results)
+
+
+def test_vector_search_fallback_ranks_matching_note(config, vault, store):
+    vault.save(Note(path="a.md", title="A", content="MCP local second brain"))
+    vault.save(Note(path="b.md", title="B", content="Another note about servers and embedding"))
+    indexer = Indexer(config, vault, store)
+    indexer.index_all()
+    engine = RAGEngine(config, store)
+    results = engine.search("MCP server", mode="vector")
+    assert results[0].note_path == "a.md"
+
+
+def test_hybrid_search_normalizes_scores(config, vault, store):
+    vault.save(Note(path="a.md", title="A", content="MCP local second brain"))
+    vault.save(Note(path="b.md", title="B", content="Another note about servers and embedding"))
+    indexer = Indexer(config, vault, store)
+    indexer.index_all()
+    engine = RAGEngine(config, store)
+    results = engine.search("MCP", mode="hybrid")
+    assert results
+    assert all(0.0 <= r.score <= 1.0 for r in results)

package/servers/obsidian-mcp/tests/test_read_raw.py

@@ -0,0 +1,37 @@
+import pytest
+
+from obsidian_mcp.tools.registry import dispatch
+from obsidian_mcp.vault.repository import VaultRepository
+
+
+def test_read_note_returns_exact_file_content(config, temp_vault):
+    VaultRepository(config)
+    raw = "---\ntitle: Exact Note\ntags:\n  - alpha\n  - beta\n---\n\n# Exact Note\n\nKeep the frontmatter exactly as written."
+    (temp_vault / "exact.md").write_text(raw, encoding="utf-8")
+    result = dispatch("read_note", {"path": "exact.md"}, config)
+    assert result == raw
+
+
+def test_read_note_does_not_inject_title_or_tags(config, temp_vault):
+    VaultRepository(config)
+    raw = "Plain body without title or tags."
+    (temp_vault / "plain.md").write_text(raw, encoding="utf-8")
+    result = dispatch("read_note", {"path": "plain.md"}, config)
+    assert result == raw
+    assert "# " not in result
+    assert "**Tags:**" not in result
+
+
+def test_read_note_non_utf8_replacement(config, vault, temp_vault):
+    VaultRepository(config)
+    path = temp_vault / "binary.md"
+    path.write_bytes(b"\xff\xfeHello\xfa world")
+    result = dispatch("read_note", {"path": "binary.md"}, config)
+    assert "Hello" in result
+    assert "world" in result
+
+
+def test_read_note_missing_raises(config):
+    VaultRepository(config)
+    with pytest.raises(FileNotFoundError):
+        dispatch("read_note", {"path": "missing.md"}, config)

package/servers/obsidian-mcp/tests/test_tfidf_fallback.py

@@ -0,0 +1,54 @@
+from obsidian_mcp.indexer.indexer import Indexer
+from obsidian_mcp.models import Chunk, Note
+from obsidian_mcp.rag.engine import RAGEngine
+from obsidian_mcp.rag.vector_search import TfidfIndex
+
+
+def test_tfidf_index_fits_on_corpus():
+    index = TfidfIndex()
+    chunks = [
+        Chunk(id="c1", note_path="a.md", text="MCP local second brain"),
+        Chunk(id="c2", note_path="b.md", text="Another note about servers"),
+    ]
+    index.fit(chunks)
+    results = index.query("MCP", top_k=10)
+    assert any(doc_id == "c1" for doc_id, _ in results)
+
+
+def test_tfidf_index_query_empty_corpus():
+    index = TfidfIndex()
+    index.fit([])
+    assert index.query("anything") == []
+
+
+def test_vector_search_builds_corpus_fitted_index(config, vault, store):
+    vault.save(Note(path="a.md", title="A", content="MCP local second brain"))
+    indexer = Indexer(config, vault, store)
+    indexer.index_all()
+    engine = RAGEngine(config, store)
+    assert engine.vector_search._tfidf_index is None
+    results = engine.search("MCP", mode="vector")
+    assert results
+    assert engine.vector_search._tfidf_index is not None
+    assert engine.vector_search._tfidf_chunk_count > 0
+
+
+def test_vector_search_reuses_fitted_index(config, vault, store):
+    vault.save(Note(path="a.md", title="A", content="MCP local second brain"))
+    indexer = Indexer(config, vault, store)
+    indexer.index_all()
+    engine = RAGEngine(config, store)
+    engine.search("MCP", mode="vector")
+    first_index = engine.vector_search._tfidf_index
+    engine.search("local", mode="vector")
+    assert engine.vector_search._tfidf_index is first_index
+
+
+def test_vector_search_ranks_matching_note_highest(config, vault, store):
+    vault.save(Note(path="a.md", title="A", content="MCP local second brain"))
+    vault.save(Note(path="b.md", title="B", content="Another note about servers and embedding"))
+    indexer = Indexer(config, vault, store)
+    indexer.index_all()
+    engine = RAGEngine(config, store)
+    results = engine.search("MCP server", mode="vector")
+    assert results[0].note_path == "a.md"

package/servers/obsidian-mcp/tests/test_tools.py

@@ -0,0 +1,108 @@
+import pytest
+
+from obsidian_mcp.indexer.indexer import Indexer
+from obsidian_mcp.indexer.store import IndexStore
+from obsidian_mcp.models import Note
+from obsidian_mcp.tools.registry import dispatch
+from obsidian_mcp.vault.repository import VaultRepository
+
+
+def test_tool_create_and_read(config):
+    VaultRepository(config)
+    result = dispatch("create_note", {"path": "t.md", "content": "Hello"}, config)
+    assert result["status"] == "created"
+    text = dispatch("read_note", {"path": "t.md"}, config)
+    assert "Hello" in text
+
+
+def test_tool_create_note_adds_extension(config):
+    VaultRepository(config)
+    result = dispatch("create_note", {"path": "no-extension", "content": "body"}, config)
+    assert result["path"] == "no-extension.md"
+    text = dispatch("read_note", {"path": "no-extension.md"}, config)
+    assert "body" in text
+
+
+def test_tool_create_note_title_from_path(config):
+    VaultRepository(config)
+    dispatch("create_note", {"path": "my-great-note.md", "content": "body"}, config)
+    text = dispatch("read_note", {"path": "my-great-note.md"}, config)
+    assert "My Great Note" in text
+
+
+def test_tool_read_note_returns_raw_content(config, temp_vault):
+    VaultRepository(config)
+    dispatch(
+        "create_note",
+        {"path": "fm.md", "title": "FM", "content": "body", "tags": ["a", "b"]},
+        config,
+    )
+    raw = (temp_vault / "fm.md").read_text(encoding="utf-8")
+    text = dispatch("read_note", {"path": "fm.md"}, config)
+    assert text == raw
+    assert "body" in text
+    assert "FM" in text
+
+
+def test_tool_search(config):
+    vault = VaultRepository(config)
+    vault.save(Note(path="s.md", title="S", content="MCP server local"))
+    indexer = Indexer(config, vault, IndexStore(config.index_dir / "index.db"))
+    indexer.index_all()
+    text = dispatch("search_notes", {"query": "MCP", "mode": "text"}, config)
+    assert "s.md" in text
+
+
+def test_tool_privacy_blocks(config):
+    with pytest.raises(ValueError):
+        dispatch("create_note", {"path": "bad.md", "content": "API_KEY=secret"}, config)
+
+
+def test_tool_update_and_delete(config):
+    VaultRepository(config)
+    dispatch("create_note", {"path": "u.md", "content": "Original", "tags": ["a"]}, config)
+    dispatch("update_note", {"path": "u.md", "append": "More", "tags": ["b"]}, config)
+    text = dispatch("read_note", {"path": "u.md"}, config)
+    assert "Original" in text
+    assert "More" in text
+    assert "b" in text
+    dispatch("delete_note", {"path": "u.md"}, config)
+    with pytest.raises(FileNotFoundError):
+        dispatch("read_note", {"path": "u.md"}, config)
+
+
+def test_tool_list_and_related(config):
+    vault = VaultRepository(config)
+    vault.save(Note(path="x.md", title="X", content="Link to [[y]]."))
+    vault.save(Note(path="y.md", title="Y", content="Content."))
+    indexer = Indexer(config, vault, IndexStore(config.index_dir / "index.db"))
+    indexer.index_all()
+    indexer.compute_backlinks()
+    listed = dispatch("list_notes", {}, config)
+    assert "x.md" in listed
+    related = dispatch("get_related_notes", {"path": "x.md"}, config)
+    assert "y.md" in related
+
+
+def test_tool_sync_from_bundle(config, temp_vault):
+    (temp_vault / "skills" / "orchestrator").mkdir(parents=True)
+    (temp_vault / "skills" / "orchestrator" / "SKILL.md").write_text("# Orchestrator\n")
+    (temp_vault / "README.md").write_text("# Bundle\n")
+    result = dispatch("sync_from_bundle", {"force": True}, config)
+    assert result["status"] == "synced"
+    assert result["indexed_bundle_files"] > 0
+
+
+def test_tool_path_traversal_blocked(config):
+    with pytest.raises(ValueError):
+        dispatch("create_note", {"path": "../outside.md", "content": "x"}, config)
+
+
+def test_tool_learn_from_text(config):
+    result = dispatch(
+        "learn_from_text",
+        {"text": "Novo conceito: Observability no projeto LEA."},
+        config,
+    )
+    assert result["status"] == "learned"
+    assert any("observability" in p.lower() for p in result["created_notes"])

package/servers/obsidian-mcp/tests/test_vault.py

@@ -0,0 +1,103 @@
+import pytest
+
+from obsidian_mcp.models import Note
+from obsidian_mcp.vault.parser import parse_note
+from obsidian_mcp.vault.repository import VaultRepository
+
+
+def test_parse_note_with_frontmatter(temp_vault):
+    path = temp_vault / "test.md"
+    path.write_text("---\ntitle: Hello\ntags: [a, b]\n---\n\nBody here with [[link]].")
+    note = parse_note("test.md", path)
+    assert note.title == "Hello"
+    assert note.frontmatter["tags"] == ["a", "b"]
+    assert "Body here" in note.content
+    assert note.links == ["link.md"]
+
+
+def test_parse_note_without_frontmatter(temp_vault):
+    path = temp_vault / "no-front.md"
+    path.write_text("# My Title\n\nContent.")
+    note = parse_note("no-front.md", path)
+    assert note.title == "My Title"
+    assert note.content == "Content."
+
+
+def test_parse_note_with_invalid_frontmatter(temp_vault):
+    path = temp_vault / "bad-front.md"
+    path.write_text("---\ntitle: [unclosed\n---\n\nBody.")
+    note = parse_note("bad-front.md", path)
+    assert note.frontmatter == {}
+    assert "Body." in note.content
+
+
+def test_vault_crud(config):
+    repo = VaultRepository(config)
+    note = Note(path="foo.md", title="Foo", content="bar")
+    repo.save(note)
+    assert repo.exists("foo.md")
+    read = repo.read("foo.md")
+    assert read.title == "Foo"
+    repo.delete("foo.md")
+    assert not repo.exists("foo.md")
+
+
+def test_vault_path_escape(config):
+    repo = VaultRepository(config)
+    with pytest.raises(ValueError):
+        repo._resolve("../outside.md")
+
+
+def test_writer_preserves_created_and_tags(config):
+    repo = VaultRepository(config)
+    note = Note(path="w.md", title="W", content="body", tags=["tag1"])
+    repo.save(note)
+    first = repo.read("w.md")
+    created = first.frontmatter["created"]
+    repo.save(first)
+    second = repo.read("w.md")
+    assert second.frontmatter["created"] == created
+    assert "tag1" in second.frontmatter["tags"]
+
+
+def test_vault_ignores_hidden_dirs(config):
+    repo = VaultRepository(config)
+    hidden = repo.root / ".hidden"
+    hidden.mkdir()
+    (hidden / "secret.md").write_text("# secret")
+    (repo.root / "visible.md").write_text("# visible")
+    notes = repo.list_notes()
+    assert "visible.md" in notes
+    assert "secret.md" not in notes
+
+
+def test_vault_blocks_symlink_escape(config, temp_vault):
+    repo = VaultRepository(config)
+    outside = temp_vault.parent / "outside.md"
+    outside.write_text("# outside")
+    link = repo.root / "escape.md"
+    link.symlink_to(outside)
+    assert "escape.md" not in repo.list_notes()
+    with pytest.raises(ValueError):
+        repo.read("escape.md")
+
+
+def test_vault_read_raw_returns_exact_content(config):
+    repo = VaultRepository(config)
+    raw = "---\ntitle: Raw\ntags:\n  - a\n---\n\nbody"
+    (repo.root / "raw.md").write_text(raw, encoding="utf-8")
+    assert repo.read_raw("raw.md") == raw
+
+
+def test_vault_read_raw_missing_raises(config):
+    repo = VaultRepository(config)
+    with pytest.raises(FileNotFoundError):
+        repo.read_raw("missing.md")
+
+
+def test_vault_read_raw_replaces_non_utf8(config, temp_vault):
+    repo = VaultRepository(config)
+    (repo.root / "binary.md").write_bytes(b"\xff\xfeHello\xfaworld")
+    text = repo.read_raw("binary.md")
+    assert "Hello" in text
+    assert "world" in text

package/servers/obsidian-mcp/tests/test_writer.py

@@ -0,0 +1,139 @@
+from datetime import datetime
+
+import pytest
+import yaml
+
+from obsidian_mcp.models import Note
+from obsidian_mcp.vault.writer import write_note
+
+
+def _parse_frontmatter(text: str) -> dict:
+    assert text.startswith("---")
+    end = text.find("\n---", 3)
+    assert end != -1
+    return yaml.safe_load(text[3:end])
+
+
+def _get_body(text: str) -> str:
+    end = text.find("\n---", 3)
+    return text[end + 5 :].lstrip("\n")
+
+
+def test_write_note_without_frontmatter(temp_vault):
+    path = temp_vault / "clean.md"
+    note = Note(path="clean.md", title="Clean Note", content="# Clean Note\n\nBody.")
+    write_note(path, note)
+
+    written = path.read_text(encoding="utf-8")
+    frontmatter = _parse_frontmatter(written)
+    body = _get_body(written)
+
+    assert frontmatter["title"] == "Clean Note"
+    assert "created" in frontmatter
+    assert "updated" in frontmatter
+    assert body == "# Clean Note\n\nBody."
+
+
+def test_write_note_with_embedded_frontmatter(temp_vault):
+    path = temp_vault / "embedded.md"
+    content = (
+        "---\n"
+        "type: journal\n"
+        "title: Embedded Title\n"
+        "tags: [a, b]\n"
+        "updated: 2026-06-16T17:35:00Z\n"
+        "---\n"
+        "\n"
+        "# Embedded Title\n"
+        "\n"
+        "Body text."
+    )
+    note = Note(path="embedded.md", title="Server Title", content=content, tags=["c"])
+    write_note(path, note)
+
+    written = path.read_text(encoding="utf-8")
+    frontmatter = _parse_frontmatter(written)
+    body = _get_body(written)
+
+    assert frontmatter["title"] == "Server Title"
+    assert frontmatter["type"] == "journal"
+    assert frontmatter["tags"] == ["a", "b", "c"]
+    assert "created" in frontmatter
+    assert "updated" in frontmatter
+    assert body == "# Embedded Title\n\nBody text."
+
+
+def test_write_note_with_malformed_frontmatter(temp_vault, caplog):
+    path = temp_vault / "bad.md"
+    content = "---\ntitle: [unclosed\n---\n\nBody."
+    note = Note(path="bad.md", title="Bad Note", content=content)
+
+    with caplog.at_level("WARNING"):
+        write_note(path, note)
+
+    written = path.read_text(encoding="utf-8")
+    frontmatter = _parse_frontmatter(written)
+    body = _get_body(written)
+
+    assert "failed to parse frontmatter" in caplog.text.lower()
+    assert frontmatter["title"] == "Bad Note"
+    assert body == "Body."
+
+
+def test_write_note_merges_tags(temp_vault):
+    path = temp_vault / "tags.md"
+    content = "---\ntags: [z, a, a]\n---\n\nBody."
+    note = Note(path="tags.md", title="Tags Note", content=content, tags=["b", "a"])
+    write_note(path, note)
+
+    written = path.read_text(encoding="utf-8")
+    frontmatter = _parse_frontmatter(written)
+
+    assert frontmatter["tags"] == ["a", "b", "z"]
+
+
+def test_write_note_preserves_created_on_update(temp_vault):
+    path = temp_vault / "preserve.md"
+    note = Note(path="preserve.md", title="Preserve", content="Body.")
+    write_note(path, note)
+
+    first = path.read_text(encoding="utf-8")
+    first_created = _parse_frontmatter(first)["created"]
+
+    note2 = Note(
+        path="preserve.md",
+        title="Preserve",
+        content="Updated body.",
+        frontmatter={"created": first_created},
+    )
+    write_note(path, note2)
+
+    second = path.read_text(encoding="utf-8")
+    second_frontmatter = _parse_frontmatter(second)
+
+    assert second_frontmatter["created"] == first_created
+    assert second_frontmatter["updated"] != first_created
+
+
+def test_write_note_title_precedence(temp_vault):
+    path = temp_vault / "title.md"
+    content = "---\ntitle: Embedded Title\n---\n\nBody."
+    note = Note(path="title.md", title="Server Title", content=content)
+    write_note(path, note)
+
+    written = path.read_text(encoding="utf-8")
+    frontmatter = _parse_frontmatter(written)
+
+    assert frontmatter["title"] == "Server Title"
+
+
+def test_write_note_tags_as_string(temp_vault):
+    path = temp_vault / "string-tags.md"
+    content = "---\ntags: x, y, z\n---\n\nBody."
+    note = Note(path="string-tags.md", title="String Tags", content=content)
+    write_note(path, note)
+
+    written = path.read_text(encoding="utf-8")
+    frontmatter = _parse_frontmatter(written)
+
+    assert frontmatter["tags"] == ["x", "y", "z"]