@archznn/crewloop-skills 0.5.0 → 0.7.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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