deviatdd 2.5.1__py3-none-any.whl

deviate/core/treesitter/models.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class SymbolChange:
+    language: str
+    kind: str
+    name: str
+    change: str
+    old_name: str = ""
+    start_line: int = 0
+    end_line: int = 0
+    old_start_line: int = 0
+    old_end_line: int = 0
+    old_signature: str = ""
+    new_signature: str = ""
+    old_line_count: int = 0
+    new_line_count: int = 0
+
+
+@dataclass
+class DuplicateBlock:
+    lines: int
+    locations: list[str]
+    similarity: float
+
+
+@dataclass
+class FileStructure:
+    filepath: str
+    language: str
+    symbols: list[dict[str, str | int]] = field(default_factory=list)
+    imports: list[str] = field(default_factory=list)

deviate/core/treesitter/parser.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+import importlib
+import logging
+import os
+import pathlib
+
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+_QUERIES_DIR: pathlib.Path = pathlib.Path(__file__).resolve().parent / "queries"
+
+EXTENSION_MAP: dict[str, str] = {
+    ".py": "python",
+    ".js": "javascript",
+    ".mjs": "javascript",
+    ".cjs": "javascript",
+    ".ts": "typescript",
+    ".mts": "typescript",
+    ".cts": "typescript",
+    ".tsx": "tsx",
+    ".rs": "rust",
+    ".go": "go",
+    ".cpp": "cpp",
+    ".cc": "cpp",
+    ".cxx": "cpp",
+    ".hpp": "cpp",
+    ".h": "cpp",
+    ".ex": "elixir",
+    ".exs": "elixir",
+    ".cs": "c_sharp",
+    ".md": "markdown",
+    ".mdx": "markdown",
+    ".sh": "bash",
+    ".bash": "bash",
+    ".zsh": "bash",
+    ".json": "json",
+    ".toml": "toml",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+    ".html": "html",
+    ".htm": "html",
+    ".css": "css",
+    ".scss": "css",
+    ".less": "css",
+    ".sql": "sql",
+    "Dockerfile": "dockerfile",
+    ".dockerfile": "dockerfile",
+    ".tf": "hcl",
+    ".tfvars": "hcl",
+    ".kt": "kotlin",
+    ".kts": "kotlin",
+    ".swift": "swift",
+}
+
+_GRAMMAR_PACKAGES: dict[str, str] = {
+    "python": "tree_sitter_python",
+    "javascript": "tree_sitter_javascript",
+    "typescript": "tree_sitter_typescript",
+    "tsx": "tree_sitter_typescript",
+    "rust": "tree_sitter_rust",
+    "go": "tree_sitter_go",
+    "cpp": "tree_sitter_cpp",
+    "elixir": "tree_sitter_elixir",
+    "c_sharp": "tree_sitter_c_sharp",
+    "markdown": "tree_sitter_markdown",
+    "bash": "tree_sitter_bash",
+    "json": "tree_sitter_json",
+    "toml": "tree_sitter_toml",
+    "yaml": "tree_sitter_yaml",
+    "html": "tree_sitter_html",
+    "css": "tree_sitter_css",
+    "sql": "tree_sitter_sql",
+    "dockerfile": "tree_sitter_dockerfile",
+    "hcl": "tree_sitter_hcl",
+    "kotlin": "tree_sitter_kotlin",
+    "swift": "tree_sitter_swift",
+}
+
+_LANGUAGE_ATTRS: dict[str, str] = {
+    "typescript": "language_typescript",
+    "tsx": "language_tsx",
+}
+
+_CAP_KIND: dict[str, str] = {
+    "function": "function",
+    "method": "function",
+    "class": "class",
+    "struct": "class",
+    "interface": "interface",
+    "entry": "entry",
+}
+
+_tree_sitter_available = True
+_parser_cache: dict[str, Any] = {}
+_query_cache: dict[str, Any] = {}
+_grammar_cache: dict[str, Any] = {}
+
+try:
+    from tree_sitter import Language, Parser, Query, QueryCursor, Tree
+except ImportError:
+    _tree_sitter_available = False
+    Language = None
+    Parser = None
+    Query = None
+    QueryCursor = None
+    Tree = None
+
+
+def get_language_id(filepath: str) -> str | None:
+    ext = _get_extension(filepath)
+    return EXTENSION_MAP.get(ext)
+
+
+def get_parser(filepath: str) -> Any | None:
+    if not _tree_sitter_available or Parser is None:
+        return None
+    lang_id = get_language_id(filepath)
+    if lang_id is None:
+        return None
+    if lang_id in _parser_cache:
+        return _parser_cache[lang_id]
+    lang_obj = _load_language(lang_id)
+    if lang_obj is None:
+        return None
+    try:
+        parser = Parser(lang_obj)
+        _parser_cache[lang_id] = parser
+        return parser
+    except Exception:
+        logger.warning("Failed to create parser for %s", lang_id)
+        return None
+
+
+def _load_language(grammar_id: str) -> Any | None:
+    if not _tree_sitter_available or Language is None:
+        return None
+    if grammar_id in _grammar_cache:
+        return _grammar_cache[grammar_id]
+    pkg_name = _GRAMMAR_PACKAGES.get(grammar_id)
+    if pkg_name is None:
+        return None
+    try:
+        pkg = importlib.import_module(pkg_name)
+        lang_attr = _LANGUAGE_ATTRS.get(grammar_id, "language")
+        cap_fn = getattr(pkg, lang_attr, None) or pkg.language
+        capsule = cap_fn()
+        lang_obj = Language(capsule)
+        _grammar_cache[grammar_id] = lang_obj
+        return lang_obj
+    except Exception:
+        logger.warning("Failed to load language %s", grammar_id)
+        return None
+
+
+def _get_extension(filepath: str) -> str:
+    name = os.path.basename(filepath)
+    if name == "Dockerfile":
+        return "Dockerfile"
+    _, ext = os.path.splitext(name)
+    return ext.lower() if ext else ""
+
+
+def _load_queries(grammar_id: str) -> Any | None:
+    if not _tree_sitter_available or Query is None:
+        return None
+    if grammar_id in _query_cache:
+        return _query_cache[grammar_id]
+    qfile = _QUERIES_DIR / f"{grammar_id}.scm"
+    if not qfile.exists():
+        _query_cache[grammar_id] = None
+        return None
+    lang_obj = _load_language(grammar_id)
+    if lang_obj is None:
+        return None
+    try:
+        qtext = qfile.read_text()
+        query = Query(lang_obj, qtext)
+        _query_cache[grammar_id] = query
+        return query
+    except Exception:
+        logger.warning("Failed to compile query for %s", grammar_id)
+        return None

