frontmatter-mcp 0.2.0__py3-none-any.whl

frontmatter_mcp/__init__.py

@@ -0,0 +1 @@
+"""Filesystem Frontmatter MCP Server."""

frontmatter_mcp/frontmatter.py

@@ -0,0 +1,97 @@
+"""Frontmatter read/write module."""
+
+from pathlib import Path
+from typing import Any
+
+import frontmatter
+
+
+def parse_file(path: Path, base_dir: Path) -> dict[str, Any]:
+    """Parse frontmatter from a single file.
+
+    Args:
+        path: Absolute path to the file.
+        base_dir: Base directory for relative path calculation.
+
+    Returns:
+        Dictionary with 'path' (relative) and frontmatter properties.
+    """
+    post = frontmatter.load(path)
+    result: dict[str, Any] = {
+        "path": str(path.relative_to(base_dir)),
+    }
+    result.update(post.metadata)
+    return result
+
+
+def parse_files(
+    paths: list[Path], base_dir: Path
+) -> tuple[list[dict[str, Any]], list[dict[str, str]]]:
+    """Parse frontmatter from multiple files.
+
+    Args:
+        paths: List of absolute paths to files.
+        base_dir: Base directory for relative path calculation.
+
+    Returns:
+        Tuple of (parsed records, warnings for failed files).
+    """
+    records: list[dict[str, Any]] = []
+    warnings: list[dict[str, str]] = []
+
+    for path in paths:
+        try:
+            record = parse_file(path, base_dir)
+            records.append(record)
+        except Exception as e:
+            warnings.append(
+                {
+                    "path": str(path.relative_to(base_dir)),
+                    "error": str(e),
+                }
+            )
+
+    return records, warnings
+
+
+def update_file(
+    path: Path,
+    base_dir: Path,
+    set_values: dict[str, Any] | None = None,
+    unset: list[str] | None = None,
+) -> dict[str, Any]:
+    """Update frontmatter in a single file.
+
+    Args:
+        path: Absolute path to the file.
+        base_dir: Base directory for relative path calculation.
+        set_values: Properties to add or overwrite.
+        unset: Property names to remove.
+
+    Returns:
+        Dictionary with 'path' (relative) and 'frontmatter' (updated metadata).
+    """
+    post = frontmatter.load(path)
+
+    # Apply set values
+    if set_values:
+        for key, value in set_values.items():
+            # Skip if key is in unset (unset takes priority)
+            if unset and key in unset:
+                continue
+            post.metadata[key] = value
+
+    # Apply unset
+    if unset:
+        for key in unset:
+            post.metadata.pop(key, None)
+
+    # Only write if there were changes
+    if set_values or unset:
+        with open(path, "wb") as f:
+            frontmatter.dump(post, f)
+
+    return {
+        "path": str(path.relative_to(base_dir)),
+        "frontmatter": dict(post.metadata),
+    }

frontmatter_mcp/query.py

@@ -0,0 +1,74 @@
+"""DuckDB query execution module."""
+
+import json
+from typing import Any
+
+import duckdb
+import pyarrow as pa
+
+
+def _serialize_value(value: Any) -> str | None:
+    """Serialize a value to string for DuckDB.
+
+    Arrays are JSON-encoded, other values are converted to string.
+    None remains None.
+    """
+    if value is None:
+        return None
+    if isinstance(value, list):
+        return json.dumps(value, ensure_ascii=False)
+    return str(value)
+
+
+def execute_query(records: list[dict[str, Any]], sql: str) -> dict[str, Any]:
+    """Execute DuckDB SQL query on frontmatter records.
+
+    All values are passed as strings to DuckDB. Use TRY_CAST in SQL
+    for type conversion. Arrays are JSON-encoded strings.
+
+    Args:
+        records: List of parsed frontmatter records.
+        sql: SQL query string. Must reference 'files' table.
+
+    Returns:
+        Dictionary with results, row_count, and columns.
+    """
+    if not records:
+        return {
+            "results": [],
+            "row_count": 0,
+            "columns": [],
+        }
+
+    # Collect all unique keys across all records
+    all_keys: set[str] = set()
+    for record in records:
+        all_keys.update(record.keys())
+
+    # Build columns dict with serialized string values
+    columns_data: dict[str, list[str | None]] = {key: [] for key in all_keys}
+    for record in records:
+        for key in all_keys:
+            columns_data[key].append(_serialize_value(record.get(key)))
+
+    # Create pyarrow table with explicit string type for all columns
+    schema = pa.schema([(key, pa.string()) for key in all_keys])
+    table = pa.table(columns_data, schema=schema)
+
+    # Create connection and register table
+    conn = duckdb.connect(":memory:")
+    conn.register("files", table)
+
+    # Execute query
+    result = conn.execute(sql)
+    columns = [desc[0] for desc in result.description]
+    rows = result.fetchall()
+
+    # Convert to list of dicts
+    results = [dict(zip(columns, row, strict=True)) for row in rows]
+
+    return {
+        "results": results,
+        "row_count": len(results),
+        "columns": columns,
+    }

