dddlint 0.1.2__py3-none-any.whl

dddlint/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.2"

dddlint/check.py

@@ -0,0 +1,135 @@
+import re
+from collections import defaultdict
+from dataclasses import dataclass
+from fnmatch import fnmatch
+from pathlib import Path
+
+from .config import Config, Context, SynonymGroup
+from .extract import Definition
+
+_BOUNDARY = r"[-_\s]+|(?<=[a-z0-9])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])"
+
+
+@dataclass(frozen=True, slots=True)
+class Finding:
+    path: Path
+    line: int
+    name: str
+    rule: str
+    message: str
+    col: int = 0
+    fix: str | None = None
+
+
+def _apply_fix(name: str, old_token: str, new_token: str) -> str:
+    assert name and old_token, "name and old_token must be non-empty"
+    assert new_token is not None, "new_token must not be None"
+
+    def _recase(m: re.Match) -> str:
+        assert m is not None, "match must not be None"
+        s = m.group()
+        assert s, "matched text must be non-empty"
+        if s.isupper():
+            return new_token.upper()
+        if s[0].isupper():
+            return new_token.capitalize()
+        return new_token
+
+    return re.sub(re.escape(old_token), _recase, name, flags=re.IGNORECASE)
+
+
+def tokenise(name: str) -> tuple[str, ...]:
+    assert name is not None, "name must not be None"
+    assert isinstance(name, str), "name must be a string"
+    return tuple(p.lower() for p in re.split(_BOUNDARY, name) if p)
+
+
+def _scoped(context: Context, path: Path) -> bool:
+    assert context is not None, "context must not be None"
+    assert isinstance(path, Path), "path must be a Path object"
+    return any(fnmatch(str(path), pattern) for pattern in context.include)
+
+
+def _alias_map(groups: list[SynonymGroup]) -> dict[str, str]:
+    assert groups is not None, "groups must not be None"
+    assert isinstance(groups, list), "groups must be a list"
+    out: dict[str, str] = {}
+    for group in groups:
+        for alias in group.aliases:
+            out[alias.lower()] = group.canonical
+    return out
+
+
+def _check_one(
+    definition: Definition,
+    forbidden: set[str],
+    aliases: dict[str, str],
+    enforce_canonical: bool,
+) -> list[Finding]:
+    assert definition is not None, "definition must not be None"
+    assert isinstance(forbidden, set), "forbidden must be a set"
+    out: list[Finding] = []
+    for token in tokenise(definition.name):
+        if token in forbidden:
+            out.append(
+                Finding(
+                    definition.path,
+                    definition.line,
+                    definition.name,
+                    "forbidden",
+                    f"uses banned term '{token}'",
+                    col=definition.col,
+                )
+            )
+        if enforce_canonical and token in aliases:
+            canonical = aliases[token]
+            out.append(
+                Finding(
+                    definition.path,
+                    definition.line,
+                    definition.name,
+                    "alias",
+                    f"'{token}' is not the canonical term, use '{canonical}'",
+                    col=definition.col,
+                    fix=_apply_fix(definition.name, token, canonical),
+                )
+            )
+    return out
+
+
+def check(definitions: list[Definition], config: Config) -> list[Finding]:
+    assert definitions is not None, "definitions must not be None"
+    assert config is not None, "config must not be None"
+    out: list[Finding] = []
+    base_forbidden = {t.lower() for t in config.forbidden}
+    base_aliases = _alias_map(config.synonyms)
+
+    for definition in definitions:
+        forbidden = set(base_forbidden)
+        aliases = dict(base_aliases)
+        for scope in config.domains + config.contexts:
+            if _scoped(scope, definition.path):
+                forbidden |= {t.lower() for t in scope.forbidden}
+                aliases |= _alias_map(scope.synonyms)
+        out.extend(_check_one(definition, forbidden, aliases, config.enforce_canonical))
+
+    by_tokens: dict[tuple[str, ...], set[str]] = defaultdict(set)
+    first: dict[tuple[str, ...], Definition] = {}
+    for definition in definitions:
+        key = tuple(sorted(tokenise(definition.name)))
+        by_tokens[key].add(definition.name)
+        first.setdefault(key, definition)
+    for key, names in by_tokens.items():
+        if len(names) > 1:
+            definition = first[key]
+            spellings = ", ".join(sorted(names))
+            out.append(
+                Finding(
+                    definition.path,
+                    definition.line,
+                    definition.name,
+                    "drift",
+                    f"one concept spelled several ways: {spellings}",
+                )
+            )
+    return out

dddlint/cli.py

