@archznn/crewloop-skills 0.1.0 → 0.3.0

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

@@ -0,0 +1,130 @@
+import asyncio
+
+from obsidian_mcp.config import Config
+from obsidian_mcp.tools.create import handle_create_note
+from obsidian_mcp.tools.delete import handle_delete_note
+from obsidian_mcp.tools.learn import handle_learn_from_text
+from obsidian_mcp.tools.list import handle_list_notes
+from obsidian_mcp.tools.read import handle_read_note
+from obsidian_mcp.tools.related import handle_get_related_notes
+from obsidian_mcp.tools.search import handle_search_notes
+from obsidian_mcp.tools.sync import handle_sync_from_bundle
+from obsidian_mcp.tools.update import handle_update_note
+
+
+TOOLS = {
+    "read_note": {
+        "description": "Read a note from the Obsidian vault.",
+        "input_schema": {
+            "type": "object",
+            "properties": {"path": {"type": "string"}},
+            "required": ["path"],
+        },
+        "handler": handle_read_note,
+    },
+    "search_notes": {
+        "description": "Search notes by text, vector, graph or hybrid.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "query": {"type": "string"},
+                "mode": {"type": "string", "enum": ["text", "vector", "graph", "hybrid"]},
+                "limit": {"type": "integer", "default": 10},
+            },
+            "required": ["query"],
+        },
+        "handler": handle_search_notes,
+    },
+    "create_note": {
+        "description": "Create a new note in the vault.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "path": {"type": "string"},
+                "content": {"type": "string"},
+                "title": {"type": "string"},
+                "tags": {"type": "array", "items": {"type": "string"}},
+                "overwrite": {"type": "boolean", "default": False},
+            },
+            "required": ["path"],
+        },
+        "handler": handle_create_note,
+    },
+    "update_note": {
+        "description": "Update or append content to an existing note.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "path": {"type": "string"},
+                "content": {"type": "string"},
+                "append": {"type": "string"},
+                "tags": {"type": "array", "items": {"type": "string"}},
+            },
+            "required": ["path"],
+        },
+        "handler": handle_update_note,
+    },
+    "delete_note": {
+        "description": "Delete a note from the vault.",
+        "input_schema": {
+            "type": "object",
+            "properties": {"path": {"type": "string"}},
+            "required": ["path"],
+        },
+        "handler": handle_delete_note,
+    },
+    "list_notes": {
+        "description": "List notes in the vault.",
+        "input_schema": {
+            "type": "object",
+            "properties": {"folder": {"type": "string"}},
+        },
+        "handler": handle_list_notes,
+    },
+    "get_related_notes": {
+        "description": "Get notes related by links and graph traversal.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "path": {"type": "string"},
+                "depth": {"type": "integer", "default": 1},
+            },
+            "required": ["path"],
+        },
+        "handler": handle_get_related_notes,
+    },
+    "sync_from_bundle": {
+        "description": "Re-index the loop-engineering-agents bundle and local vault.",
+        "input_schema": {
+            "type": "object",
+            "properties": {"force": {"type": "boolean", "default": False}},
+        },
+        "handler": handle_sync_from_bundle,
+    },
+    "learn_from_text": {
+        "description": "Detect learnings in text and create notes automatically.",
+        "input_schema": {
+            "type": "object",
+            "properties": {"text": {"type": "string"}},
+            "required": ["text"],
+        },
+        "handler": handle_learn_from_text,
+    },
+}
+
+
+def dispatch(name: str, arguments: dict, config: Config):
+    tool = TOOLS.get(name)
+    if tool is None:
+        raise ValueError(f"unknown tool: {name}")
+    return tool["handler"](arguments, config)
+
+
+async def dispatch_async(name: str, arguments: dict, config: Config):
+    tool = TOOLS.get(name)
+    if tool is None:
+        raise ValueError(f"unknown tool: {name}")
+    handler = tool["handler"]
+    if asyncio.iscoroutinefunction(handler):
+        return await handler(arguments, config)
+    return await asyncio.to_thread(handler, arguments, config)

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)