@archznn/crewloop-skills 0.2.0 → 0.3.0

package/servers/obsidian-mcp/src/obsidian_mcp/tools/related.py

@@ -0,0 +1,20 @@
+import logging
+
+from obsidian_mcp.config import Config
+from obsidian_mcp.indexer.store import IndexStore
+from obsidian_mcp.rag.engine import RAGEngine
+
+logger = logging.getLogger(__name__)
+
+
+def handle_get_related_notes(arguments: dict, config: Config) -> str:
+    path = arguments.get("path")
+    if not path:
+        raise ValueError("path is required")
+    depth = int(arguments.get("depth", 1))
+    logger.info("getting related notes: path=%s depth=%d", path, depth)
+    engine = RAGEngine(config, IndexStore(config.index_dir / "index.db"))
+    results = engine.related(path, depth=depth)
+    if not results:
+        return "No related notes found."
+    return "\n".join(f"- **{r.note_path}** (score: {r.score:.3f})" for r in results)

package/servers/obsidian-mcp/src/obsidian_mcp/tools/search.py

@@ -0,0 +1,26 @@
+import logging
+
+from obsidian_mcp.config import Config
+from obsidian_mcp.indexer.store import IndexStore
+from obsidian_mcp.rag.engine import RAGEngine
+
+logger = logging.getLogger(__name__)
+
+
+def handle_search_notes(arguments: dict, config: Config) -> str:
+    query = arguments.get("query")
+    if not query:
+        raise ValueError("query is required")
+    mode = arguments.get("mode", "hybrid")
+    limit = int(arguments.get("limit", 10))
+    logger.info("searching notes: mode=%s query=%r limit=%d", mode, query, limit)
+    engine = RAGEngine(config, IndexStore(config.index_dir / "index.db"))
+    results = engine.search(query, mode=mode, limit=limit)
+    if not results:
+        return "No results found."
+    lines = []
+    for r in results:
+        lines.append(f"- **{r.note_path}** (score: {r.score:.3f})")
+        if r.snippet:
+            lines.append(f"  {r.snippet[:200].replace(chr(10), ' ')}")
+    return "\n".join(lines)

package/servers/obsidian-mcp/src/obsidian_mcp/tools/sync.py

@@ -0,0 +1,22 @@
+import logging
+
+from obsidian_mcp.config import Config
+from obsidian_mcp.indexer.indexer import Indexer
+from obsidian_mcp.indexer.store import IndexStore
+from obsidian_mcp.indexer.sync import BundleSync
+from obsidian_mcp.vault.repository import VaultRepository
+
+logger = logging.getLogger(__name__)
+
+
+def handle_sync_from_bundle(arguments: dict, config: Config) -> dict:
+    force = bool(arguments.get("force", False))
+    logger.info("syncing from bundle: force=%s", force)
+    vault = VaultRepository(config)
+    store = IndexStore(config.index_dir / "index.db")
+    indexer = Indexer(config, vault, store)
+    indexer.index_all(force=force)
+    sync = BundleSync(config, indexer, vault)
+    report = sync.sync(force=force)
+    logger.info("synced from bundle: %s", report)
+    return {"status": "synced", **report}

package/servers/obsidian-mcp/src/obsidian_mcp/tools/update.py

@@ -0,0 +1,34 @@
+import logging
+from datetime import datetime, timezone
+
+from obsidian_mcp.config import Config
+from obsidian_mcp.privacy.filter import PrivacyFilter
+from obsidian_mcp.vault.repository import VaultRepository
+
+logger = logging.getLogger(__name__)
+
+
+def handle_update_note(arguments: dict, config: Config) -> dict:
+    path = arguments.get("path")
+    if not path:
+        raise ValueError("path is required")
+    content = arguments.get("content")
+    append = arguments.get("append")
+    tags = arguments.get("tags")
+
+    vault = VaultRepository(config)
+    note = vault.read(path)
+
+    PrivacyFilter(config).validate(content or "")
+    PrivacyFilter(config).validate(append or "")
+
+    if content is not None:
+        note.content = content
+    if append:
+        note.content = note.content.rstrip() + "\n\n" + append
+    if tags is not None:
+        note.tags = tags
+    note.frontmatter["updated"] = datetime.now(timezone.utc).isoformat()
+    vault.save(note)
+    logger.info("updated note: %s", path)
+    return {"status": "updated", "path": path}

package/servers/obsidian-mcp/src/obsidian_mcp/vault/parser.py

