daimyo 1.0.0__py3-none-any.whl

daimyo/__init__.py

@@ -0,0 +1,11 @@
+"""
+Daimyo - Rules Server for Agents
+
+A Python server providing rules to agents through REST and MCP interfaces.
+Supports scope-based rules with inheritance, categories for filtering,
+and server federation for distributed rule management.
+"""
+
+__version__ = "1.0.0"
+
+__all__ = ["__version__"]

daimyo/__main__.py

@@ -0,0 +1,205 @@
+"""CLI entry point for Daimyo rules server."""
+
+from enum import Enum
+
+import typer
+import uvicorn
+
+from daimyo import __version__
+from daimyo.config import settings
+from daimyo.infrastructure.logging import setup_logging
+
+app = typer.Typer(
+    name="daimyo",
+    help="Daimyo - Rules Server for Agents",
+    add_completion=False,
+)
+
+
+class TransportType(str, Enum):
+    """MCP transport types."""
+
+    STDIO = "stdio"
+    SSE = "sse"
+
+
+def version_callback(value: bool) -> None:
+    """Print version and exit.
+
+    :param value: Whether version flag was set
+    :type value: bool
+    :rtype: None
+    :raises typer.Exit: Always exits after printing version
+    """
+    if value:
+        typer.echo(f"daimyo version {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(
+        False,
+        "--version",
+        "-v",
+        callback=version_callback,
+        is_eager=True,
+        help="Show version and exit",
+    ),
+) -> None:
+    """Daimyo - Rules Server for Agents.
+
+    :param version: Show version flag
+    :type version: bool
+    :rtype: None
+    """
+    pass
+
+
+@app.command()
+def serve(
+    host: str = typer.Option(
+        None,
+        "--host",
+        help=f"Host to bind to (default: {settings.REST_HOST})",
+    ),
+    port: int = typer.Option(
+        None,
+        "--port",
+        help=f"Port to bind to (default: {settings.REST_PORT})",
+    ),
+    reload: bool = typer.Option(
+        False,
+        "--reload",
+        help="Enable auto-reload for development",
+    ),
+) -> None:
+    """Start the REST API server.
+
+    :param host: Host to bind to
+    :type host: str
+    :param port: Port to bind to
+    :type port: int
+    :param reload: Enable auto-reload for development
+    :type reload: bool
+    :rtype: None
+    """
+    setup_logging()
+
+    resolved_host = host or settings.REST_HOST
+    resolved_port = port or settings.REST_PORT
+
+    typer.echo(f"Starting Daimyo REST API server on {resolved_host}:{resolved_port}")
+    typer.echo(f"API documentation available at http://{resolved_host}:{resolved_port}/docs")
+
+    uvicorn.run(
+        "daimyo.presentation.rest.app:app",
+        host=resolved_host,
+        port=resolved_port,
+        reload=reload,
+        log_config=None,
+    )
+
+
+@app.command()
+def mcp(
+    transport: TransportType = typer.Option(
+        None,
+        "--transport",
+        help=f"MCP transport type (default: {settings.MCP_TRANSPORT})",
+    ),
+) -> None:
+    """Start the MCP server.
+
+    :param transport: MCP transport type
+    :type transport: TransportType
+    :rtype: None
+    """
+    setup_logging()
+
+    resolved_transport = transport.value if transport else settings.MCP_TRANSPORT
+
+    typer.echo(f"Starting Daimyo MCP server with {resolved_transport} transport")
+
+    from daimyo.presentation.mcp.server import mcp as mcp_server
+
+    if resolved_transport == "stdio":
+        mcp_server.run(transport="stdio")
+    else:
+        mcp_server.run(transport="sse")
+
+
+@app.command()
+def list_scopes() -> None:
+    """List all available scopes.
+
+    :rtype: None
+    """
+    setup_logging()
+
+    from daimyo.infrastructure.di import get_container
+
+    container = get_container()
+    repo = container.scope_repository()
+    scopes = repo.list_scopes()
+
+    if not scopes:
+        typer.echo("No scopes found.")
+        return
+
+    typer.echo("Available scopes:")
+    for scope_name in scopes:
+        typer.echo(f"  - {scope_name}")
+
+
+@app.command()
+def show(
+    scope_name: str = typer.Argument(
+        ...,
+        help="Name of the scope to show",
+    ),
+) -> None:
+    """Show details of a specific scope.
+
+    :param scope_name: Name of the scope to show
+    :type scope_name: str
+    :rtype: None
+    """
+    setup_logging()
+
+    from daimyo.infrastructure.di import get_container
+
+    try:
+        container = get_container()
+        repo = container.scope_repository()
+        scope = repo.get_scope(scope_name)
+
+        if scope is None:
+            typer.echo(f"Error: Scope '{scope_name}' not found", err=True)
+            raise typer.Exit(code=1)
+
+        typer.echo(f"# Scope: {scope.metadata.name}")
+        typer.echo(f"\nDescription: {scope.metadata.description}")
+        if scope.metadata.parent:
+            typer.echo(f"Parent: {scope.metadata.parent}")
+        if scope.metadata.tags:
+            typer.echo(f"Tags: {scope.metadata.tags}")
+
+        typer.echo(f"\nCommandments: {len(scope.commandments.categories)} categories")
+        typer.echo(f"Suggestions: {len(scope.suggestions.categories)} categories")
+
+    except Exception as e:
+        typer.echo(f"Error: {str(e)}", err=True)
+        raise typer.Exit(code=1)
+
+
+def cli() -> None:
+    """Entry point for the CLI.
+
+    :rtype: None
+    """
+    app()
+
+
+if __name__ == "__main__":
+    cli()