@@ -0,0 +1,146 @@
+from collections import defaultdict
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+from .check import Finding, check
+from .config import load_config
+from .config_check import check_config
+from .extract import Definition, definitions, language_for
+
+app = typer.Typer(
+    add_completion=False,
+    no_args_is_help=True,
+    context_settings={"help_option_names": ["-h", "--help"]},
+)
+console = Console()
+
+
+def _version(value: bool = False) -> bool:
+    assert isinstance(value, bool), "value must be a bool"
+    if not value:
+        return value
+    from . import __version__
+
+    assert __version__, "version string must be non-empty"
+    typer.echo(__version__)
+    raise typer.Exit()
+
+
+@app.callback()
+def _cli(
+    version: Annotated[
+        bool, typer.Option("--version", "-v", callback=_version, is_eager=True)
+    ] = False,
+) -> None:
+    """Polyglot ubiquitous language linter for codebases and coding agents."""
+    assert isinstance(version, bool), "version flag must be a bool"
+    assert app is not None, "app must be initialized"
+
+
+SKIP = {".git", ".venv", "node_modules", "__pycache__", "target", "dist", "build"}
+DEFAULT_CONFIG = Path("dddlint.yaml")
+
+RULE_STYLE: dict[str, str] = {
+    "forbidden": "bold red",
+    "alias": "bold yellow",
+    "drift": "bold cyan",
+    "config:forbidden-canonical-clash": "bold red",
+    "config:alias-conflict": "bold yellow",
+    "config:duplicate-name": "bold cyan",
+}
+
+
+def _resolve(root: Path | None, config: Path | None) -> tuple[Path, Path]:
+    assert root is None or isinstance(root, Path), "root must be a Path or None"
+    assert config is None or isinstance(config, Path), "config must be a Path or None"
+    if root is None:
+        root = Path.cwd()
+    if config is None:
+        config = root / DEFAULT_CONFIG
+        if not config.exists():
+            config = Path.cwd() / DEFAULT_CONFIG
+    return root, config
+
+
+def _print_findings(findings: list[Finding]) -> None:
+    assert findings is not None, "findings must not be None"
+    assert isinstance(findings, list), "findings must be a list"
+    by_file: dict[Path, list[Finding]] = defaultdict(list)
+    for f in findings:
+        by_file[f.path].append(f)
+    for path, file_findings in by_file.items():
+        console.print(f"\n[bold white]{path}[/bold white]")
+        console.rule(style="dim")
+        for f in file_findings:
+            style = RULE_STYLE.get(f.rule, "bold white")
+            console.print(
+                f"  [dim]{f.line:>4}[/dim]  [{style}]{f.rule:<10}[/{style}]"
+                f"  [bold]{f.name}[/bold]  [dim]{f.message}[/dim]"
+            )
+
+
+@app.command()
+def lint(
+    root: Annotated[Path | None, typer.Argument()] = None,
+    config: Annotated[Path | None, typer.Option()] = None,
+) -> None:
+    """Lint a codebase for DDD ubiquitous language violations."""
+    root, config = _resolve(root, config)
+    assert isinstance(root, Path), "resolved root must be a Path"
+    assert config.name, "config path must have a name"
+    settings = load_config(config)
+    extra: dict[str, str] = {}
+    collected: list[Definition] = []
+    for path in root.rglob("*"):
+        if not path.is_file() or SKIP & set(path.parts):
+            continue
+        language = language_for(path, extra)
+        if language is None:
+            continue
+        collected.extend(definitions(path, language))
+
+    findings = check_config(settings, config) + check(collected, settings)
+    if findings:
+        _print_findings(findings)
+        n = len(findings)
+        console.print(f"\n[bold red]✖ {n} finding{'s' if n != 1 else ''}[/bold red]")
+    else:
+        console.print("[bold green]✔ no findings[/bold green]")
+    raise typer.Exit(1 if findings else 0)
+
+
+@app.command()
+def html(
+    root: Annotated[Path | None, typer.Argument()] = None,
+    config: Annotated[Path | None, typer.Option()] = None,
+) -> None:
+    """Open an interactive DDD graph in the browser."""
+    import tempfile
+    import webbrowser
+
+    from .view import _generate_html
+
+    root, config = _resolve(root, config)
+    assert isinstance(root, Path), "resolved root must be a Path"
+    assert config.name, "config path must have a name"
+    settings = load_config(config)
+    content = _generate_html(settings)
+    with tempfile.NamedTemporaryFile(suffix=".html", delete=False, mode="w") as f:
+        f.write(content)
+        path = f.name
+    webbrowser.open(f"file://{path}")
+
+
+@app.command()
+def lsp(
+    root: Annotated[Path | None, typer.Argument()] = None,
+) -> None:
+    """Start the LSP server (stdio transport)."""
+    assert root is None or isinstance(root, Path), "root must be a Path or None"
+    from .server import main as server_main
+
+    assert callable(server_main), "server entrypoint must be callable"
+    server_main()

dddlint/config.py

@@ -0,0 +1,31 @@
+from pathlib import Path
+
+import yaml
+from pydantic import BaseModel
+
+
+class SynonymGroup(BaseModel):
+    canonical: str
+    aliases: list[str] = []
+
+
+class Context(BaseModel):
+    name: str
+    include: list[str]
+    forbidden: list[str] = []
+    synonyms: list[SynonymGroup] = []
+
+
+class Config(BaseModel):
+    similarity_threshold: float = 0.85
+    enforce_canonical: bool = True
+    forbidden: list[str] = []
+    synonyms: list[SynonymGroup] = []
+    domains: list[Context] = []
+    contexts: list[Context] = []
+
+
+def load_config(path: Path) -> Config:
+    assert path is not None, "path must not be None"
+    assert isinstance(path, Path), "path must be a Path object"
+    return Config.model_validate(yaml.safe_load(path.read_text()) or {})

dddlint/config_check.py