@@ -0,0 +1,82 @@
+import logging
+import re
+from datetime import datetime, timezone
+from pathlib import Path
+
+import yaml
+
+from obsidian_mcp.models import Note
+
+logger = logging.getLogger(__name__)
+
+
+FRONTMATTER_RE = re.compile(r"^---\s*\n(.*?)\n---\s*\n", re.DOTALL)
+LINK_RE = re.compile(r"\[\[([^\]|]+)(?:\|[^\]]+)?\]\]")
+
+
+def extract_frontmatter(content: str) -> tuple[dict, str]:
+    match = FRONTMATTER_RE.match(content)
+    if not match:
+        return {}, content
+    try:
+        frontmatter = yaml.safe_load(match.group(1)) or {}
+    except yaml.YAMLError as exc:
+        logger.warning("failed to parse frontmatter: %s", exc)
+        frontmatter = {}
+    body = content[match.end():]
+    return frontmatter, body
+
+
+def extract_title_and_body(body: str) -> tuple[str, str]:
+    lines = body.splitlines()
+    if lines and lines[0].startswith("# "):
+        title = lines[0][2:].strip()
+        return title, "\n".join(lines[1:]).lstrip("\n")
+    return "", body
+
+
+def extract_title(body: str, path: str) -> str:
+    title, _ = extract_title_and_body(body)
+    if title:
+        return title
+    return Path(path).stem.replace("-", " ").replace("_", " ").title()
+
+
+def normalize_link(link: str) -> str:
+    link = link.strip()
+    if not any(link.endswith(ext) for ext in (".md", ".png", ".jpg", ".jpeg", ".pdf")):
+        link += ".md"
+    return link
+
+
+def extract_links(content: str) -> list[str]:
+    return [normalize_link(m.group(1)) for m in LINK_RE.finditer(content)]
+
+
+def parse_note(path: str, full_path: Path) -> Note:
+    content = full_path.read_text(encoding="utf-8")
+    frontmatter, body = extract_frontmatter(content)
+    if frontmatter.get("title"):
+        title = frontmatter["title"]
+    else:
+        title, body = extract_title_and_body(body)
+        if not title:
+            title = extract_title(body, path)
+    links = extract_links(content)
+    stat = full_path.stat()
+    ctime = datetime.fromtimestamp(stat.st_ctime, tz=timezone.utc)
+    mtime = datetime.fromtimestamp(stat.st_mtime, tz=timezone.utc)
+    tags = frontmatter.get("tags", []) or []
+    if isinstance(tags, str):
+        tags = [t.strip() for t in tags.split(",") if t.strip()]
+    return Note(
+        path=path,
+        title=title,
+        content=body,
+        frontmatter=frontmatter,
+        links=links,
+        backlinks=[],
+        tags=tags,
+        ctime=ctime,
+        mtime=mtime,
+    )

package/servers/obsidian-mcp/src/obsidian_mcp/vault/repository.py

@@ -0,0 +1,68 @@
+from pathlib import Path
+
+from obsidian_mcp.config import Config
+from obsidian_mcp.models import Note
+from obsidian_mcp.vault.parser import parse_note
+from obsidian_mcp.vault.writer import write_note
+
+
+class VaultRepository:
+    def __init__(self, config: Config):
+        self.config = config
+        self.root = config.vault_path
+        self.root.mkdir(parents=True, exist_ok=True)
+
+    def _resolve(self, path: str) -> Path:
+        safe = path.lstrip("/")
+        if ".." in safe.split("/"):
+            raise ValueError(f"invalid note path: {path}")
+        full = (self.root / safe).resolve()
+        if full != self.root and self.root not in full.parents:
+            raise ValueError(f"invalid note path: {path}")
+        return full
+
+    def _is_inside_vault(self, path: Path) -> bool:
+        resolved = path.resolve()
+        return resolved == self.root or self.root in resolved.parents
+
+    def list_notes(self, folder: str | None = None) -> list[str]:
+        base = self.root
+        if folder:
+            base = self._resolve(folder)
+        paths = []
+        for p in base.rglob("*.md"):
+            if not self._is_inside_vault(p):
+                continue
+            rel = p.relative_to(self.root)
+            if any(part.startswith(".") for part in rel.parts):
+                continue
+            paths.append(rel.as_posix())
+        return sorted(paths)
+
+    def read(self, path: str) -> Note:
+        full = self._resolve(path)
+        if not full.exists():
+            raise FileNotFoundError(f"note not found: {path}")
+        return parse_note(path, full)
+
+    def read_raw(self, path: str) -> str:
+        full = self._resolve(path)
+        if not full.exists():
+            raise FileNotFoundError(f"note not found: {path}")
+        return full.read_text(encoding="utf-8", errors="replace")
+
+    def read_all(self) -> list[Note]:
+        return [self.read(p) for p in self.list_notes()]
+
+    def exists(self, path: str) -> bool:
+        return self._resolve(path).exists()
+
+    def save(self, note: Note) -> None:
+        full = self._resolve(note.path)
+        write_note(full, note)
+
+    def delete(self, path: str) -> None:
+        full = self._resolve(path)
+        if not full.exists():
+            raise FileNotFoundError(f"note not found: {path}")
+        full.unlink()

