@archznn/crewloop-skills 0.2.0 → 0.4.0

package/servers/obsidian-mcp/src/obsidian_mcp/server.py

@@ -0,0 +1,61 @@
+import asyncio
+import json
+import logging
+import time
+
+from mcp import ErrorData, McpError
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+from mcp.types import TextContent, Tool
+
+from obsidian_mcp.config import Config
+from obsidian_mcp.tools.registry import TOOLS, dispatch_async
+
+logger = logging.getLogger(__name__)
+
+
+def _error_code_for(exc: Exception) -> int:
+    if isinstance(exc, (ValueError, FileExistsError)):
+        return -32600
+    if isinstance(exc, FileNotFoundError):
+        return -32602
+    return -32603
+
+
+async def serve(config: Config | None = None):
+    config = config or Config()
+    server = Server("obsidian-mcp")
+
+    @server.list_tools()
+    async def list_tools() -> list[Tool]:
+        return [
+            Tool(name=name, description=meta["description"], inputSchema=meta["input_schema"])
+            for name, meta in TOOLS.items()
+        ]
+
+    @server.call_tool()
+    async def call_tool(name: str, arguments: dict | None) -> list[TextContent]:
+        arguments = arguments or {}
+        start = time.perf_counter()
+        logger.info("tool start: %s", name)
+        try:
+            result = await dispatch_async(name, arguments, config)
+            if isinstance(result, str):
+                return [TextContent(type="text", text=result)]
+            return [TextContent(type="text", text=json.dumps(result, ensure_ascii=False, indent=2))]
+        except Exception as exc:
+            logger.exception("tool error: %s", name)
+            raise McpError(
+                ErrorData(code=_error_code_for(exc), message=str(exc))
+            ) from exc
+        finally:
+            elapsed = time.perf_counter() - start
+            logger.info("tool end: %s (%.3fs)", name, elapsed)
+
+    async with stdio_server() as (read_stream, write_stream):
+        await server.run(read_stream, write_stream, server.create_initialization_options())
+
+
+def main():
+    logging.basicConfig(level=logging.INFO)
+    asyncio.run(serve())

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

@@ -0,0 +1,43 @@
+import logging
+from pathlib import Path
+
+from obsidian_mcp.config import Config
+from obsidian_mcp.models import Note
+from obsidian_mcp.privacy.filter import PrivacyFilter
+from obsidian_mcp.vault.repository import VaultRepository
+
+logger = logging.getLogger(__name__)
+
+
+def handle_create_note(arguments: dict, config: Config) -> dict:
+    path = arguments.get("path")
+    content = arguments.get("content", "")
+    title = arguments.get("title")
+    tags = arguments.get("tags", [])
+    overwrite = bool(arguments.get("overwrite", False))
+    if not path:
+        raise ValueError("path is required")
+
+    if not path.endswith(".md"):
+        path = path + ".md"
+
+    PrivacyFilter(config).validate(path)
+    PrivacyFilter(config).validate(content)
+
+    vault = VaultRepository(config)
+    if vault.exists(path) and not overwrite:
+        raise FileExistsError(f"note already exists: {path}")
+
+    note = Note(
+        path=path,
+        title=title or _title_from_path(path),
+        content=content,
+        tags=tags,
+    )
+    vault.save(note)
+    logger.info("created note: %s", path)
+    return {"status": "created", "path": path}
+
+
+def _title_from_path(path: str) -> str:
+    return Path(path).stem.replace("-", " ").replace("_", " ").title()

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

@@ -0,0 +1,16 @@
+import logging
+
+from obsidian_mcp.config import Config
+from obsidian_mcp.vault.repository import VaultRepository
+
+logger = logging.getLogger(__name__)
+
+
+def handle_delete_note(arguments: dict, config: Config) -> dict:
+    path = arguments.get("path")
+    if not path:
+        raise ValueError("path is required")
+    vault = VaultRepository(config)
+    vault.delete(path)
+    logger.info("deleted note: %s", path)
+    return {"status": "deleted", "path": path}

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

@@ -0,0 +1,42 @@
+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.learning.detector import LearningDetector
+from obsidian_mcp.learning.note_generator import NoteGenerator
+from obsidian_mcp.privacy.filter import PrivacyFilter
+from obsidian_mcp.vault.repository import VaultRepository
+
+logger = logging.getLogger(__name__)
+
+
+def handle_learn_from_text(arguments: dict, config: Config) -> dict:
+    text = arguments.get("text", "")
+    if not text:
+        raise ValueError("text is required")
+
+    PrivacyFilter(config).validate(text)
+
+    detector = LearningDetector(config)
+    learnings = detector.detect(text)
+    if not learnings:
+        return {"status": "no_learning_detected"}
+
+    vault = VaultRepository(config)
+    generator = NoteGenerator(config, vault)
+    indexer = Indexer(config, vault, IndexStore(config.index_dir / "index.db"))
+
+    created = []
+    for learning in learnings:
+        if vault.exists(generator.path_for(learning)):
+            continue
+        note = generator.generate_and_save(learning)
+        indexer.index_note(note)
+        created.append(note.path)
+
+    if not created:
+        logger.info("no new learnings created from text")
+        return {"status": "duplicate", "created_notes": []}
+    logger.info("learned from text, created notes: %s", created)
+    return {"status": "learned", "created_notes": created}

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

@@ -0,0 +1,16 @@
+import logging
+
+from obsidian_mcp.config import Config
+from obsidian_mcp.vault.repository import VaultRepository
+
+logger = logging.getLogger(__name__)
+
+
+def handle_list_notes(arguments: dict, config: Config) -> str:
+    folder = arguments.get("folder")
+    vault = VaultRepository(config)
+    notes = vault.list_notes(folder)
+    logger.debug("listed %d notes in folder %s", len(notes), folder)
+    if not notes:
+        return "No notes found."
+    return "\n".join(f"- {n}" for n in notes)

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

@@ -0,0 +1,15 @@
+import logging
+
+from obsidian_mcp.config import Config
+from obsidian_mcp.vault.repository import VaultRepository
+
+logger = logging.getLogger(__name__)
+
+
+def handle_read_note(arguments: dict, config: Config) -> str:
+    path = arguments.get("path")
+    if not path:
+        raise ValueError("path is required")
+    vault = VaultRepository(config)
+    logger.debug("reading note: %s", path)
+    return vault.read_raw(path)

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")