deviate/core/treesitter/queries/bash.scm

@@ -0,0 +1,7 @@
+; captures: function, call, import, conditional, loop
+(function_definition name: (word) @function)
+(command name: (command_name) @call)
+(if_statement) @conditional
+(for_statement) @loop
+(while_statement) @loop
+(case_statement) @conditional

deviate/core/treesitter/queries/c_sharp.scm

@@ -0,0 +1,11 @@
+; captures: function, class, interface, call, import, conditional, loop
+(method_declaration name: (identifier) @method)
+(class_declaration name: (identifier) @class)
+(struct_declaration name: (identifier) @struct)
+(interface_declaration name: (identifier) @interface)
+(record_declaration name: (identifier) @struct)
+(invocation_expression) @call
+(if_statement) @conditional
+(for_statement) @loop
+(while_statement) @loop
+(switch_statement) @conditional

deviate/core/treesitter/queries/cpp.scm

@@ -0,0 +1,9 @@
+; captures: function, class, call, import, conditional, loop
+(function_definition declarator: (function_declarator declarator: (identifier) @function))
+(class_specifier name: (type_identifier) @class)
+(call_expression) @call
+(using_declaration) @import
+(if_statement) @conditional
+(for_statement) @loop
+(while_statement) @loop
+(switch_statement) @conditional