frontmatter_mcp/schema.py

@@ -0,0 +1,58 @@
+"""Schema inference module."""
+
+from typing import Any
+
+
+def infer_schema(
+    records: list[dict[str, Any]], max_samples: int = 5
+) -> dict[str, dict[str, Any]]:
+    """Collect schema information from parsed records.
+
+    Note: This does not perform type inference. All values are treated
+    as strings in DuckDB queries. This function provides metadata about
+    what properties exist and their sample values.
+
+    Args:
+        records: List of parsed frontmatter records.
+        max_samples: Maximum number of sample values to include.
+
+    Returns:
+        Schema dict with count, nullable, sample_values for each property.
+    """
+    schema: dict[str, dict[str, Any]] = {}
+    property_values: dict[str, list[Any]] = {}
+
+    for record in records:
+        for key, value in record.items():
+            if key == "path":
+                continue
+            if key not in property_values:
+                property_values[key] = []
+            property_values[key].append(value)
+
+    total_files = len(records)
+
+    for prop, values in property_values.items():
+        non_null_values = [v for v in values if v is not None]
+        count = len(non_null_values)
+
+        # Detect if values are arrays
+        is_array = any(isinstance(v, list) for v in non_null_values)
+
+        # Collect unique sample values
+        seen: set[str] = set()
+        samples: list[Any] = []
+        for v in non_null_values:
+            key = str(v)
+            if key not in seen and len(samples) < max_samples:
+                seen.add(key)
+                samples.append(v)
+
+        schema[prop] = {
+            "type": "array" if is_array else "string",
+            "count": count,
+            "nullable": count < total_files,
+            "sample_values": samples,
+        }
+
+    return schema

frontmatter_mcp/server.py