package/servers/obsidian-mcp/src/obsidian_mcp/vault/writer.py

@@ -0,0 +1,61 @@
+import logging
+from datetime import datetime, timezone
+from pathlib import Path
+
+import yaml
+
+from obsidian_mcp.models import Note
+from obsidian_mcp.vault.parser import extract_frontmatter
+
+logger = logging.getLogger(__name__)
+
+
+def to_frontmatter(data: dict) -> str:
+    if not data:
+        return ""
+    return "---\n" + yaml.safe_dump(data, sort_keys=False, allow_unicode=True) + "---\n\n"
+
+
+def _normalize_tags(tags) -> list[str]:
+    if tags is None:
+        return []
+    if isinstance(tags, str):
+        return [t.strip() for t in tags.split(",") if t.strip()]
+    return list(tags)
+
+
+def write_note(full_path: Path, note: Note) -> None:
+    full_path.parent.mkdir(parents=True, exist_ok=True)
+
+    body = note.content
+    extracted_frontmatter = {}
+    if note.content.startswith("---"):
+        extracted_frontmatter, body = extract_frontmatter(note.content)
+        if extracted_frontmatter is None:
+            logger.warning("failed to parse embedded frontmatter in %s", full_path)
+            extracted_frontmatter = {}
+            body = note.content
+
+    frontmatter = dict(note.frontmatter)
+    frontmatter.setdefault("title", note.title)
+
+    server_tags = _normalize_tags(note.tags)
+    extracted_tags = _normalize_tags(extracted_frontmatter.pop("tags", []))
+    all_tags = set(server_tags)
+    all_tags.update(extracted_tags)
+    all_tags.update(_normalize_tags(frontmatter.get("tags", [])))
+    if all_tags:
+        frontmatter["tags"] = sorted(all_tags)
+    elif "tags" in frontmatter:
+        del frontmatter["tags"]
+
+    for key, value in extracted_frontmatter.items():
+        if key not in ("title", "created", "updated"):
+            frontmatter.setdefault(key, value)
+
+    now = datetime.now(timezone.utc).isoformat()
+    frontmatter.setdefault("created", now)
+    frontmatter["updated"] = now
+
+    content = to_frontmatter(frontmatter) + body
+    full_path.write_text(content, encoding="utf-8")

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

@@ -0,0 +1,39 @@
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from obsidian_mcp.config import Config
+from obsidian_mcp.indexer.indexer import Indexer
+from obsidian_mcp.indexer.store import IndexStore
+from obsidian_mcp.vault.repository import VaultRepository
+
+
+@pytest.fixture
+def temp_vault():
+    with tempfile.TemporaryDirectory() as tmp:
+        yield Path(tmp)
+
+
+@pytest.fixture
+def config(temp_vault):
+    return Config(
+        vault_path=temp_vault,
+        index_dir=temp_vault / ".index",
+        bundle_path=temp_vault,
+    )
+
+
+@pytest.fixture
+def vault(config):
+    return VaultRepository(config)
+
+
+@pytest.fixture
+def store(config):
+    return IndexStore(config.index_dir / "index.db")
+
+
+@pytest.fixture
+def indexer(config, vault, store):
+    return Indexer(config, vault, store)

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