deviate/core/treesitter/queries/css.scm

@@ -0,0 +1,4 @@
+; captures: entry
+(rule_set) @entry
+(at_rule) @entry
+(declaration) @entry

deviate/core/treesitter/queries/dockerfile.scm

@@ -0,0 +1,8 @@
+; captures: entry
+(from_instruction) @entry
+(run_instruction) @entry
+(cmd_instruction) @entry
+(env_instruction) @entry
+(expose_instruction) @entry
+(copy_instruction) @entry
+(entrypoint_instruction) @entry

deviate/core/treesitter/queries/elixir.scm

@@ -0,0 +1,6 @@
+; captures: function, call, import, class, interface
+; Elixir uses 'call' nodes for all def/defmodule/defstruct etc.
+; We capture the first argument as the name
+(call target: (identifier) @call)
+(unary_operator operator: "@" (call target: (identifier) @call))
+(alias) @import

deviate/core/treesitter/queries/go.scm

@@ -0,0 +1,9 @@
+; captures: function, class, call, import, conditional, loop
+(function_declaration name: (identifier) @function)
+(method_declaration name: (field_identifier) @method)
+(call_expression) @call
+(import_declaration) @import
+(if_statement) @conditional
+(for_statement) @loop
+(expression_switch_statement) @conditional
+(type_switch_statement) @conditional

deviate/core/treesitter/queries/hcl.scm

@@ -0,0 +1,3 @@
+; captures: entry
+(block) @entry
+(attribute) @entry

deviate/core/treesitter/queries/html.scm

@@ -0,0 +1,3 @@
+; captures: entry
+(element) @entry
+(attribute) @entry

deviate/core/treesitter/queries/javascript.scm

@@ -0,0 +1,12 @@
+; captures: function, class, call, import, conditional, loop
+(function_declaration name: (identifier) @function)
+(class_declaration name: (identifier) @class)
+(method_definition name: (property_identifier) @method)
+(arrow_function) @function
+(call_expression) @call
+(import_statement) @import
+(export_statement) @function
+(if_statement) @conditional
+(for_statement) @loop
+(while_statement) @loop
+(switch_statement) @conditional

deviate/core/treesitter/queries/json.scm

@@ -0,0 +1,4 @@
+; captures: entry
+(pair) @entry
+(object) @entry
+(array) @entry

deviate/core/treesitter/queries/kotlin.scm

@@ -0,0 +1,8 @@
+; captures: function, class, call, interface, conditional, loop
+(function_declaration name: (identifier) @function)
+(class_declaration name: (identifier) @class)
+(object_declaration name: (identifier) @class)
+(call_expression) @call
+(if_expression) @conditional
+(for_statement) @loop
+(while_statement) @loop

deviate/core/treesitter/queries/markdown.scm

@@ -0,0 +1,4 @@
+; captures: entry
+(section) @entry
+(fenced_code_block) @entry
+(list_item) @entry

deviate/core/treesitter/queries/python.scm

@@ -0,0 +1,10 @@
+; captures: function, class, call, import, conditional, loop
+(function_definition name: (identifier) @function)
+(class_definition name: (identifier) @class)
+(call (identifier) @call)
+(import_statement) @import
+(import_from_statement) @import
+(if_statement) @conditional
+(for_statement) @loop
+(while_statement) @loop
+(match_statement) @conditional

deviate/core/treesitter/queries/rust.scm

@@ -0,0 +1,12 @@
+; captures: function, class, interface, call, import, conditional, loop
+(function_item name: (identifier) @function)
+(struct_item name: (type_identifier) @struct)
+(enum_item name: (type_identifier) @enum)
+(trait_item name: (type_identifier) @interface)
+(impl_item) @class
+(call_expression) @call
+(use_declaration) @import
+(if_expression) @conditional
+(for_expression) @loop
+(while_expression) @loop
+(match_expression) @conditional