@@ -0,0 +1,89 @@
+from difflib import SequenceMatcher
+from pathlib import Path
+
+from .check import Finding
+from .config import Config, Context, SynonymGroup
+
+
+def _alias_map(synonyms: list[SynonymGroup]) -> dict[str, str]:
+    assert synonyms is not None, "synonyms must not be None"
+    assert isinstance(synonyms, list), "synonyms must be a list"
+    return {alias.lower(): g.canonical.lower() for g in synonyms for alias in g.aliases}
+
+
+def _forbidden_canonical_clashes(config: Config, path: Path) -> list[Finding]:
+    assert config is not None, "config must not be None"
+    assert isinstance(path, Path), "path must be a Path object"
+    forbidden = {t.lower() for t in config.forbidden}
+    canonicals = {g.canonical.lower() for g in config.synonyms}
+    return [
+        Finding(
+            path,
+            0,
+            term,
+            "config:forbidden-canonical-clash",
+            f"'{term}' is both forbidden and a canonical synonym",
+        )
+        for term in forbidden & canonicals
+    ]
+
+
+def _alias_conflicts(config: Config, path: Path) -> list[Finding]:
+    assert config is not None, "config must not be None"
+    assert isinstance(path, Path), "path must be a Path object"
+    scopes: list[tuple[str, list[SynonymGroup]]] = [("global", config.synonyms)]
+    for s in config.domains:
+        scopes.append((f"domain:{s.name}", s.synonyms))
+    for s in config.contexts:
+        scopes.append((f"context:{s.name}", s.synonyms))
+
+    out: list[Finding] = []
+    seen: dict[str, tuple[str, str]] = {}
+    for scope_name, synonyms in scopes:
+        for alias, canonical in _alias_map(synonyms).items():
+            if alias in seen and seen[alias][1] != canonical:
+                prev_scope, prev_canonical = seen[alias]
+                out.append(
+                    Finding(
+                        path,
+                        0,
+                        alias,
+                        "config:alias-conflict",
+                        f"'{alias}' → '{canonical}' in {scope_name} "
+                        f"but → '{prev_canonical}' in {prev_scope}",
+                    )
+                )
+            else:
+                seen[alias] = (scope_name, canonical)
+    return out
+
+
+def _duplicate_names(config: Config, path: Path) -> list[Finding]:
+    assert config is not None, "config must not be None"
+    assert isinstance(path, Path), "path must be a Path object"
+    out: list[Finding] = []
+    all_scopes: list[Context] = config.domains + config.contexts
+    for i, a in enumerate(all_scopes):
+        for b in all_scopes[i + 1 :]:
+            similarity = SequenceMatcher(None, a.name.lower(), b.name.lower()).ratio()
+            if similarity >= config.similarity_threshold:
+                out.append(
+                    Finding(
+                        path,
+                        0,
+                        a.name,
+                        "config:duplicate-name",
+                        f"'{a.name}' and '{b.name}' look like the same domain/context",
+                    )
+                )
+    return out
+
+
+def check_config(config: Config, path: Path) -> list[Finding]:
+    assert config is not None, "config must not be None"
+    assert isinstance(path, Path), "path must be a Path object"
+    return (
+        _forbidden_canonical_clashes(config, path)
+        + _alias_conflicts(config, path)
+        + _duplicate_names(config, path)
+    )

dddlint/extract.py

@@ -0,0 +1,82 @@
+from collections.abc import Iterable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import tree_sitter_language_pack as tslp
+
+DEFINITION_KINDS = frozenset(
+    {"Function", "Method", "Class", "Struct", "Interface", "Enum", "Trait"}
+)
+SYMBOL_KINDS = frozenset({"Variable", "Constant"})
+
+
+@dataclass(frozen=True, slots=True)
+class Definition:
+    name: str
+    kind: str
+    path: Path
+    line: int
+    col: int = 0
+    doc: str | None = None
+
+
+def _kind_name(kind: object) -> str:
+    assert kind is not None, "kind must not be None"
+    name = str(kind)
+    assert name, "kind name must be non-empty"
+    return name
+
+
+def _flatten(
+    items: Iterable[Any], path: Path, source_lines: list[str], out: list[Definition]
+) -> None:
+    assert path is not None, "path must not be None"
+    assert isinstance(out, list), "out must be a list"
+    stack: list[Any] = list(items)
+    while stack:
+        item = stack.pop(0)
+        kind = _kind_name(item.kind)
+        if item.name and kind in DEFINITION_KINDS:
+            line = item.span.start_line
+            line_text = source_lines[line] if line < len(source_lines) else ""
+            col = line_text.find(item.name)
+            out.append(Definition(item.name, kind, path, line, max(col, 0), item.doc_comment))
+        if item.children:
+            stack[:0] = list(item.children)
+
+
+def language_for(path: Path, extra: dict[str, str]) -> str | None:
+    assert isinstance(path, Path), "path must be a Path object"
+    assert extra is not None, "extra must not be None"
+    return extra.get(path.suffix) or tslp.detect_language_from_path(str(path))
+
+
+def definitions(path: Path, language: str) -> list[Definition]:
+    assert isinstance(path, Path), "path must be a Path object"
+    assert language, "language must be non-empty"
+    source = path.read_text(errors="ignore")
+    config = tslp.ProcessConfig(
+        language=language,
+        structure=True,
+        symbols=True,
+        imports=False,
+        exports=False,
+        comments=False,
+        docstrings=True,
+        diagnostics=False,
+        chunk_max_size=None,
+    )
+    result = tslp.process(source, config)
+    source_lines = source.splitlines()
+    out: list[Definition] = []
+    _flatten(result.structure, path, source_lines, out)
+    for sym in result.symbols:
+        kind = _kind_name(sym.kind)
+        if kind not in SYMBOL_KINDS:
+            continue
+        line = sym.span.start_line
+        line_text = source_lines[line] if line < len(source_lines) else ""
+        col = line_text.find(sym.name)
+        out.append(Definition(sym.name, kind, path, line, max(col, 0), sym.doc))
+    return out

dddlint/mcp_server.py

@@ -0,0 +1,76 @@
+"""MCP server for dddlint documentation.
+
+Provides documentation access via Model Context Protocol.
+Usage:
+    claude mcp add dddlint --transport stdio \\
+        python src/dddlint/mcp_server.py
+"""
+
+import logging
+from pathlib import Path
+
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+from mcp.types import Resource
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = Server("dddlint")
+
+
+@app.list_resources()
+async def list_resources() -> list[Resource]:
+    """List available documentation resources."""
+    assert app is not None, "Server must be initialized"
+
+    docs_dir = Path(__file__).parent.parent.parent / "docs"
+    assert docs_dir.exists(), "Docs directory must exist"
+
+    resources = []
+    for doc_file in docs_dir.rglob("*.md"):
+        relative_path = doc_file.relative_to(docs_dir)
+        uri_str = f"doc://dddlint/{relative_path}"
+        resources.append(
+            Resource(
+                uri=uri_str,  # type: ignore[arg-type]
+                name=str(relative_path),
+                mimeType="text/markdown",
+                description=f"Documentation: {relative_path}",
+            )
+        )
+
+    return resources
+
+
+@app.read_resource()
+async def read_resource(uri) -> str:  # type: ignore[no-untyped-def]
+    """Read documentation content."""
+    uri_str = str(uri)
+    assert uri_str is not None, "URI must not be None"
+    assert uri_str.startswith("doc://dddlint/"), "URI must be for this package"
+
+    path = uri_str.replace("doc://dddlint/", "")
+    docs_dir = Path(__file__).parent.parent.parent / "docs"
+    doc_file = docs_dir / path
+
+    assert doc_file.exists(), f"Documentation file {path} not found"
+    assert doc_file.is_relative_to(docs_dir), "Path must be within docs directory"
+
+    return doc_file.read_text()
+
+
+async def main() -> None:
+    """Run MCP server via stdio."""
+    assert app is not None, "Server must be initialized"
+
+    async with stdio_server() as (read_stream, write_stream):
+        assert read_stream is not None, "Read stream must not be None"
+        assert write_stream is not None, "Write stream must not be None"
+        await app.run(read_stream, write_stream, app.create_initialization_options())
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    asyncio.run(main())