daimyo/application/__init__.py

@@ -0,0 +1 @@
+"""Application layer - business logic and use cases."""

daimyo/application/filtering/__init__.py

@@ -0,0 +1,5 @@
+"""Category filtering services."""
+
+from .category_filter import CategoryFilterService
+
+__all__ = ["CategoryFilterService"]

daimyo/application/filtering/category_filter.py

@@ -0,0 +1,81 @@
+"""Category filtering service for scopes."""
+
+from __future__ import annotations
+
+from daimyo.application.rule_service import RuleMergingService
+from daimyo.domain import MergedScope
+from daimyo.infrastructure.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class CategoryFilterService:
+    """Service for filtering categories in scopes."""
+
+    def __init__(self, rule_service: RuleMergingService):
+        """Initialize category filter service.
+
+        :param rule_service: Rule merging service for filtering
+        :type rule_service: RuleMergingService
+        """
+        self.rule_service = rule_service
+
+    @staticmethod
+    def parse_category_string(categories: str | None) -> list[str]:
+        """Parse comma-separated category string into list.
+
+        :param categories: Comma-separated category string (e.g., "python.web,python.testing")
+        :type categories: str | None
+        :returns: List of category filters, empty list if None
+        :rtype: list[str]
+        """
+        if not categories:
+            return []
+        return [c.strip() for c in categories.split(",")]
+
+    def apply_filters(
+        self, scope: MergedScope, category_filters: list[str] | None
+    ) -> MergedScope:
+        """Apply category filters to a merged scope.
+
+        Filters both commandments and suggestions by the given category prefixes.
+        If no filters provided, returns scope unchanged.
+
+        :param scope: Merged scope to filter
+        :type scope: MergedScope
+        :param category_filters: List of category prefix filters
+        :type category_filters: list[str] | None
+        :returns: Scope with filtered categories
+        :rtype: MergedScope
+        """
+        if not category_filters:
+            return scope
+
+        logger.debug(f"Filtering scope by categories: {category_filters}")
+
+        scope.commandments = self.rule_service.filter_categories(
+            scope.commandments, category_filters
+        )
+        scope.suggestions = self.rule_service.filter_categories(
+            scope.suggestions, category_filters
+        )
+
+        return scope
+
+    def filter_from_string(self, scope: MergedScope, categories: str | None) -> MergedScope:
+        """Parse category string and apply filters to scope.
+
+        Convenience method combining parse_category_string and apply_filters.
+
+        :param scope: Merged scope to filter
+        :type scope: MergedScope
+        :param categories: Comma-separated category string
+        :type categories: str | None
+        :returns: Scope with filtered categories
+        :rtype: MergedScope
+        """
+        category_list = self.parse_category_string(categories)
+        return self.apply_filters(scope, category_list)
+
+
+__all__ = ["CategoryFilterService"]

daimyo/application/formatters/__init__.py

@@ -0,0 +1,8 @@
+"""Output formatters for different response formats."""
+
+from .json_formatter import JsonFormatter
+from .markdown_formatter import MarkdownFormatter
+from .tree_builder import CategoryTreeBuilder
+from .yaml_formatter import YamlMultiDocFormatter
+
+__all__ = ["YamlMultiDocFormatter", "JsonFormatter", "MarkdownFormatter", "CategoryTreeBuilder"]

daimyo/application/formatters/json_formatter.py