@@ -0,0 +1,87 @@
+import asyncio
+import threading
+import time
+
+import pytest
+
+from obsidian_mcp.config import Config
+from obsidian_mcp.tools.registry import TOOLS, dispatch_async
+from obsidian_mcp.vault.repository import VaultRepository
+
+
+def test_dispatch_async_runs_sync_handler_in_thread(monkeypatch):
+    events = []
+
+    def slow_handler(arguments, config):
+        events.append(("start", threading.current_thread().name))
+        time.sleep(0.1)
+        events.append(("end", threading.current_thread().name))
+        return "slow-result"
+
+    monkeypatch.setitem(TOOLS, "slow_tool", {
+        "description": "Slow tool",
+        "input_schema": {"type": "object"},
+        "handler": slow_handler,
+    })
+
+    async def _run():
+        start = time.monotonic()
+        result = await dispatch_async("slow_tool", {}, Config())
+        elapsed = time.monotonic() - start
+        return result, elapsed
+
+    result, elapsed = asyncio.run(_run())
+    assert result == "slow-result"
+    assert elapsed >= 0.05
+    assert any("start" in e[0] for e in events)
+
+
+def test_dispatch_async_awaits_async_handler(monkeypatch):
+    async def async_handler(arguments, config):
+        await asyncio.sleep(0.01)
+        return "async-result"
+
+    monkeypatch.setitem(TOOLS, "async_tool", {
+        "description": "Async tool",
+        "input_schema": {"type": "object"},
+        "handler": async_handler,
+    })
+
+    async def _run():
+        return await dispatch_async("async_tool", {}, Config())
+
+    result = asyncio.run(_run())
+    assert result == "async-result"
+
+
+def test_dispatch_async_does_not_block_event_loop(monkeypatch):
+    async def background_task():
+        await asyncio.sleep(0.05)
+        return "background-done"
+
+    def slow_handler(arguments, config):
+        time.sleep(0.15)
+        return "done"
+
+    monkeypatch.setitem(TOOLS, "slow_tool2", {
+        "description": "Slow tool",
+        "input_schema": {"type": "object"},
+        "handler": slow_handler,
+    })
+
+    async def _run():
+        task = asyncio.create_task(background_task())
+        result = await dispatch_async("slow_tool2", {}, Config())
+        background_result = await task
+        return result, background_result
+
+    result, background_result = asyncio.run(_run())
+    assert result == "done"
+    assert background_result == "background-done"
+
+
+def test_dispatch_stays_synchronous(config):
+    VaultRepository(config)
+    from obsidian_mcp.tools.registry import dispatch
+    result = dispatch("create_note", {"path": "sync.md", "content": "hello"}, config)
+    assert result["status"] == "created"

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

@@ -0,0 +1,59 @@
+import os
+
+import pytest
+
+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.rag.engine import RAGEngine
+from obsidian_mcp.tools.registry import dispatch
+from obsidian_mcp.vault.repository import VaultRepository
+
+
+def test_config_bundle_path_from_env(monkeypatch, tmp_path):
+    monkeypatch.setenv("CREWLOOP_BUNDLE_PATH", str(tmp_path))
+    config = Config()
+    assert config.bundle_path == tmp_path.resolve()
+
+
+def test_vector_search_empty_vault(config, store):
+    engine = RAGEngine(config, store)
+    results = engine.search("anything", mode="vector")
+    assert results == []
+
+
+def test_text_search_empty_vault(config, store):
+    engine = RAGEngine(config, store)
+    results = engine.search("anything", mode="text")
+    assert results == []
+
+
+def test_graph_search_empty_vault(config, store):
+    engine = RAGEngine(config, store)
+    results = engine.search("anything", mode="graph")
+    assert results == []
+
+
+def test_related_notes_empty_vault(config, store):
+    engine = RAGEngine(config, store)
+    results = engine.related("missing.md")
+    assert results == []
+
+
+def test_list_notes_empty_vault(config):
+    VaultRepository(config)
+    result = dispatch("list_notes", {}, config)
+    assert result == "No notes found."
+
+
+def test_sync_from_bundle_empty_bundle(config, temp_vault):
+    VaultRepository(config)
+    result = dispatch("sync_from_bundle", {"force": True}, config)
+    assert result["status"] == "synced"
+    assert result["indexed_bundle_files"] == 0
+
+
+def test_learn_from_text_no_learning(config):
+    result = dispatch("learn_from_text", {"text": "Just a random sentence with no clear concept."}, config)
+    assert result["status"] == "no_learning_detected"

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

@@ -0,0 +1,27 @@
+from obsidian_mcp.indexer.embeddings import chunk_text
+from obsidian_mcp.models import Note
+
+
+def test_chunk_text_character_based():
+    long_text = "word " * 200
+    chunks = chunk_text(long_text, chunk_size=50, overlap=10)
+    assert len(chunks) > 1
+    assert all(len(text) <= 80 for text, _, _ in chunks)
+
+
+def test_index_note(indexer, vault, store):
+    note = Note(path="test.md", title="Test", content="Hello world from MCP.")
+    vault.save(note)
+    indexer.index_note(note)
+    chunks = store.get_all_chunks()
+    assert any(c.note_path == "test.md" for c in chunks)
+
+
+def test_compute_backlinks(indexer, vault, store):
+    vault.save(Note(path="a.md", title="A", content="Link to [[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()
+    edges = store.get_all_edges()
+    assert any(e.source == "b.md" and e.target == "a.md" and e.relation == "backlink" for e in edges)

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"