dddlint/server.py

@@ -0,0 +1,159 @@
+import logging
+from pathlib import Path
+from urllib.parse import urlparse
+
+from lsprotocol import types
+from pygls.lsp.server import LanguageServer
+
+from .check import Finding, check
+from .config import Config, load_config
+from .config_check import check_config
+from .extract import Definition, definitions, language_for
+
+logger = logging.getLogger(__name__)
+
+SKIP = {".git", ".venv", "node_modules", "__pycache__", "target", "dist", "build"}
+DEFAULT_CONFIG = Path("dddlint.yaml")
+
+SEVERITY: dict[str, types.DiagnosticSeverity] = {
+    "forbidden": types.DiagnosticSeverity.Error,
+    "alias": types.DiagnosticSeverity.Warning,
+    "drift": types.DiagnosticSeverity.Information,
+}
+
+
+class DddlintServer(LanguageServer):
+    def __init__(self) -> None:
+        super().__init__("dddlint", "v0.1.0")
+        self.ddd_findings: dict[str, list[Finding]] = {}
+        assert isinstance(self.ddd_findings, dict), "findings must be a dict"
+        assert self.ddd_findings == {}, "findings must start empty"
+
+
+server = DddlintServer()
+
+
+def _to_path(uri: str) -> Path:
+    assert uri, "uri must be non-empty"
+    assert isinstance(uri, str), "uri must be a string"
+    return Path(urlparse(uri).path)
+
+
+def _scan(ls: DddlintServer) -> None:
+    assert ls is not None, "language server must not be None"
+    assert isinstance(ls, DddlintServer), "ls must be a DddlintServer"
+    root_uri = ls.workspace.root_uri
+    if not root_uri:
+        return
+    root = _to_path(root_uri)
+    config_path = root / DEFAULT_CONFIG
+    settings = load_config(config_path) if config_path.exists() else Config()
+
+    extra: dict[str, str] = {}
+    collected: list[Definition] = []
+    for path in root.rglob("*"):
+        if not path.is_file() or SKIP & set(path.parts):
+            continue
+        lang = language_for(path, extra)
+        if lang is None:
+            continue
+        try:
+            collected.extend(definitions(path, lang))
+        except Exception as exc:
+            logger.debug("failed to extract definitions from %s: %s", path, exc)
+
+    all_findings: list[Finding] = []
+    if config_path.exists():
+        all_findings += check_config(settings, config_path)
+    all_findings += check(collected, settings)
+    by_file: dict[Path, list[Finding]] = {}
+    for f in all_findings:
+        by_file.setdefault(f.path, []).append(f)
+
+    published: set[str] = set()
+    for path, file_findings in by_file.items():
+        uri = path.absolute().as_uri()
+        ls.text_document_publish_diagnostics(
+            types.PublishDiagnosticsParams(
+                uri=uri, diagnostics=[_to_diagnostic(f) for f in file_findings]
+            )
+        )
+        ls.ddd_findings[uri] = file_findings
+        published.add(uri)
+
+    for uri in list(ls.ddd_findings):
+        if uri not in published:
+            ls.text_document_publish_diagnostics(
+                types.PublishDiagnosticsParams(uri=uri, diagnostics=[])
+            )
+            del ls.ddd_findings[uri]
+
+
+def _to_diagnostic(f: Finding) -> types.Diagnostic:
+    assert f is not None, "finding must not be None"
+    assert f.line >= 0, "line must be non-negative"
+    start = types.Position(line=f.line, character=f.col)
+    end = types.Position(line=f.line, character=f.col + len(f.name))
+    return types.Diagnostic(
+        range=types.Range(start=start, end=end),
+        message=f.message,
+        severity=SEVERITY.get(f.rule, types.DiagnosticSeverity.Warning),
+        source="dddlint",
+        code=f.rule,
+    )
+
+
+@server.feature(types.TEXT_DOCUMENT_DID_OPEN)
+def did_open(ls: DddlintServer, params: types.DidOpenTextDocumentParams) -> None:
+    assert ls is not None, "ls must not be None"
+    assert params is not None, "params must not be None"
+    _scan(ls)
+
+
+@server.feature(types.TEXT_DOCUMENT_DID_SAVE)
+def did_save(ls: DddlintServer, params: types.DidSaveTextDocumentParams) -> None:
+    assert ls is not None, "ls must not be None"
+    assert params is not None, "params must not be None"
+    _scan(ls)
+
+
+@server.feature(
+    types.TEXT_DOCUMENT_CODE_ACTION,
+    types.CodeActionOptions(code_action_kinds=[types.CodeActionKind.QuickFix]),
+)
+def code_action(ls: DddlintServer, params: types.CodeActionParams) -> list[types.CodeAction]:
+    assert ls is not None, "ls must not be None"
+    assert params is not None, "params must not be None"
+    uri = params.text_document.uri
+    cursor_line = params.range.start.line
+    actions: list[types.CodeAction] = []
+
+    for f in ls.ddd_findings.get(uri, []):
+        if f.line != cursor_line or f.fix is None:
+            continue
+        actions.append(
+            types.CodeAction(
+                title=f"Rename '{f.name}' → '{f.fix}' (dddlint: {f.rule})",
+                kind=types.CodeActionKind.QuickFix,
+                edit=types.WorkspaceEdit(
+                    changes={
+                        uri: [
+                            types.TextEdit(
+                                range=types.Range(
+                                    start=types.Position(line=f.line, character=f.col),
+                                    end=types.Position(line=f.line, character=f.col + len(f.name)),
+                                ),
+                                new_text=f.fix,
+                            )
+                        ]
+                    }
+                ),
+            )
+        )
+    return actions
+
+
+def main() -> None:
+    assert server is not None, "server must be initialized"
+    assert isinstance(server, DddlintServer), "server must be a DddlintServer"
+    server.start_io()