deviate/core/treesitter/queries/sql.scm

@@ -0,0 +1,7 @@
+; captures: function, entry
+(create_function (object_reference) @function)
+(create_table name: (identifier) @entry)
+(select) @entry
+(insert) @entry
+(update) @entry
+(delete) @entry

deviate/core/treesitter/queries/swift.scm

@@ -0,0 +1,10 @@
+; captures: function, class, interface, call, import, conditional, loop
+(function_declaration name: (identifier) @function)
+(class_declaration name: (type_identifier) @class)
+(protocol_declaration name: (type_identifier) @interface)
+(call_expression) @call
+(import_declaration) @import
+(if_statement) @conditional
+(for_statement) @loop
+(while_statement) @loop
+(switch_statement) @conditional

deviate/core/treesitter/queries/toml.scm

@@ -0,0 +1,3 @@
+; captures: entry
+(table) @entry
+(pair) @entry

deviate/core/treesitter/queries/tsx.scm

@@ -0,0 +1,14 @@
+; captures: function, class, interface, call, import, conditional, loop
+(function_declaration name: (identifier) @function)
+(class_declaration name: (type_identifier) @class)
+(method_definition name: (property_identifier) @method)
+(interface_declaration name: (type_identifier) @interface)
+(type_alias_declaration name: (type_identifier) @interface)
+(arrow_function) @function
+(call_expression) @call
+(import_statement) @import
+(export_statement) @function
+(if_statement) @conditional
+(for_statement) @loop
+(while_statement) @loop
+(switch_statement) @conditional

deviate/core/treesitter/queries/typescript.scm

@@ -0,0 +1,14 @@
+; captures: function, class, interface, call, import, conditional, loop
+(function_declaration name: (identifier) @function)
+(class_declaration name: (type_identifier) @class)
+(method_definition name: (property_identifier) @method)
+(interface_declaration name: (type_identifier) @interface)
+(type_alias_declaration name: (type_identifier) @interface)
+(arrow_function) @function
+(call_expression) @call
+(import_statement) @import
+(export_statement) @function
+(if_statement) @conditional
+(for_statement) @loop
+(while_statement) @loop
+(switch_statement) @conditional

deviate/core/treesitter/queries/yaml.scm

@@ -0,0 +1,4 @@
+; captures: entry
+(block_mapping_pair) @entry
+(block_sequence) @entry
+(flow_mapping) @entry

