@archznn/crewloop-skills 0.6.0 → 0.7.0

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

@@ -1,31 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,108 +0,0 @@
-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

@@ -1,103 +0,0 @@
-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

@@ -1,139 +0,0 @@
-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"]