dddlint/view.py

@@ -0,0 +1,364 @@
+import json
+
+from .config import Config
+
+_COLORS = {
+    "global": "#7c3aed",
+    "domain": "#2563eb",
+    "context": "#0891b2",
+    "canonical": "#16a34a",
+    "alias": "#374151",
+    "forbidden": "#dc2626",
+}
+
+_RADII = {
+    "global": 38,
+    "domain": 32,
+    "context": 32,
+    "canonical": 22,
+    "alias": 16,
+    "forbidden": 16,
+}
+
+
+def _build_graph(config: Config) -> dict:
+    assert config is not None, "config must not be None"
+    assert isinstance(config, Config), "config must be a Config"
+    nodes: list[dict] = []
+    edges: list[dict] = []
+    seen: set[str] = set()
+
+    def node(id_: str, label: str, kind: str) -> None:
+        assert id_, "id_ must be non-empty"
+        assert kind in _COLORS, "kind must be a known node type"
+        if id_ not in seen:
+            nodes.append(
+                {"id": id_, "label": label, "type": kind, "color": _COLORS[kind], "r": _RADII[kind]}
+            )
+            seen.add(id_)
+
+    def edge(src: str, tgt: str, kind: str = "owns") -> None:
+        assert src and tgt, "src and tgt must be non-empty"
+        assert kind, "kind must be non-empty"
+        edges.append({"source": src, "target": tgt, "kind": kind})
+
+    node("global", "Global", "global")
+
+    for term in config.forbidden:
+        nid = f"forbidden:{term}"
+        node(nid, term, "forbidden")
+        edge("global", nid, "forbidden")
+
+    for g in config.synonyms:
+        cid = f"canonical:{g.canonical}"
+        node(cid, g.canonical, "canonical")
+        edge("global", cid, "owns")
+        for alias in g.aliases:
+            aid = f"alias:{alias}"
+            node(aid, alias, "alias")
+            edge(aid, cid, "alias")
+
+    for scope_list, kind in [(config.domains, "domain"), (config.contexts, "context")]:
+        for scope in scope_list:
+            sid = f"{kind}:{scope.name}"
+            node(sid, scope.name, kind)
+            edge("global", sid, "scope")
+            for term in scope.forbidden:
+                nid = f"forbidden:{sid}:{term}"
+                node(nid, term, "forbidden")
+                edge(sid, nid, "forbidden")
+            for g in scope.synonyms:
+                cid = f"canonical:{sid}:{g.canonical}"
+                node(cid, g.canonical, "canonical")
+                edge(sid, cid, "owns")
+                for alias in g.aliases:
+                    aid = f"alias:{sid}:{alias}"
+                    node(aid, alias, "alias")
+                    edge(aid, cid, "alias")
+
+    return {"nodes": nodes, "edges": edges}
+
+
+_HTML_TEMPLATE = """\
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<title>DDD Graph</title>
+<style>
+  * {{ box-sizing: border-box; margin: 0; padding: 0; }}
+  body {{ background: #0d0f17; overflow: hidden; font-family: system-ui, sans-serif; }}
+  canvas {{ display: block; }}
+  #legend {{
+    position: fixed; bottom: 1.5rem; left: 1.5rem;
+    display: flex; gap: 1rem; flex-wrap: wrap;
+  }}
+  .leg {{ display: flex; align-items: center; gap: 0.35rem;
+           font-size: 0.72rem; color: #6b7280; }}
+  .dot {{ width: 10px; height: 10px; border-radius: 50%; }}
+  #title {{
+    position: fixed; top: 1.5rem; left: 1.5rem;
+    font-size: 1.1rem; font-weight: 700; color: #e2e4f0;
+    letter-spacing: -0.03em;
+  }}
+  #hint {{
+    position: fixed; top: 1.5rem; right: 1.5rem;
+    font-size: 0.72rem; color: #374151;
+  }}
+</style>
+</head>
+<body>
+<canvas id="c"></canvas>
+<div id="title">DDD Graph</div>
+<div id="hint">scroll to zoom · drag to pan · drag nodes</div>
+<div id="legend">
+  <div class="leg"><div class="dot" style="background:#7c3aed"></div>global</div>
+  <div class="leg"><div class="dot" style="background:#2563eb"></div>domain</div>
+  <div class="leg"><div class="dot" style="background:#0891b2"></div>context</div>
+  <div class="leg"><div class="dot" style="background:#16a34a"></div>canonical</div>
+  <div class="leg"><div class="dot" style="background:#374151;border:1px solid #6b7280"></div>alias</div>
+  <div class="leg"><div class="dot" style="background:#dc2626"></div>forbidden</div>
+</div>
+<script>
+const DATA = {data};
+
+const canvas = document.getElementById('c');
+const ctx = canvas.getContext('2d');
+let W, H;
+
+function resize() {{
+  W = canvas.width = window.innerWidth;
+  H = canvas.height = window.innerHeight;
+}}
+resize();
+window.addEventListener('resize', resize);
+
+// --- state ---
+const nodes = DATA.nodes.map(n => ({{
+  ...n,
+  x: W/2 + (Math.random()-0.5)*300,
+  y: H/2 + (Math.random()-0.5)*300,
+  vx: 0, vy: 0, pinned: false
+}}));
+const edges = DATA.edges;
+const nodeById = Object.fromEntries(nodes.map(n => [n.id, n]));
+
+// --- camera ---
+let cam = {{ x: 0, y: 0, zoom: 1 }};
+
+// --- interaction ---
+let drag = null;
+let pan = null;
+
+function worldPos(ex, ey) {{
+  return {{
+    x: (ex - W/2 - cam.x) / cam.zoom,
+    y: (ey - H/2 - cam.y) / cam.zoom,
+  }};
+}}
+
+function hitNode(wx, wy) {{
+  for (let i = nodes.length-1; i >= 0; i--) {{
+    const n = nodes[i];
+    const dx = wx - n.x, dy = wy - n.y;
+    if (Math.sqrt(dx*dx+dy*dy) <= n.r + 2) return n;
+  }}
+  return null;
+}}
+
+canvas.addEventListener('mousedown', e => {{
+  const w = worldPos(e.clientX, e.clientY);
+  const hit = hitNode(w.x, w.y);
+  if (hit) {{ drag = {{ node: hit, ox: w.x - hit.x, oy: w.y - hit.y }}; hit.pinned = true; }}
+  else pan = {{ ox: e.clientX - cam.x, oy: e.clientY - cam.y }};
+}});
+
+canvas.addEventListener('mousemove', e => {{
+  if (drag) {{
+    const w = worldPos(e.clientX, e.clientY);
+    drag.node.x = w.x - drag.ox;
+    drag.node.y = w.y - drag.oy;
+    drag.node.vx = drag.node.vy = 0;
+  }} else if (pan) {{
+    cam.x = e.clientX - pan.ox;
+    cam.y = e.clientY - pan.oy;
+  }}
+}});
+
+canvas.addEventListener('mouseup', () => {{ drag = pan = null; }});
+
+canvas.addEventListener('wheel', e => {{
+  e.preventDefault();
+  const factor = e.deltaY < 0 ? 1.1 : 0.91;
+  cam.zoom = Math.max(0.2, Math.min(4, cam.zoom * factor));
+}}, {{ passive: false }});
+
+// --- physics ---
+const REPEL = 4000;
+const SPRING = 0.04;
+const REST = {{
+  owns: 100, scope: 140, alias: 80, forbidden: 80, default: 110
+}};
+const DAMP = 0.82;
+const CENTER = 0.005;
+
+function tick() {{
+  // repulsion
+  for (let i = 0; i < nodes.length; i++) {{
+    for (let j = i+1; j < nodes.length; j++) {{
+      const a = nodes[i], b = nodes[j];
+      let dx = b.x - a.x, dy = b.y - a.y;
+      const d2 = dx*dx + dy*dy || 1;
+      const f = REPEL / d2;
+      const inv = 1 / Math.sqrt(d2);
+      dx *= inv; dy *= inv;
+      a.vx -= f*dx; a.vy -= f*dy;
+      b.vx += f*dx; b.vy += f*dy;
+    }}
+  }}
+
+  // springs
+  for (const e of edges) {{
+    const a = nodeById[e.source], b = nodeById[e.target];
+    if (!a || !b) continue;
+    let dx = b.x - a.x, dy = b.y - a.y;
+    const d = Math.sqrt(dx*dx+dy*dy) || 1;
+    const rest = REST[e.kind] ?? REST.default;
+    const f = (d - rest) * SPRING;
+    dx /= d; dy /= d;
+    a.vx += f*dx; a.vy += f*dy;
+    b.vx -= f*dx; b.vy -= f*dy;
+  }}
+
+  // center gravity
+  for (const n of nodes) {{
+    n.vx += (0 - n.x) * CENTER;
+    n.vy += (0 - n.y) * CENTER;
+  }}
+
+  // integrate
+  for (const n of nodes) {{
+    if (n.pinned && drag?.node === n) continue;
+    n.vx *= DAMP; n.vy *= DAMP;
+    n.x += n.vx; n.y += n.vy;
+  }}
+}}
+
+// --- render ---
+function hexAlpha(hex, a) {{
+  const r = parseInt(hex.slice(1,3),16);
+  const g = parseInt(hex.slice(3,5),16);
+  const b = parseInt(hex.slice(5,7),16);
+  return `rgba(${{r}},${{g}},${{b}},${{a}})`;
+}}
+
+function draw() {{
+  ctx.clearRect(0, 0, W, H);
+  ctx.save();
+  ctx.translate(W/2 + cam.x, H/2 + cam.y);
+  ctx.scale(cam.zoom, cam.zoom);
+
+  // edges
+  for (const e of edges) {{
+    const a = nodeById[e.source], b = nodeById[e.target];
+    if (!a || !b) continue;
+
+    const dx = b.x - a.x, dy = b.y - a.y;
+    const d = Math.sqrt(dx*dx+dy*dy) || 1;
+    const ux = dx/d, uy = dy/d;
+    const sx = a.x + ux*a.r, sy = a.y + uy*a.r;
+    const ex = b.x - ux*b.r, ey = b.y - uy*b.r;
+
+    ctx.beginPath();
+    if (e.kind === 'alias') {{
+      ctx.setLineDash([4, 4]);
+      ctx.strokeStyle = '#374151';
+      ctx.lineWidth = 1;
+    }} else if (e.kind === 'forbidden') {{
+      ctx.setLineDash([]);
+      ctx.strokeStyle = hexAlpha('#dc2626', 0.5);
+      ctx.lineWidth = 1;
+    }} else if (e.kind === 'scope') {{
+      ctx.setLineDash([]);
+      ctx.strokeStyle = '#252838';
+      ctx.lineWidth = 1.5;
+    }} else {{
+      ctx.setLineDash([]);
+      ctx.strokeStyle = '#1e2130';
+      ctx.lineWidth = 1.5;
+    }}
+    ctx.moveTo(sx, sy);
+    ctx.lineTo(ex, ey);
+    ctx.stroke();
+
+    // arrowhead on alias edges
+    if (e.kind === 'alias') {{
+      ctx.setLineDash([]);
+      ctx.fillStyle = '#374151';
+      const angle = Math.atan2(ey-sy, ex-sx);
+      ctx.save();
+      ctx.translate(ex, ey);
+      ctx.rotate(angle);
+      ctx.beginPath();
+      ctx.moveTo(0, 0);
+      ctx.lineTo(-7, -3.5);
+      ctx.lineTo(-7, 3.5);
+      ctx.closePath();
+      ctx.fill();
+      ctx.restore();
+    }}
+  }}
+  ctx.setLineDash([]);
+
+  // nodes
+  for (const n of nodes) {{
+    // glow for scopes
+    if (['global','domain','context'].includes(n.type)) {{
+      const g = ctx.createRadialGradient(n.x, n.y, n.r*0.5, n.x, n.y, n.r*2);
+      g.addColorStop(0, hexAlpha(n.color, 0.15));
+      g.addColorStop(1, hexAlpha(n.color, 0));
+      ctx.beginPath();
+      ctx.arc(n.x, n.y, n.r*2, 0, Math.PI*2);
+      ctx.fillStyle = g;
+      ctx.fill();
+    }}
+
+    // circle
+    ctx.beginPath();
+    ctx.arc(n.x, n.y, n.r, 0, Math.PI*2);
+    ctx.fillStyle = hexAlpha(n.color, n.type === 'alias' ? 0.25 : 0.18);
+    ctx.fill();
+    ctx.strokeStyle = n.color;
+    ctx.lineWidth = n.type === 'alias' ? 1 : 1.5;
+    ctx.stroke();
+
+    // label
+    const fs = n.type === 'global' ? 13 :
+                n.type === 'domain' || n.type === 'context' ? 11 : 10;
+    ctx.font = `${{['global','domain','context'].includes(n.type) ? 600 : 500}} ${{fs}}px system-ui`;
+    ctx.fillStyle = n.type === 'alias' ? '#6b7280' : '#e2e4f0';
+    ctx.textAlign = 'center';
+    ctx.textBaseline = 'middle';
+    ctx.fillText(n.label, n.x, n.y);
+  }}
+
+  ctx.restore();
+}}
+
+function loop() {{
+  for (let i = 0; i < 3; i++) tick();
+  draw();
+  requestAnimationFrame(loop);
+}}
+loop();
+</script>
+</body>
+</html>
+"""
+
+
+def _generate_html(config: Config) -> str:
+    assert config is not None, "config must not be None"
+    assert isinstance(config, Config), "config must be a Config"
+    graph = _build_graph(config)
+    return _HTML_TEMPLATE.format(data=json.dumps(graph))