@@ -0,0 +1,53 @@
+"""JSON formatter for API responses."""
+
+from typing import Any
+
+from daimyo.domain import MergedScope, RuleSet
+
+
+class JsonFormatter:
+    """Format merged scope as JSON.
+
+    Output contains structured JSON with metadata, commandments, and suggestions.
+    """
+
+    def format(self, scope: MergedScope) -> dict[str, Any]:
+        """Format merged scope as JSON-serializable dictionary.
+
+        :param scope: The merged scope to format
+        :type scope: MergedScope
+        :returns: Dictionary ready for JSON serialization
+        :rtype: Dict[str, Any]
+        """
+        return {
+            "metadata": {
+                "name": scope.metadata.name,
+                "description": scope.metadata.description,
+                "parent": scope.metadata.parent,
+                "tags": scope.metadata.tags,
+                "sources": scope.sources,
+            },
+            "commandments": self._format_ruleset(scope.commandments),
+            "suggestions": self._format_ruleset(scope.suggestions),
+        }
+
+    def _format_ruleset(self, ruleset: RuleSet) -> dict[str, dict[str, Any]]:
+        """Format a ruleset as flat dictionary with category keys.
+
+        :param ruleset: The ruleset to format
+        :type ruleset: RuleSet
+        :returns: Dictionary mapping category keys to their data
+        :rtype: Dict[str, Dict[str, Any]]
+        """
+        result = {}
+
+        for category in ruleset.categories.values():
+            result[str(category.key)] = {
+                "when": category.when,
+                "rules": [rule.text for rule in category.rules],
+            }
+
+        return result
+
+
+__all__ = ["JsonFormatter"]

daimyo/application/formatters/markdown_formatter.py

@@ -0,0 +1,149 @@
+"""Markdown formatter for MCP API responses."""
+
+from daimyo.application.formatters.tree_builder import CategoryTreeBuilder
+from daimyo.domain import Category, MergedScope, RuleSet
+
+
+class MarkdownFormatter:
+    """Format merged scope as markdown with hierarchy and MUST/SHOULD markers.
+
+    Features:
+    - Nested headings for category hierarchy (## python, ### web, #### testing)
+    - MUST markers for commandments, SHOULD markers for suggestions
+    - Include 'when' descriptions for each category
+    """
+
+    def format(self, scope: MergedScope) -> str:
+        """Format merged scope as markdown.
+
+        :param scope: The merged scope to format
+        :type scope: MergedScope
+        :returns: Markdown-formatted string
+        :rtype: str
+        """
+        lines = []
+
+        lines.append(f"# Rules for {scope.metadata.name}\n")
+        if scope.metadata.description:
+            lines.append(f"{scope.metadata.description}\n")
+
+        merged_tree = CategoryTreeBuilder.merge_trees(
+            list(scope.commandments.categories.values()),
+            list(scope.suggestions.categories.values())
+        )
+
+        lines.extend(self._format_merged_tree(merged_tree, depth=2))
+
+        return "\n".join(lines)
+
+    def _format_merged_tree(
+        self, tree: dict[str, dict], depth: int, path: str = ""
+    ) -> list[str]:
+        """Format merged category tree with both MUST and SHOULD rules.
+
+        :param tree: Merged category tree
+        :type tree: Dict[str, Dict]
+        :param depth: Current heading depth
+        :type depth: int
+        :param path: Current category path
+        :type path: str
+        :returns: List of markdown lines
+        :rtype: List[str]
+        """
+        lines = []
+
+        for key, node in sorted(tree.items()):
+            heading = "#" * depth
+            current_path = f"{path}.{key}" if path else key
+            lines.append(f"{heading} {key}\n")
+
+            commandments = node.get("_commandments", [])
+            suggestions = node.get("_suggestions", [])
+
+            when_description = None
+            for category in commandments:
+                if category.when:
+                    when_description = category.when
+                    break
+            if not when_description:
+                for category in suggestions:
+                    if category.when:
+                        when_description = category.when
+                        break
+
+            if when_description:
+                lines.append(f"*{when_description}*\n")
+
+            for category in commandments:
+                for rule in category.rules:
+                    lines.append(f"- **MUST**: {rule.text}")
+
+            for category in suggestions:
+                for rule in category.rules:
+                    lines.append(f"- **SHOULD**: {rule.text}")
+
+            if commandments or suggestions:
+                lines.append("")
+
+            children = node.get("_children", {})
+            if children:
+                lines.extend(self._format_merged_tree(children, depth + 1, current_path))
+
+        return lines
+
+    def _format_ruleset_markdown(self, ruleset: RuleSet, marker: str) -> str:
+        """Format a ruleset as markdown with hierarchical headings.
+
+        :param ruleset: The ruleset to format
+        :type ruleset: RuleSet
+        :param marker: The marker to use (MUST or SHOULD)
+        :type marker: str
+        :returns: Markdown string
+        :rtype: str
+        """
+        lines = []
+
+        category_tree = CategoryTreeBuilder.build_tree(list(ruleset.categories.values()))
+
+        lines.extend(self._format_tree(category_tree, marker, depth=3))
+
+        return "\n".join(lines)
+
+    def _format_tree(
+        self, tree: dict[str, dict], marker: str, depth: int, path: str = ""
+    ) -> list[str]:
+        """Recursively format category tree as markdown.
+
+        :param tree: Category tree
+        :type tree: Dict[str, Dict]
+        :param marker: MUST or SHOULD
+        :type marker: str
+        :param depth: Current heading depth
+        :type depth: int
+        :param path: Current category path
+        :type path: str
+        :returns: List of markdown lines
+        :rtype: List[str]
+        """
+        lines = []
+
+        for key, node in sorted(tree.items()):
+            heading = "#" * depth
+            current_path = f"{path}.{key}" if path else key
+            lines.append(f"{heading} {key}\n")
+
+            for category in node.get("_categories", []):
+                lines.append(f"*{category.when}*\n")
+
+                for rule in category.rules:
+                    lines.append(f"- **{marker}**: {rule.text}")
+                lines.append("")
+
+            children = node.get("_children", {})
+            if children:
+                lines.extend(self._format_tree(children, marker, depth + 1, current_path))
+
+        return lines
+
+
+__all__ = ["MarkdownFormatter"]

