wicked-garden 12.27.0

package/scripts/engineering/patch/codegraph_db.py

@@ -0,0 +1,125 @@
+#!/usr/bin/env python3
+"""codegraph_db.py — adapt codegraph's SQLite into the symbol-graph DB wicked-patch
+expects (the `--db`).
+
+This is the payoff of ADR 0001: codegraph builds a column-precise, multi-language
+symbol+edge graph; wicked-patch needs a `--db` with a `symbols` table + reference
+tables for cross-file refactor (rename/add-field/remove). Nothing produced that
+`--db` before, so the patch family was dead-on-arrival. This translates
+codegraph's `nodes`/`edges` into the schema `PropagationEngine` + `_resolve_symbol_id`
+read, reviving the family without changing patch's engine.
+
+Mapping (codegraph → patch):
+  nodes(id,name,kind,file_path,start_line,end_line,metadata)
+      -> symbols(id,name,type,file_path,line_start,line_end,metadata,layer)
+  edges(source,target,kind):
+      kind='references' -> symbol_refs(source_id,target_id,ref_type) + refs
+      kind='calls'      -> symbol_calls(symbol_id,target_id)         + refs
+      kind='imports'    -> symbol_imports(symbol_id,target_id)       + refs
+      (all)             -> refs(source_id,target_id,ref_type,confidence)
+  + metadata(key,value) with indexed_at (safety.py freshness check)
+
+Stdlib-only. Deterministic. Rebuilds the patch DB from scratch each run.
+"""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Dict
+
+# codegraph edge kind -> (patch reference table, columns)
+_EDGE_TABLE = {
+    "references": ("symbol_refs", ("source_id", "target_id", "ref_type")),
+    "calls": ("symbol_calls", ("symbol_id", "target_id")),
+    "imports": ("symbol_imports", ("symbol_id", "target_id")),
+}
+
+
+def build_patch_db(codegraph_db: Path, out_db: Path) -> Dict[str, int]:
+    """Translate a codegraph SQLite into a patch-compatible symbol-graph DB.
+    Returns counts. Rebuilds out_db from scratch (idempotent)."""
+    if not Path(codegraph_db).exists():
+        raise FileNotFoundError(f"codegraph db not found: {codegraph_db}; run `codegraph index` first")
+    src = sqlite3.connect(f"file:{codegraph_db}?mode=ro", uri=True)
+    src.row_factory = sqlite3.Row
+    if Path(out_db).exists():
+        Path(out_db).unlink()
+    dst = sqlite3.connect(str(out_db))
+    try:
+        dst.executescript(
+            """
+            CREATE TABLE symbols (
+              id TEXT PRIMARY KEY, name TEXT, type TEXT, file_path TEXT,
+              line_start INTEGER, line_end INTEGER, metadata TEXT, layer TEXT
+            );
+            CREATE TABLE refs (source_id TEXT, target_id TEXT, ref_type TEXT, confidence REAL);
+            CREATE TABLE symbol_refs (source_id TEXT, target_id TEXT, ref_type TEXT);
+            CREATE TABLE symbol_calls (symbol_id TEXT, target_id TEXT);
+            CREATE TABLE symbol_imports (symbol_id TEXT, target_id TEXT);
+            CREATE TABLE metadata (key TEXT PRIMARY KEY, value TEXT);
+            CREATE INDEX idx_symbols_name ON symbols(name);
+            CREATE INDEX idx_symbols_file ON symbols(file_path);
+            CREATE INDEX idx_refs_target ON refs(target_id);
+            """
+        )
+        counts = {"symbols": 0, "refs": 0, "symbol_refs": 0, "symbol_calls": 0, "symbol_imports": 0}
+        # codegraph nodes carry no `metadata` column. PropagationEngine does
+        # json.loads(metadata) so it MUST be a JSON object (or NULL -> "{}").
+        # Pack the useful codegraph fields (signature) as JSON. layer has no
+        # codegraph equivalent -> NULL.
+        for r in src.execute(
+            "SELECT id, name, kind, file_path, start_line, end_line, signature FROM nodes"
+        ):
+            meta = json.dumps({"signature": r["signature"]}) if r["signature"] else None
+            dst.execute(
+                "INSERT OR IGNORE INTO symbols (id,name,type,file_path,line_start,line_end,metadata,layer)"
+                " VALUES (?,?,?,?,?,?,?,?)",
+                (r["id"], r["name"], r["kind"], r["file_path"],
+                 r["start_line"], r["end_line"], meta, None),
+            )
+            counts["symbols"] += 1
+        for e in src.execute("SELECT source, target, kind FROM edges"):
+            s, t, k = e["source"], e["target"], e["kind"]
+            dst.execute("INSERT INTO refs (source_id,target_id,ref_type,confidence) VALUES (?,?,?,?)",
+                        (s, t, k, 1.0))
+            counts["refs"] += 1
+            spec = _EDGE_TABLE.get(k)
+            if spec:
+                table, cols = spec
+                dst.execute(f"INSERT INTO {table} ({','.join(cols)}) VALUES ({','.join('?' * len(cols))})",
+                            (s, t, k) if len(cols) == 3 else (s, t))
+                counts[table] += 1
+        dst.execute("INSERT INTO metadata (key,value) VALUES ('indexed_at', ?)",
+                    (datetime.now(timezone.utc).isoformat(),))
+        dst.execute("INSERT INTO metadata (key,value) VALUES ('source', 'codegraph')")
+        dst.commit()
+        return counts
+    finally:
+        src.close()
+        dst.close()
+
+
+def main() -> int:
+    import argparse
+    p = argparse.ArgumentParser(description="Build a wicked-patch --db from codegraph's SQLite.")
+    p.add_argument("--codegraph-db", default=".codegraph/codegraph.db")
+    p.add_argument("--out", default=".wicked/patch-symbols.db")
+    a = p.parse_args()
+    out = Path(a.out)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        counts = build_patch_db(Path(a.codegraph_db), out)
+    except FileNotFoundError as e:
+        print(str(e), file=sys.stderr)
+        return 1
+    import json
+    print(json.dumps({"out": str(out), **counts}, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/engineering/patch/generators/__init__.py

@@ -0,0 +1,56 @@
+"""
+Code generators for wicked-patch.
+
+Generators are the code-production side of the patch pipeline:
+- Input: change spec + affected symbols
+- Output: concrete patches per file
+
+Uses the symbol graph (from --db or wicked-brain once available) to
+propagate changes across all affected files automatically.
+"""
+
+from .base import (
+    BaseGenerator,
+    GeneratorRegistry,
+    register_generator,
+    ChangeSpec,
+    ChangeType,
+    FieldSpec,
+    Patch,
+    PatchSet,
+)
+
+# Import generators to register them
+from . import java_generator
+from . import jsp_generator
+from . import python_generator
+from . import typescript_generator
+from . import sql_generator
+from . import go_generator
+from . import csharp_generator
+from . import ruby_generator
+from . import kotlin_generator
+from . import rust_generator
+from . import php_generator
+from . import perl_generator
+
+# Import propagation engine
+from .propagation_engine import PropagationEngine, PropagationPlan, AffectedSymbol
+
+__all__ = [
+    # Base classes
+    "BaseGenerator",
+    "GeneratorRegistry",
+    "register_generator",
+    # Change specifications
+    "ChangeSpec",
+    "ChangeType",
+    "FieldSpec",
+    # Patch handling
+    "Patch",
+    "PatchSet",
+    # Propagation
+    "PropagationEngine",
+    "PropagationPlan",
+    "AffectedSymbol",
+]

package/scripts/engineering/patch/generators/base.py

@@ -0,0 +1,373 @@
+"""
+Base generator interface and registry for language-agnostic code generation.
+
+Generators are the symmetric counterpart to adapters. While adapters extract
+symbols from code, generators create patches to modify code based on change
+specifications and the symbol graph.
+
+Architecture:
+    ChangeSpec -> Generator.generate() -> Patch/PatchSet
+
+The propagation engine uses lineage paths to coordinate generators:
+    1. User specifies a change to a symbol (e.g., add field to entity)
+    2. Lineage tracer finds all dependent symbols
+    3. For each affected file, the appropriate generator creates patches
+    4. All patches are returned as a PatchSet for review/application
+"""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set, Type, Union
+import logging
+import threading
+
+logger = logging.getLogger(__name__)
+
+
+class ChangeType(str, Enum):
+    """Types of changes that can be propagated."""
+    ADD_FIELD = "add_field"           # Add a field to an entity/class
+    REMOVE_FIELD = "remove_field"     # Remove a field
+    RENAME_FIELD = "rename_field"     # Rename a field
+    MODIFY_FIELD = "modify_field"     # Change field type or attributes
+    ADD_VALIDATION = "add_validation" # Add validation logic
+    ADD_COLUMN = "add_column"         # Add database column
+    RENAME_COLUMN = "rename_column"   # Rename database column
+    ADD_UI_BINDING = "add_ui_binding" # Add UI binding for field
+    UPDATE_UI_BINDING = "update_ui_binding"  # Update existing UI binding
+
+
+@dataclass
+class FieldSpec:
+    """Specification for a field/property."""
+    name: str
+    type: str                          # Language-agnostic type hint
+    nullable: bool = True
+    default: Optional[str] = None
+    validation: Optional[Dict[str, Any]] = None  # e.g., {"min": 0, "max": 100}
+    annotations: List[str] = field(default_factory=list)
+    column_name: Optional[str] = None  # Database column name if different
+    label: Optional[str] = None        # UI label
+    description: Optional[str] = None
+
+
+@dataclass
+class ChangeSpec:
+    """
+    Specification for a change to propagate.
+
+    This is language-agnostic - the generator translates it to
+    language-specific code modifications.
+    """
+    change_type: ChangeType
+    target_symbol_id: str              # Symbol being modified
+    field_spec: Optional[FieldSpec] = None  # For add/modify field
+    old_name: Optional[str] = None     # For rename operations
+    new_name: Optional[str] = None     # For rename operations
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self):
+        if isinstance(self.change_type, str):
+            self.change_type = ChangeType(self.change_type)
+
+
+@dataclass
+class Patch:
+    """
+    A single code modification.
+
+    Patches are expressed as line-based edits to maintain
+    readability and allow for conflict detection.
+    """
+    file_path: str
+    line_start: int                    # 1-based line number
+    line_end: int                      # Inclusive end line
+    old_content: str                   # Original lines (for verification)
+    new_content: str                   # Replacement content
+    description: str                   # Human-readable description
+    symbol_id: Optional[str] = None    # Related symbol
+    confidence: str = "high"           # high/medium/low
+
+    @property
+    def is_insert(self) -> bool:
+        """True if this is an insertion (no lines replaced)."""
+        return self.line_start > self.line_end
+
+    @property
+    def is_delete(self) -> bool:
+        """True if this is a deletion (empty new content)."""
+        return not self.new_content.strip()
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "file": self.file_path,
+            "line_start": self.line_start,
+            "line_end": self.line_end,
+            "old": self.old_content,
+            "new": self.new_content,
+            "description": self.description,
+            "symbol_id": self.symbol_id,
+            "confidence": self.confidence,
+        }
+
+    def to_unified_diff(self) -> str:
+        """Generate unified diff format."""
+        from difflib import unified_diff
+        old_lines = self.old_content.splitlines(keepends=True)
+        new_lines = self.new_content.splitlines(keepends=True)
+        diff = unified_diff(
+            old_lines, new_lines,
+            fromfile=f"a/{self.file_path}",
+            tofile=f"b/{self.file_path}",
+            lineterm=""
+        )
+        return "".join(diff)
+
+
+@dataclass
+class PatchSet:
+    """
+    Collection of patches for a change propagation.
+
+    Groups patches by file and provides aggregate statistics.
+    """
+    change_spec: ChangeSpec
+    patches: List[Patch] = field(default_factory=list)
+    errors: List[str] = field(default_factory=list)
+    warnings: List[str] = field(default_factory=list)
+
+    @property
+    def files_affected(self) -> Set[str]:
+        """Set of files that will be modified."""
+        return {p.file_path for p in self.patches}
+
+    @property
+    def patch_count(self) -> int:
+        return len(self.patches)
+
+    @property
+    def has_errors(self) -> bool:
+        return len(self.errors) > 0
+
+    def patches_by_file(self) -> Dict[str, List[Patch]]:
+        """Group patches by file path."""
+        by_file: Dict[str, List[Patch]] = {}
+        for patch in self.patches:
+            if patch.file_path not in by_file:
+                by_file[patch.file_path] = []
+            by_file[patch.file_path].append(patch)
+        # Sort patches within each file by line number (descending for safe application).
+        # enumerate() provides a stable secondary key so same-position patches
+        # preserve their original generation order after reversal.
+        for patches in by_file.values():
+            indexed = list(enumerate(patches))
+            indexed.sort(key=lambda t: (t[1].line_start, t[0]), reverse=True)
+            patches[:] = [p for _, p in indexed]
+        return by_file
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "change_type": self.change_spec.change_type.value,
+            "target": self.change_spec.target_symbol_id,
+            "files_affected": list(self.files_affected),
+            "patch_count": self.patch_count,
+            "patches": [p.to_dict() for p in self.patches],
+            "errors": self.errors,
+            "warnings": self.warnings,
+        }
+
+    def summary(self) -> str:
+        """Human-readable summary."""
+        lines = [
+            f"Change: {self.change_spec.change_type.value}",
+            f"Target: {self.change_spec.target_symbol_id}",
+            f"Files affected: {len(self.files_affected)}",
+            f"Patches: {self.patch_count}",
+        ]
+        if self.errors:
+            lines.append(f"Errors: {len(self.errors)}")
+        if self.warnings:
+            lines.append(f"Warnings: {len(self.warnings)}")
+        return "\n".join(lines)
+
+
+class BaseGenerator(ABC):
+    """
+    Base class for language-specific code generators.
+
+    Each generator knows how to create patches for its language
+    based on change specifications.
+    """
+
+    # Override in subclasses
+    name: str = "base"
+    extensions: Set[str] = set()  # e.g., {'.java'}
+    symbol_types: Set[str] = set()  # Symbol types this generator handles
+
+    def __init__(self, db_path: Optional[Path] = None):
+        """
+        Initialize generator.
+
+        Args:
+            db_path: Path to symbol database for context lookup
+        """
+        self.db_path = db_path
+        self._conn = None
+
+    @abstractmethod
+    def generate(
+        self,
+        change_spec: ChangeSpec,
+        symbol: Dict[str, Any],
+        file_content: str,
+    ) -> List[Patch]:
+        """
+        Generate patches for a change.
+
+        Args:
+            change_spec: The change to apply
+            symbol: The symbol being modified (from database)
+            file_content: Current content of the file
+
+        Returns:
+            List of patches to apply
+        """
+        raise NotImplementedError("Subclasses must implement generate() to produce language-specific patches")
+
+    def supports_file(self, file_path: str) -> bool:
+        """Check if this generator handles the given file type."""
+        ext = Path(file_path).suffix.lower()
+        return ext in self.extensions
+
+    def supports_symbol(self, symbol_type: str) -> bool:
+        """Check if this generator handles the given symbol type."""
+        return symbol_type.lower() in {t.lower() for t in self.symbol_types}
+
+    def _get_indentation(self, line: str) -> str:
+        """Extract indentation from a line."""
+        return line[:len(line) - len(line.lstrip())]
+
+    def _map_type(self, generic_type: str, language: str = None) -> str:
+        """
+        Map a generic type to a language-specific type.
+
+        Override in subclasses for language-specific mappings.
+        """
+        # Default mappings
+        type_map = {
+            "string": "String",
+            "int": "int",
+            "integer": "Integer",
+            "long": "Long",
+            "float": "float",
+            "double": "double",
+            "boolean": "boolean",
+            "date": "Date",
+            "datetime": "LocalDateTime",
+            "decimal": "BigDecimal",
+        }
+        return type_map.get(generic_type.lower(), generic_type)
+
+
+# Registry for generators
+_GENERATOR_REGISTRY: Dict[str, Type[BaseGenerator]] = {}
+_instances: Dict[str, BaseGenerator] = {}
+_lock = threading.Lock()
+
+
+def register_generator(cls: Type[BaseGenerator]) -> Type[BaseGenerator]:
+    """
+    Decorator to register a generator class.
+
+    Usage:
+        @register_generator
+        class JavaGenerator(BaseGenerator):
+            name = "java"
+            extensions = {'.java'}
+            ...
+    """
+    for ext in cls.extensions:
+        _GENERATOR_REGISTRY[ext] = cls
+        logger.debug(f"Registered generator {cls.name} for {ext}")
+    return cls
+
+
+class GeneratorRegistry:
+    """
+    Registry for code generators.
+
+    Maps file extensions and symbol types to generators.
+    Thread-safe with instance caching.
+    """
+
+    @classmethod
+    def get_generator(
+        cls,
+        file_path: str,
+        db_path: Optional[Path] = None
+    ) -> Optional[BaseGenerator]:
+        """
+        Get generator instance for a file.
+
+        Args:
+            file_path: Path to file
+            db_path: Optional database path
+
+        Returns:
+            Generator instance or None
+        """
+        ext = Path(file_path).suffix.lower()
+        generator_class = _GENERATOR_REGISTRY.get(ext)
+
+        if not generator_class:
+            return None
+
+        # Thread-safe cache lookup
+        cache_key = f"{generator_class.name}:{db_path}"
+        with _lock:
+            if cache_key not in _instances:
+                _instances[cache_key] = generator_class(db_path)
+            return _instances[cache_key]
+
+    @classmethod
+    def supported_extensions(cls) -> Set[str]:
+        """Get all registered file extensions."""
+        return set(_GENERATOR_REGISTRY.keys())
+
+    @classmethod
+    def list_generators(cls) -> Dict[str, Type[BaseGenerator]]:
+        """List all registered generators."""
+        return dict(_GENERATOR_REGISTRY)
+
+    @classmethod
+    def generate(
+        cls,
+        change_spec: ChangeSpec,
+        symbol: Dict[str, Any],
+        file_content: str,
+        file_path: str,
+        db_path: Optional[Path] = None,
+    ) -> List[Patch]:
+        """
+        Generate patches using the appropriate generator.
+
+        Args:
+            change_spec: Change specification
+            symbol: Symbol being modified
+            file_content: Current file content
+            file_path: Path to file
+            db_path: Optional database path
+
+        Returns:
+            List of patches, empty if no generator available
+        """
+        generator = cls.get_generator(file_path, db_path)
+        if generator:
+            try:
+                return generator.generate(change_spec, symbol, file_content)
+            except Exception as e:
+                logger.warning(f"Generator {generator.name} failed: {e}")
+                return []
+        return []