dddlint-0.1.2.dist-info/METADATA

@@ -0,0 +1,184 @@
+Metadata-Version: 2.4
+Name: dddlint
+Version: 0.1.2
+Summary: Polyglot ubiquitous language linter for codebases and coding agents
+Project-URL: Repository, https://github.com/benomahony/dddlint
+Author: benomahony
+Requires-Python: >=3.12
+Requires-Dist: lsprotocol>=2025.0.0
+Requires-Dist: mcp>=1.28.1
+Requires-Dist: pydantic>=2.13.4
+Requires-Dist: pygls>=2.1.1
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: rich>=15.0.0
+Requires-Dist: tree-sitter-language-pack>=1.8.1
+Requires-Dist: typer>=0.26.2
+Description-Content-Type: text/markdown
+
+# dddlint
+
+Polyglot ubiquitous language linter. Reads class, function, method, and type names across **306 languages** and enforces them against a domain vocabulary — banned terms, non-canonical synonyms, and one concept spelled multiple ways.
+
+Works with any language tree-sitter recognises, without per-language queries. Slots into pre-commit hooks, CI pipelines, and coding agent loops via a non-zero exit code on findings. Ships with an LSP server for inline editor diagnostics and rename code actions.
+
+## Install
+
+```sh
+uv add dddlint
+```
+
+## Quick start
+
+```sh
+# lint current directory (looks for dddlint.yaml)
+dddlint lint
+
+# lint a specific path
+dddlint lint src/
+
+# open an interactive language graph in the browser
+dddlint html
+
+# start the LSP server (stdio)
+dddlint lsp
+```
+
+## Config
+
+Place `dddlint.yaml` at the project root. When a path is passed to `lint` or `html`, the config is looked up in that directory first, then falls back to the current working directory.
+
+```yaml
+similarity_threshold: 0.85   # Jaccard threshold for drift detection
+enforce_canonical: true       # flag alias terms in addition to forbidden ones
+
+# terms that must never appear in a definition name
+forbidden:
+  - util
+  - helper
+  - manager
+
+# canonical terms and their aliases
+synonyms:
+  - canonical: customer
+    aliases: [client, user, accountholder]
+  - canonical: order
+    aliases: [purchase, transaction]
+
+# high-level business domains
+domains:
+  - name: commerce
+    include: ["**/commerce/**"]
+    synonyms:
+      - canonical: order
+        aliases: [purchase]
+
+# bounded contexts — same structure as domains, applied after (context wins on conflict)
+contexts:
+  - name: billing
+    include: ["**/billing/**"]
+    forbidden: [discount]
+    synonyms:
+      - canonical: invoice
+        aliases: [bill, statement]
+
+# register file extensions for languages not auto-detected
+languages:
+  svelte:
+    extensions: [".svelte"]
+```
+
+Global rules apply everywhere. Domain rules apply to matching paths. Context rules apply after domains, so a context can override a domain synonym.
+
+## Rules
+
+| Rule | Severity | Description |
+|---|---|---|
+| `forbidden` | error | A definition name contains a banned term |
+| `alias` | warning | A definition uses a non-canonical synonym — includes a rename suggestion |
+| `drift` | info | The same concept is spelled multiple ways across the codebase |
+| `config:forbidden-canonical-clash` | error | A term is both forbidden and a canonical synonym |
+| `config:alias-conflict` | warning | The same alias maps to different canonicals in different scopes |
+| `config:duplicate-name` | info | Two domains or contexts have suspiciously similar names |
+
+Config rules are checked against `dddlint.yaml` itself on every run.
+
+## LSP
+
+The LSP server publishes diagnostics on file open and save, scanning the entire workspace each time so cross-file drift is always caught. Alias findings include a code action to rename the identifier to the canonical term with case preserved (`ClientRepo` → `CustomerRepo`, `get_client` → `get_customer`).
+
+**Neovim** — add to `init.lua`:
+
+```lua
+vim.api.nvim_create_autocmd("BufReadPost", {
+  callback = function(args)
+    local root = vim.fs.root(args.buf, { "dddlint.yaml" })
+    if root then
+      vim.lsp.start({
+        name = "dddlint",
+        cmd = { "dddlint", "lsp" },
+        root_dir = root,
+      }, { bufnr = args.buf })
+    end
+  end,
+})
+```
+
+The autocmd fires on every buffer, attaches only when `dddlint.yaml` is found, and is language-agnostic — no filetype list required.
+
+**VS Code** — via a generic LSP client extension:
+
+```json
+{
+  "lsp.servers": {
+    "dddlint": {
+      "command": ["uvx", "dddlint", "lsp"],
+      "filetypes": ["*"]
+    }
+  }
+}
+```
+
+**Helix** — `.helix/languages.toml`:
+
+```toml
+[language-server.dddlint]
+command = "dddlint"
+args = ["lsp"]
+```
+
+## Language support
+
+Extraction is powered by [`tree-sitter-language-pack`](https://github.com/Goldziher/tree-sitter-language-pack), which covers 306 languages including:
+
+Ada · Agda · Arduino · Bash · C · C++ · C# · Clojure · COBOL · Crystal · CSS · D · Dart · Dockerfile · Elixir · Elm · Erlang · F# · Fortran · GDScript · GLSL · Go · GraphQL · Groovy · Hack · Haskell · HCL · HTML · Java · JavaScript · Julia · Kotlin · Lean · Lua · MATLAB · Mojo · Nix · OCaml · Odin · Pascal · Perl · PHP · PowerShell · Prolog · Python · R · Racket · Ruby · Rust · Scala · Scheme · Solidity · SQL · Svelte · Swift · Terraform · TLA+ · TOML · TypeScript · V · VHDL · Vim · Vue · WebAssembly · XML · YAML · Zig — and [243 more](https://github.com/Goldziher/tree-sitter-language-pack).
+
+## CI
+
+```yaml
+# .github/workflows/dddlint.yml
+- run: uvx dddlint lint
+```
+
+Exit code is `0` when clean, `1` when findings exist.
+
+## Pre-commit
+
+```yaml
+# .pre-commit-config.yaml
+repos:
+  - repo: local
+    hooks:
+      - id: dddlint
+        name: dddlint
+        entry: dddlint lint
+        language: python
+        pass_filenames: false
+```
+
+## Offline use
+
+The language pack downloads parsers on first use. For CI or air-gapped runs, warm the cache in the image:
+
+```sh
+python -c "import tree_sitter_language_pack as t; t.download_all()"
+```

dddlint-0.1.2.dist-info/RECORD

@@ -0,0 +1,13 @@
+dddlint/__init__.py,sha256=YvuYzWnKtqBb-IqG8HAu-nhIYAsgj9Vmc_b9o7vO-js,22
+dddlint/check.py,sha256=paFI81hm361vk-yvamyog98-W-YX0II7en0FMVi60Dg,4596
+dddlint/cli.py,sha256=s4K4xxzux8PzLBxQQeZN1vi804DEgTbPwJeJKXbtoN0,4819
+dddlint/config.py,sha256=lEmM6BOyLIN696PYj1DiW2vpkADfuB9D6toEr6f2NrY,747
+dddlint/config_check.py,sha256=ndpIDdX5OcJ2jyUnu8TJ0jAdspbRv_qZxpEYVn8rLV0,3375
+dddlint/extract.py,sha256=dmVw_rhOTOtUdvfWwdEt74zegn0Dd-Jgxdm_syLiDU0,2663
+dddlint/mcp_server.py,sha256=26frdntTvpNeW5NcYUhmJENFOdC3NbG7FLlBqfnkVOA,2311
+dddlint/server.py,sha256=lmIe5iCH_6B6GYR0dYo05tK9m2F7AViw_6NmU6nxcrY,5525
+dddlint/view.py,sha256=HrJ929xtu21d287n8ZlzF6TljPbIRHO7heSKFvLV4DQ,10382
+dddlint-0.1.2.dist-info/METADATA,sha256=jNxkz2jPWBgQhm2RvZNCDs-td7c-rzo3ujx25rx-jOQ,5782
+dddlint-0.1.2.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+dddlint-0.1.2.dist-info/entry_points.txt,sha256=wkXDoWuNSP2ucX8MlVBQQYBumvCKPqKMcV_fXTNwskk,78
+dddlint-0.1.2.dist-info/RECORD,,

dddlint-0.1.2.dist-info/WHEEL

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

dddlint-0.1.2.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+dddlint = dddlint.cli:app
+dddlint-lsp = dddlint.server:main