@@ -0,0 +1,512 @@
+"""MCP Server implementation using FastMCP."""
+
+import glob as globmodule
+import sys
+from pathlib import Path
+from typing import Any
+
+import frontmatter
+from mcp.server.fastmcp import FastMCP
+
+from frontmatter_mcp.frontmatter import parse_files, update_file
+from frontmatter_mcp.query import execute_query
+from frontmatter_mcp.schema import infer_schema
+
+# Global base directory
+_base_dir: Path | None = None
+
+mcp = FastMCP("frontmatter-mcp")
+
+
+def get_base_dir() -> Path:
+    """Get the configured base directory."""
+    if _base_dir is None:
+        raise RuntimeError("Base directory not configured. Use --base-dir argument.")
+    return _base_dir
+
+
+def collect_files(glob_pattern: str) -> list[Path]:
+    """Collect files matching the glob pattern."""
+    base = get_base_dir()
+    pattern = str(base / glob_pattern)
+    matches = globmodule.glob(pattern, recursive=True)
+    return [Path(p) for p in matches if Path(p).is_file()]
+
+
+@mcp.tool()
+def query_inspect(glob: str) -> dict[str, Any]:
+    """Get frontmatter schema from files matching glob pattern.
+
+    Args:
+        glob: Glob pattern relative to base directory (e.g. "atoms/**/*.md").
+
+    Returns:
+        Dict with file_count, schema (type, count, nullable, sample_values).
+    """
+    base = get_base_dir()
+    paths = collect_files(glob)
+    records, warnings = parse_files(paths, base)
+    schema = infer_schema(records)
+
+    result: dict[str, Any] = {
+        "file_count": len(records),
+        "schema": schema,
+    }
+    if warnings:
+        result["warnings"] = warnings
+
+    return result
+
+
+@mcp.tool()
+def query(glob: str, sql: str) -> dict[str, Any]:
+    """Query frontmatter with DuckDB SQL.
+
+    Args:
+        glob: Glob pattern relative to base directory (e.g. "atoms/**/*.md").
+        sql: SQL query string. Reference 'files' table. Columns are frontmatter
+            properties plus 'path'.
+
+    Returns:
+        Dict with results array, row_count, and columns.
+    """
+    base = get_base_dir()
+    paths = collect_files(glob)
+    records, warnings = parse_files(paths, base)
+    query_result = execute_query(records, sql)
+
+    result: dict[str, Any] = {
+        "results": query_result["results"],
+        "row_count": query_result["row_count"],
+        "columns": query_result["columns"],
+    }
+    if warnings:
+        result["warnings"] = warnings
+
+    return result
+
+
+@mcp.tool()
+def update(
+    path: str,
+    set: dict[str, Any] | None = None,
+    unset: list[str] | None = None,
+) -> dict[str, Any]:
+    """Update frontmatter properties in a single file.
+
+    Args:
+        path: File path relative to base directory.
+        set: Properties to add or overwrite. Values are applied as-is (null becomes
+            YAML null, empty string becomes empty value).
+        unset: Property names to remove completely.
+
+    Returns:
+        Dict with path and updated frontmatter.
+
+    Notes:
+        - If same key appears in both set and unset, unset takes priority.
+        - If file has no frontmatter, it will be created.
+    """
+    base = get_base_dir().resolve()
+    abs_path = (base / path).resolve()
+
+    # Security: ensure path is within base_dir
+    try:
+        abs_path.relative_to(base)
+    except ValueError as e:
+        raise ValueError(f"Path must be within base directory: {path}") from e
+
+    if not abs_path.exists():
+        raise FileNotFoundError(f"File not found: {path}")
+
+    return update_file(abs_path, base, set_values=set, unset=unset)
+
+
+@mcp.tool()
+def batch_update(
+    glob: str,
+    set: dict[str, Any] | None = None,
+    unset: list[str] | None = None,
+) -> dict[str, Any]:
+    """Update frontmatter properties in multiple files matching glob pattern.
+
+    Args:
+        glob: Glob pattern relative to base directory (e.g. "atoms/**/*.md").
+        set: Properties to add or overwrite in all matched files.
+        unset: Property names to remove from all matched files.
+
+    Returns:
+        Dict with updated_count, updated_files, and warnings.
+
+    Notes:
+        - If same key appears in both set and unset, unset takes priority.
+        - If a file has no frontmatter, it will be created.
+        - Errors in individual files are recorded in warnings, not raised.
+    """
+    base = get_base_dir().resolve()
+    paths = collect_files(glob)
+
+    updated_files: list[str] = []
+    warnings: list[str] = []
+
+    for file_path in paths:
+        abs_path = file_path.resolve()
+        try:
+            abs_path.relative_to(base)
+        except ValueError:
+            warnings.append(f"Skipped (outside base directory): {abs_path}")
+            continue
+
+        try:
+            update_result = update_file(abs_path, base, set_values=set, unset=unset)
+            updated_files.append(update_result["path"])
+        except Exception as e:
+            rel_path = abs_path.relative_to(base)
+            warnings.append(f"Failed to update {rel_path}: {e}")
+
+    response: dict[str, Any] = {
+        "updated_count": len(updated_files),
+        "updated_files": updated_files,
+    }
+    if warnings:
+        response["warnings"] = warnings
+
+    return response
+
+
+@mcp.tool()
+def batch_array_add(
+    glob: str,
+    property: str,
+    value: Any,
+    allow_duplicates: bool = False,
+) -> dict[str, Any]:
+    """Add a value to an array property in multiple files.
+
+    Args:
+        glob: Glob pattern relative to base directory (e.g. "atoms/**/*.md").
+        property: Name of the array property.
+        value: Value to add. If value is an array, it's added as a single element.
+        allow_duplicates: If False (default), skip files where value already exists.
+
+    Returns:
+        Dict with updated_count, updated_files, and warnings.
+
+    Notes:
+        - If property doesn't exist, it will be created with [value].
+        - If property is not an array, file is skipped with a warning.
+        - Files are only included in updated_files if actually modified.
+    """
+
+    base = get_base_dir().resolve()
+    paths = collect_files(glob)
+
+    updated_files: list[str] = []
+    warnings: list[str] = []
+
+    for file_path in paths:
+        abs_path = file_path.resolve()
+        try:
+            rel_path = str(abs_path.relative_to(base))
+        except ValueError:
+            warnings.append(f"Skipped (outside base directory): {abs_path}")
+            continue
+
+        try:
+            post = frontmatter.load(abs_path)
+            current = post.get(property)
+
+            # Property doesn't exist: create new array
+            if current is None:
+                post[property] = [value]
+                frontmatter.dump(post, abs_path)
+                updated_files.append(rel_path)
+                continue
+
+            # Property is not an array: skip with warning
+            if not isinstance(current, list):
+                warnings.append(f"Skipped {rel_path}: '{property}' is not an array")
+                continue
+
+            # Check for duplicates
+            if not allow_duplicates and value in current:
+                continue
+
+            # Add value
+            current.append(value)
+            frontmatter.dump(post, abs_path)
+            updated_files.append(rel_path)
+
+        except Exception as e:
+            warnings.append(f"Failed to update {rel_path}: {e}")
+
+    response: dict[str, Any] = {
+        "updated_count": len(updated_files),
+        "updated_files": updated_files,
+    }
+    if warnings:
+        response["warnings"] = warnings
+
+    return response
+
+
+@mcp.tool()
+def batch_array_remove(
+    glob: str,
+    property: str,
+    value: Any,
+) -> dict[str, Any]:
+    """Remove a value from an array property in multiple files.
+
+    Args:
+        glob: Glob pattern relative to base directory (e.g. "atoms/**/*.md").
+        property: Name of the array property.
+        value: Value to remove.
+
+    Returns:
+        Dict with updated_count, updated_files, and warnings.
+
+    Notes:
+        - If property doesn't exist, file is skipped.
+        - If value doesn't exist in array, file is skipped.
+        - If property is not an array, file is skipped with a warning.
+        - Files are only included in updated_files if actually modified.
+    """
+
+    base = get_base_dir().resolve()
+    paths = collect_files(glob)
+
+    updated_files: list[str] = []
+    warnings: list[str] = []
+
+    for file_path in paths:
+        abs_path = file_path.resolve()
+        try:
+            rel_path = str(abs_path.relative_to(base))
+        except ValueError:
+            warnings.append(f"Skipped (outside base directory): {abs_path}")
+            continue
+
+        try:
+            post = frontmatter.load(abs_path)
+            current = post.get(property)
+
+            # Property doesn't exist: skip
+            if current is None:
+                continue
+
+            # Property is not an array: skip with warning
+            if not isinstance(current, list):
+                warnings.append(f"Skipped {rel_path}: '{property}' is not an array")
+                continue
+
+            # Value doesn't exist: skip
+            if value not in current:
+                continue
+
+            # Remove value
+            current.remove(value)
+            frontmatter.dump(post, abs_path)
+            updated_files.append(rel_path)
+
+        except Exception as e:
+            warnings.append(f"Failed to update {rel_path}: {e}")
+
+    response: dict[str, Any] = {
+        "updated_count": len(updated_files),
+        "updated_files": updated_files,
+    }
+    if warnings:
+        response["warnings"] = warnings
+
+    return response
+
+
+@mcp.tool()
+def batch_array_replace(
+    glob: str,
+    property: str,
+    old_value: Any,
+    new_value: Any,
+) -> dict[str, Any]:
+    """Replace a value in an array property in multiple files.
+
+    Args:
+        glob: Glob pattern relative to base directory (e.g. "atoms/**/*.md").
+        property: Name of the array property.
+        old_value: Value to replace.
+        new_value: New value.
+
+    Returns:
+        Dict with updated_count, updated_files, and warnings.
+
+    Notes:
+        - If property doesn't exist, file is skipped.
+        - If old_value doesn't exist in array, file is skipped.
+        - If property is not an array, file is skipped with a warning.
+        - Files are only included in updated_files if actually modified.
+    """
+
+    base = get_base_dir().resolve()
+    paths = collect_files(glob)
+
+    updated_files: list[str] = []
+    warnings: list[str] = []
+
+    for file_path in paths:
+        abs_path = file_path.resolve()
+        try:
+            rel_path = str(abs_path.relative_to(base))
+        except ValueError:
+            warnings.append(f"Skipped (outside base directory): {abs_path}")
+            continue
+
+        try:
+            post = frontmatter.load(abs_path)
+            current = post.get(property)
+
+            # Property doesn't exist: skip
+            if current is None:
+                continue
+
+            # Property is not an array: skip with warning
+            if not isinstance(current, list):
+                warnings.append(f"Skipped {rel_path}: '{property}' is not an array")
+                continue
+
+            # Old value doesn't exist: skip
+            if old_value not in current:
+                continue
+
+            # Replace value
+            idx = current.index(old_value)
+            current[idx] = new_value
+            frontmatter.dump(post, abs_path)
+            updated_files.append(rel_path)
+
+        except Exception as e:
+            warnings.append(f"Failed to update {rel_path}: {e}")
+
+    response: dict[str, Any] = {
+        "updated_count": len(updated_files),
+        "updated_files": updated_files,
+    }
+    if warnings:
+        response["warnings"] = warnings
+
+    return response
+
+
+@mcp.tool()
+def batch_array_sort(
+    glob: str,
+    property: str,
+    reverse: bool = False,
+) -> dict[str, Any]:
+    """Sort an array property in multiple files.
+
+    Args:
+        glob: Glob pattern relative to base directory (e.g. "atoms/**/*.md").
+        property: Name of the array property.
+        reverse: If True, sort in descending order. Default is ascending.
+
+    Returns:
+        Dict with updated_count, updated_files, and warnings.
+
+    Notes:
+        - If property doesn't exist, file is skipped.
+        - If array is empty, file is skipped.
+        - If array is already sorted, file is skipped.
+        - If property is not an array, file is skipped with a warning.
+        - Files are only included in updated_files if actually modified.
+    """
+
+    base = get_base_dir().resolve()
+    paths = collect_files(glob)
+
+    updated_files: list[str] = []
+    warnings: list[str] = []
+
+    for file_path in paths:
+        abs_path = file_path.resolve()
+        try:
+            rel_path = str(abs_path.relative_to(base))
+        except ValueError:
+            warnings.append(f"Skipped (outside base directory): {abs_path}")
+            continue
+
+        try:
+            post = frontmatter.load(abs_path)
+            current = post.get(property)
+
+            # Property doesn't exist: skip
+            if current is None:
+                continue
+
+            # Property is not an array: skip with warning
+            if not isinstance(current, list):
+                warnings.append(f"Skipped {rel_path}: '{property}' is not an array")
+                continue
+
+            # Empty array or single element: skip (already sorted)
+            if len(current) <= 1:
+                continue
+
+            # Check if already sorted using pairwise comparison
+            if not reverse:
+                is_sorted = all(
+                    current[i] <= current[i + 1] for i in range(len(current) - 1)
+                )
+            else:
+                is_sorted = all(
+                    current[i] >= current[i + 1] for i in range(len(current) - 1)
+                )
+            if is_sorted:
+                continue
+
+            # Sort
+            post[property] = sorted(current, reverse=reverse)
+            frontmatter.dump(post, abs_path)
+            updated_files.append(rel_path)
+
+        except Exception as e:
+            warnings.append(f"Failed to update {rel_path}: {e}")
+
+    response: dict[str, Any] = {
+        "updated_count": len(updated_files),
+        "updated_files": updated_files,
+    }
+    if warnings:
+        response["warnings"] = warnings
+
+    return response
+
+
+def main() -> None:
+    """Entry point for the MCP server."""
+    global _base_dir
+
+    # Parse --base-dir argument
+    args = sys.argv[1:]
+    if "--base-dir" not in args:
+        print("Error: --base-dir argument is required", file=sys.stderr)
+        print("Usage: frontmatter-mcp --base-dir /path", file=sys.stderr)
+        sys.exit(1)
+
+    base_dir_idx = args.index("--base-dir")
+    if base_dir_idx + 1 >= len(args):
+        print("Error: --base-dir requires a value", file=sys.stderr)
+        sys.exit(1)
+
+    base_dir_str = args[base_dir_idx + 1]
+    _base_dir = Path(base_dir_str).resolve()
+
+    if not _base_dir.is_dir():
+        print(f"Error: Base directory does not exist: {_base_dir}", file=sys.stderr)
+        sys.exit(1)
+
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

