@archznn/crewloop-skills 0.1.0 → 0.3.0

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

@@ -0,0 +1,90 @@
+import time
+from pathlib import Path
+
+from obsidian_mcp.config import Config
+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_end_to_end_workflow(tmp_path):
+    config = Config(
+        vault_path=tmp_path / "vault",
+        index_dir=tmp_path / ".index",
+        bundle_path=Path(__file__).resolve().parents[3],
+    )
+
+    # 1. Sync bundle as initial knowledge
+    result = dispatch("sync_from_bundle", {"force": True}, config)
+    assert result["status"] == "synced"
+    assert result["indexed_bundle_files"] > 0
+
+    # 2. Search existing knowledge
+    search = dispatch("search_notes", {"query": "orchestrator", "mode": "text"}, config)
+    assert "orchestrator" in search.lower() or "No results" not in search
+
+    # 3. Create a note with a link
+    dispatch(
+        "create_note",
+        {
+            "path": "projects/mcp-integration.md",
+            "title": "MCP Integration",
+            "content": "We integrated Obsidian via [[MCP]].",
+            "tags": ["integration"],
+        },
+        config,
+    )
+
+    # 4. Learn from new text
+    learn = dispatch(
+        "learn_from_text",
+        {"text": "Novo conceito: MCP Server conecta Obsidian local ao bundle LEA."},
+        config,
+    )
+    assert learn["status"] == "learned"
+    assert any("mcp-server" in p.lower() for p in learn["created_notes"])
+
+    # 5. Re-index and find related notes
+    vault = VaultRepository(config)
+    indexer = Indexer(config, vault, IndexStore(config.index_dir / "index.db"))
+    indexer.index_all()
+    indexer.compute_backlinks()
+
+    related = dispatch("get_related_notes", {"path": "projects/mcp-integration.md"}, config)
+    assert "mcp" in related.lower()
+
+    # 6. List notes
+    listed = dispatch("list_notes", {"folder": "concepts"}, config)
+    assert "mcp-server" in listed.lower()
+
+    # 7. Read generated concept note
+    concept_path = learn["created_notes"][0]
+    concept = dispatch("read_note", {"path": concept_path}, config)
+    assert "MCP Server" in concept
+
+
+def test_search_performance(tmp_path):
+    config = Config(
+        vault_path=tmp_path / "vault",
+        index_dir=tmp_path / ".index",
+        bundle_path=tmp_path,
+    )
+    vault = VaultRepository(config)
+    for i in range(1000):
+        vault.save(
+            Note(
+                path=f"notes/note-{i:04d}.md",
+                title=f"Note {i}",
+                content=f"This is note number {i} about topic {i % 10} and keyword {i}.",
+            )
+        )
+    indexer = Indexer(config, vault, IndexStore(config.index_dir / "index.db"))
+    indexer.index_all()
+
+    start = time.time()
+    result = dispatch("search_notes", {"query": "topic 5", "mode": "text", "limit": 10}, config)
+    elapsed = time.time() - start
+    assert elapsed < 2.0, f"search took {elapsed:.2f}s"
+    assert "note-" in result

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

@@ -0,0 +1,34 @@
+from obsidian_mcp.learning.detector import LearningDetector
+from obsidian_mcp.learning.note_generator import NoteGenerator
+from obsidian_mcp.tools.registry import dispatch
+from obsidian_mcp.vault.repository import VaultRepository
+
+
+def test_detect_concept(config, vault):
+    detector = LearningDetector(config)
+    learnings = detector.detect("Novo conceito: Graph RAG será usado no projeto.")
+    assert any(l.type == "concept" and "Graph RAG" in l.title for l in learnings)
+
+
+def test_detect_decision(config, vault):
+    detector = LearningDetector(config)
+    learnings = detector.detect("Decidimos que o vault ficará em ~/.lea.")
+    assert any(l.type == "decision" for l in learnings)
+
+
+def test_note_generator(config, vault):
+    detector = LearningDetector(config)
+    learnings = detector.detect("Novo conceito: MCP Server.")
+    gen = NoteGenerator(config, vault)
+    note = gen.to_note(learnings[0])
+    assert note.path.startswith("concepts/")
+    assert note.frontmatter["auto_generated"] is True
+
+
+def test_learn_from_text_dedup(config):
+    VaultRepository(config)
+    text = "Novo conceito: Dedup Test no projeto."
+    first = dispatch("learn_from_text", {"text": text}, config)
+    assert first["status"] == "learned"
+    second = dispatch("learn_from_text", {"text": text}, config)
+    assert second["status"] == "duplicate"

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