daimyo/application/formatters/tree_builder.py

@@ -0,0 +1,105 @@
+"""Category tree building utilities for formatters."""
+
+from __future__ import annotations
+
+from daimyo.domain import Category
+
+
+class CategoryTreeBuilder:
+    """Utility for building hierarchical category trees."""
+
+    @staticmethod
+    def build_tree(categories: list[Category]) -> dict[str, dict]:
+        """Build a hierarchical tree from flat category list.
+
+        :param categories: List of categories
+        :type categories: list[Category]
+        :returns: Nested dictionary representing category hierarchy
+        :rtype: dict[str, dict]
+        """
+        tree: dict[str, dict] = {}
+
+        for category in categories:
+            parts = category.key.parts
+            current = tree
+
+            for i, part in enumerate(parts):
+                if part not in current:
+                    current[part] = {"_categories": [], "_children": {}}
+
+                if i == len(parts) - 1:
+                    current[part]["_categories"].append(category)
+                else:
+                    current = current[part]["_children"]
+
+        return tree
+
+    @staticmethod
+    def merge_trees(commandments: list[Category], suggestions: list[Category]) -> dict[str, dict]:
+        """Merge commandment and suggestion categories into a single tree.
+
+        :param commandments: List of commandment categories
+        :type commandments: list[Category]
+        :param suggestions: List of suggestion categories
+        :type suggestions: list[Category]
+        :returns: Merged tree with both commandments and suggestions
+        :rtype: dict[str, dict]
+        """
+        tree: dict[str, dict] = {}
+
+        for category in commandments:
+            parts = category.key.parts
+            current = tree
+
+            for i, part in enumerate(parts):
+                if part not in current:
+                    current[part] = {"_commandments": [], "_suggestions": [], "_children": {}}
+
+                if i == len(parts) - 1:
+                    current[part]["_commandments"].append(category)
+                else:
+                    current = current[part]["_children"]
+
+        for category in suggestions:
+            parts = category.key.parts
+            current = tree
+
+            for i, part in enumerate(parts):
+                if part not in current:
+                    current[part] = {"_commandments": [], "_suggestions": [], "_children": {}}
+
+                if i == len(parts) - 1:
+                    current[part]["_suggestions"].append(category)
+                else:
+                    current = current[part]["_children"]
+
+        return tree
+
+    @staticmethod
+    def build_index_tree(categories: list[tuple[str, str]]) -> dict[str, dict]:
+        """Build tree for index display from category key-when pairs.
+
+        :param categories: List of (category_key, when_description) tuples
+        :type categories: list[tuple[str, str]]
+        :returns: Nested dictionary for rendering category index
+        :rtype: dict[str, dict]
+        """
+        tree: dict[str, dict] = {}
+
+        for category_key, when_desc in categories:
+            parts = category_key.split(".")
+            current = tree
+
+            for i, part in enumerate(parts):
+                if part not in current:
+                    current[part] = {"_children": {}, "_key": ".".join(parts[: i + 1])}
+
+                if i == len(parts) - 1:
+                    current[part]["_when"] = when_desc
+
+                current = current[part]["_children"]
+
+        return tree
+
+
+__all__ = ["CategoryTreeBuilder"]