frontmatter_mcp-0.2.0.dist-info/METADATA

@@ -0,0 +1,264 @@
+Metadata-Version: 2.4
+Name: frontmatter-mcp
+Version: 0.2.0
+Summary: MCP server for querying Markdown frontmatter with DuckDB SQL
+Project-URL: Homepage, https://github.com/kzmshx/frontmatter-mcp
+Project-URL: Repository, https://github.com/kzmshx/frontmatter-mcp
+Author: kzmshx
+License: MIT License
+        
+        Copyright (c) 2025 kzmshx
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: duckdb>=1.0.0
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: pyarrow>=22.0.0
+Requires-Dist: python-frontmatter>=1.0.0
+Description-Content-Type: text/markdown
+
+# frontmatter-mcp
+
+An MCP server for querying Markdown frontmatter with DuckDB SQL.
+
+## Installation
+
+```bash
+uv tool install git+https://github.com/kzmshx/frontmatter-mcp.git
+```
+
+## Configuration
+
+```json
+{
+  "mcpServers": {
+    "frontmatter": {
+      "command": "frontmatter-mcp",
+      "args": ["--base-dir", "/path/to/markdown/directory"]
+    }
+  }
+}
+```
+
+## Tools
+
+### query_inspect
+
+Get schema information from frontmatter across files.
+
+| Parameter | Type   | Description                             |
+| --------- | ------ | --------------------------------------- |
+| `glob`    | string | Glob pattern relative to base directory |
+
+**Example:**
+
+```json
+// Input
+{ "glob": "**/*.md" }
+
+// Output
+{
+  "file_count": 186,
+  "schema": {
+    "date": { "type": "string", "count": 180, "nullable": true },
+    "tags": { "type": "array", "count": 150, "nullable": true }
+  }
+}
+```
+
+### query
+
+Query frontmatter data with DuckDB SQL.
+
+| Parameter | Type   | Description                                |
+| --------- | ------ | ------------------------------------------ |
+| `glob`    | string | Glob pattern relative to base directory    |
+| `sql`     | string | DuckDB SQL query referencing `files` table |
+
+**Example:**
+
+```json
+// Input
+{
+  "glob": "**/*.md",
+  "sql": "SELECT path, date FROM files WHERE date >= '2025-11-01' ORDER BY date DESC"
+}
+
+// Output
+{
+  "columns": ["path", "date"],
+  "row_count": 24,
+  "results": [
+    {"path": "daily/2025-11-28.md", "date": "2025-11-28"},
+    {"path": "daily/2025-11-27.md", "date": "2025-11-27"}
+  ]
+}
+```
+
+### update
+
+Update frontmatter properties in a single file.
+
+| Parameter | Type     | Description                          |
+| --------- | -------- | ------------------------------------ |
+| `path`    | string   | File path relative to base directory |
+| `set`     | object   | Properties to add or overwrite       |
+| `unset`   | string[] | Property names to remove             |
+
+**Example:**
+
+```json
+// Input
+{ "path": "notes/idea.md", "set": {"status": "published"} }
+
+// Output
+{ "path": "notes/idea.md", "frontmatter": {"title": "Idea", "status": "published"} }
+```
+
+### batch_update
+
+Update frontmatter properties in multiple files.
+
+| Parameter | Type     | Description                             |
+| --------- | -------- | --------------------------------------- |
+| `glob`    | string   | Glob pattern relative to base directory |
+| `set`     | object   | Properties to add or overwrite          |
+| `unset`   | string[] | Property names to remove                |
+
+**Example:**
+
+```json
+// Input
+{ "glob": "drafts/*.md", "set": {"status": "review"} }
+
+// Output
+{ "updated_count": 5, "updated_files": ["drafts/a.md", "drafts/b.md", ...] }
+```
+
+### batch_array_add
+
+Add a value to an array property in multiple files.
+
+| Parameter          | Type   | Description                                |
+| ------------------ | ------ | ------------------------------------------ |
+| `glob`             | string | Glob pattern relative to base directory    |
+| `property`         | string | Name of the array property                 |
+| `value`            | any    | Value to add                               |
+| `allow_duplicates` | bool   | Allow duplicate values (default: false)    |
+
+**Example:**
+
+```json
+// Input
+{ "glob": "**/*.md", "property": "tags", "value": "reviewed" }
+
+// Output
+{ "updated_count": 42, "updated_files": ["a.md", "b.md", ...] }
+```
+
+### batch_array_remove
+
+Remove a value from an array property in multiple files.
+
+| Parameter  | Type   | Description                             |
+| ---------- | ------ | --------------------------------------- |
+| `glob`     | string | Glob pattern relative to base directory |
+| `property` | string | Name of the array property              |
+| `value`    | any    | Value to remove                         |
+
+**Example:**
+
+```json
+// Input
+{ "glob": "**/*.md", "property": "tags", "value": "draft" }
+
+// Output
+{ "updated_count": 15, "updated_files": ["a.md", "b.md", ...] }
+```
+
+### batch_array_replace
+
+Replace a value in an array property in multiple files.
+
+| Parameter   | Type   | Description                             |
+| ----------- | ------ | --------------------------------------- |
+| `glob`      | string | Glob pattern relative to base directory |
+| `property`  | string | Name of the array property              |
+| `old_value` | any    | Value to replace                        |
+| `new_value` | any    | New value                               |
+
+**Example:**
+
+```json
+// Input
+{ "glob": "**/*.md", "property": "tags", "old_value": "draft", "new_value": "review" }
+
+// Output
+{ "updated_count": 10, "updated_files": ["a.md", "b.md", ...] }
+```
+
+### batch_array_sort
+
+Sort an array property in multiple files.
+
+| Parameter  | Type   | Description                             |
+| ---------- | ------ | --------------------------------------- |
+| `glob`     | string | Glob pattern relative to base directory |
+| `property` | string | Name of the array property              |
+| `reverse`  | bool   | Sort in descending order (default: false)|
+
+**Example:**
+
+```json
+// Input
+{ "glob": "**/*.md", "property": "tags" }
+
+// Output
+{ "updated_count": 20, "updated_files": ["a.md", "b.md", ...] }
+```
+
+## Technical Notes
+
+### All Values Are Strings
+
+All frontmatter values are passed to DuckDB as strings. Use `TRY_CAST` in SQL for type conversion when needed.
+
+```sql
+SELECT * FROM files
+WHERE TRY_CAST(date AS DATE) >= '2025-11-01'
+```
+
+### Arrays Are JSON Strings
+
+Arrays like `tags: [ai, python]` are stored as JSON strings `'["ai", "python"]'`. Use `from_json()` and `UNNEST` to expand them.
+
+```sql
+SELECT path, tag
+FROM files, UNNEST(from_json(tags, '[""]')) AS t(tag)
+WHERE tag = 'ai'
+```
+
+### Templater Expression Support
+
+Files containing Obsidian Templater expressions (e.g., `<% tp.date.now("YYYY-MM-DD") %>`) are handled gracefully. These expressions are treated as strings and naturally excluded by date filtering.
+
+## License
+
+MIT