deviate/core/validation.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+import re
+from collections import namedtuple
+
+import yaml
+
+ValidationResult = namedtuple("ValidationResult", ["passed", "errors", "warnings"])
+
+ARTIFACT_VALIDATORS: dict[str, list[str]] = {
+    "explore": [
+        "Problem Definition",
+        "Discovery Audit Results",
+        "Constitution Quotes",
+        "Architectural Baselines",
+        "Ecosystem Research",
+        "File Registry",
+        "Status Summary",
+    ],
+    "design": [
+        "Recommended Architecture",
+        "Options Matrix",
+        "Rejected Options",
+        "Design Trade-Offs",
+        "Contrarian Viewpoints",
+        "Risk Register",
+        "Constitutional Alignment Audit",
+        "Pending HITL Decisions",
+        "Source Registry",
+        "Status Summary",
+    ],
+    "data_model": [
+        "Entity Definitions",
+        "Relationship Graph",
+        "Schema Tables",
+        "State Transitions",
+        "Data Flow",
+        "Source Registry",
+    ],
+    "prd": [
+        "Document Control and Metadata",
+        "System Objectives and Scope Boundary",
+        "Architectural Constraints and Prerequisites",
+        "Functional Flow and Sequence Architecture",
+        "Functional Requirements and Epics",
+        "Issue Sharding Strategy",
+    ],
+}
+
+
+def validate_artifact(content: str | None, artifact_type: str) -> ValidationResult:
+    required = ARTIFACT_VALIDATORS.get(artifact_type)
+    if required is None:
+        return ValidationResult(
+            passed=False,
+            errors=[f"unknown artifact type: {artifact_type}"],
+            warnings=[],
+        )
+    missing = validate_sections(content, required)
+    passed = len(missing) == 0
+    return ValidationResult(passed=passed, errors=missing, warnings=[])
+
+
+def extract_section_body(content: str, header: str) -> str | None:
+    escaped_header = re.escape(header)
+    pattern = rf"^## {escaped_header}\s*$(.*?)(?=^## |\Z)"
+    match = re.search(pattern, content, re.MULTILINE | re.DOTALL)
+    if match:
+        return match.group(1)
+    return None
+
+
+def validate_gherkin_syntax(content: str) -> list[str]:
+    errors: list[str] = []
+    scenario_pattern = re.compile(r"\*\*(?P<label>(?:Scenario \d+|AC-\d+-\d+)):.*?\*\*")
+    scenarios = list(scenario_pattern.finditer(content))
+    if not scenarios:
+        return errors
+    for i, match in enumerate(scenarios):
+        start = match.end()
+        end = scenarios[i + 1].start() if i + 1 < len(scenarios) else len(content)
+        body = content[start:end]
+        label = match.group("label")
+        if "**Given**" not in body:
+            errors.append(f"{label}: missing 'Given'")
+        if "**When**" not in body:
+            errors.append(f"{label}: missing 'When'")
+        if "**Then**" not in body:
+            errors.append(f"{label}: missing 'Then'")
+    return errors
+
+
+def validate_sections(content: str | None, required: list[str]) -> list[str]:
+    if not content or not content.strip():
+        return list(required)
+    missing: list[str] = []
+    for section in required:
+        pattern = rf"^##\s+\[?{re.escape(section)}\]?\s*$"
+        if not re.search(pattern, content, re.MULTILINE):
+            missing.append(section)
+    return missing
+
+
+def validate_yaml_frontmatter(content: str) -> bool:
+    if not content.lstrip().startswith("---"):
+        return False
+    end_idx = content.find("---", 3)
+    if end_idx == -1:
+        return False
+    frontmatter = content[3:end_idx].strip()
+    try:
+        yaml.safe_load(frontmatter)
+        return True
+    except yaml.YAMLError:
+        return False
+
+
+def validate_task_id(task_id: str) -> bool:
+    if not task_id:
+        return False
+    return bool(re.match(r"^TSK-\d{3}-\d{2}$", task_id))
+
+
+def validate_source_file(source_file: str, epic_slug: str) -> bool:
+    """Validate a shard manifest's ``source_file`` against the issue registry pattern.
+
+    The downstream ``deviate meso run`` command parses ``source_file`` via
+    ``PurePosixPath(source_file).parent.parent.name`` to derive the epic bucket
+    slug and ``PurePosixPath(source_file).stem`` to derive the issue slug used
+    for branch naming. Both rely on the strict shape
+    ``specs/<epic_slug>/issues/<file>.md``. Any deviation (e.g. a PRD or
+    design reference) silently produces wrong branch names and downstream
+    worktree failures.
+
+    Returns ``True`` only when *source_file* matches the expected pattern for
+    *epic_slug*; ``False`` otherwise.
+    """
+    if not source_file or not epic_slug:
+        return False
+    if source_file.startswith("/"):
+        return False
+    parts = source_file.split("/")
+    if len(parts) != 4:
+        return False
+    if parts[0] != "specs":
+        return False
+    if parts[1] != epic_slug:
+        return False
+    if parts[2] != "issues":
+        return False
+    if not parts[3].endswith(".md"):
+        return False
+    return True