frontmatter_mcp-0.2.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+frontmatter_mcp/__init__.py,sha256=xwUmLf7DN4rwjk-xtCtMlO3LUI1mBYjhq3QGxkGcRSY,41
+frontmatter_mcp/frontmatter.py,sha256=yBkhxrm5q9QJkFkopJTO4eWmyT5vwUZt14y-d7sHFwE,2552
+frontmatter_mcp/query.py,sha256=uEVVscmrAUaS70O-ETxl45uEgYwPHtnSgYWPzJyjvH8,2108
+frontmatter_mcp/schema.py,sha256=kw23ahynDa7hrFlzXSjDtqODlZU6-aw1sg-vF39MfSs,1786
+frontmatter_mcp/server.py,sha256=5C4hxpCVfRFRDpmVVncCOhKSizpQ902QGM23NkggT-o,15056
+frontmatter_mcp-0.2.0.dist-info/METADATA,sha256=yQgtyHuVjSNSACiyHnDNhx4NXHgd5M-1jz_FsrmMR0s,7707
+frontmatter_mcp-0.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+frontmatter_mcp-0.2.0.dist-info/entry_points.txt,sha256=56y0yYs0A2wNqpKFSLeZPK5lo4WTseW56o-d7OSrf90,64
+frontmatter_mcp-0.2.0.dist-info/licenses/LICENSE,sha256=09zWP4vFnSQF9-F1Z8jtzfC6Fw9gOOjBU-1pFiXxPIo,1063
+frontmatter_mcp-0.2.0.dist-info/RECORD,,

frontmatter_mcp-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

frontmatter_mcp-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+frontmatter-mcp = frontmatter_mcp.server:main

frontmatter_mcp-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 kzmshx
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.