source-kb 0.2.2__py3-none-any.whl

core/preset_classify.py

@@ -0,0 +1,132 @@
+"""File classification logic — rule-based file→category mapping.
+
+Extracted from core/preset.py to keep file sizes within 300-line limit.
+All classification rules come from preset.yaml config.
+
+Usage:
+    from core.preset_classify import classify_file
+    categories = classify_file(preset, "com/example/OrderService.java", skeleton_entry)
+"""
+
+from __future__ import annotations
+
+import fnmatch
+import os
+
+
+def classify_file(preset: dict, file_path: str, skeleton_entry: dict | None = None) -> list[str]:
+    """Classify a single file into categories using preset rules.
+
+    Match priority: class_type > class_annotations > method_annotations > field_types > patterns.
+    Exclusion: exclude_if conditions checked after match.
+    """
+    classification = preset.get("file_classification", {})
+    matched: list[str] = []
+
+    classes = (skeleton_entry or {}).get("classes", [])
+    methods = (skeleton_entry or {}).get("methods", [])
+    fields = (skeleton_entry or {}).get("fields", [])
+
+    class_types = {c.get("type", "").lower() for c in classes}
+    class_annos = _collect_annotations(classes)
+    method_annos = _collect_method_annotations(methods)
+    field_type_set = {f.get("type", "") for f in fields}
+
+    for cat_name, cfg in classification.items():
+        if not isinstance(cfg, dict):
+            continue
+        hit = _check_match(cfg, file_path, class_types, class_annos, method_annos, field_type_set)
+        if not hit:
+            continue
+        if _should_exclude(cfg, file_path, class_annos, method_annos):
+            continue
+        matched.append(cat_name)
+
+    matched = _apply_exclusions(classification, matched)
+    return matched
+
+
+def _check_match(cfg: dict, file_path: str, class_types: set, class_annos: set,
+                 method_annos: set, field_types: set) -> bool:
+    """Check if a file matches a category's rules."""
+    if cfg.get("class_type") and cfg["class_type"].lower() in class_types:
+        return True
+    ca = cfg.get("class_annotations", [])
+    if ca and any(a in class_annos for a in ca):
+        return True
+    ma = cfg.get("method_annotations", [])
+    if ma and any(a in method_annos for a in ma):
+        return True
+    ft = cfg.get("field_types", [])
+    if ft and any(kw in t for kw in ft for t in field_types):
+        return True
+    patterns = cfg.get("patterns", [])
+    if patterns and _match_patterns(file_path, patterns):
+        return True
+    return False
+
+
+def _should_exclude(cfg: dict, file_path: str, class_annos: set, method_annos: set) -> bool:
+    """Check exclude_if conditions."""
+    exclude = cfg.get("exclude_if")
+    if not exclude:
+        return False
+    path_patterns = exclude.get("path_contains", [])
+    if path_patterns and any(p.lower() in file_path.lower() for p in path_patterns):
+        return True
+    anno_list = exclude.get("has_annotation", [])
+    if anno_list and any(a in class_annos for a in anno_list):
+        return True
+    method_anno_list = exclude.get("has_method_annotation", [])
+    if method_anno_list and any(a in method_annos for a in method_anno_list):
+        return True
+    return False
+
+
+def _apply_exclusions(classification: dict, matched: list[str]) -> list[str]:
+    """Apply matched_by exclusions and priority conflict resolution."""
+    if len(matched) <= 1:
+        return matched
+    matched_set = set(matched)
+    to_remove: set[str] = set()
+    for cat in matched:
+        cfg = classification.get(cat, {})
+        matched_by = cfg.get("exclude_if", {}).get("matched_by", [])
+        if matched_by and any(m in matched_set for m in matched_by):
+            to_remove.add(cat)
+    return [c for c in matched if c not in to_remove]
+
+
+def _match_patterns(file_path: str, patterns: list[str]) -> bool:
+    """Check if file path matches any pattern (glob or substring)."""
+    file_lower = file_path.lower()
+    for p in patterns:
+        pl = p.lower()
+        if pl.startswith("*"):
+            if fnmatch.fnmatch(os.path.basename(file_lower), pl):
+                return True
+        elif pl in file_lower:
+            return True
+    return False
+
+
+def _collect_annotations(classes: list[dict]) -> set[str]:
+    annos: set[str] = set()
+    for c in classes:
+        for a in c.get("annotations", []):
+            if isinstance(a, dict):
+                annos.add(a.get("name", ""))
+            else:
+                annos.add(a.split("(")[0])
+    return annos
+
+
+def _collect_method_annotations(methods: list[dict]) -> set[str]:
+    annos: set[str] = set()
+    for m in methods:
+        for a in m.get("annotations", []):
+            if isinstance(a, dict):
+                annos.add(a.get("name", ""))
+            else:
+                annos.add(a.split("(")[0])
+    return annos

core/preset_hooks.py

@@ -0,0 +1,129 @@
+"""Preset hooks — pluggable language/framework-specific logic.
+
+Provides a base PresetHooks class with no-op defaults. Each preset can optionally
+provide a hooks.py that subclasses PresetHooks and overrides methods for
+language-specific behavior.
+
+Core modules call hooks instead of hardcoding Java/Spring assumptions.
+
+Usage:
+    from core.preset_hooks import load_hooks
+    hooks = load_hooks("java-spring")
+    framework_types = hooks.get_framework_types()
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import logging
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class PresetHooks:
+    """Base hooks class — all methods return empty/default values.
+
+    Presets override only the methods they need. Core code calls these
+    methods instead of hardcoding language-specific logic.
+    """
+
+    def get_business_suffixes(self) -> tuple[str, ...]:
+        """Class name suffixes that indicate business logic classes."""
+        return ()
+
+    def get_infra_suffixes(self) -> tuple[str, ...]:
+        """Class name suffixes that indicate infrastructure classes."""
+        return ()
+
+    def get_data_suffixes(self) -> tuple[str, ...]:
+        """Class name suffixes that indicate data/model classes."""
+        return ()
+
+    def get_framework_types(self) -> set[str]:
+        """Types to exclude from dependency analysis (framework internals)."""
+        return set()
+
+    def get_common_types(self) -> frozenset[str]:
+        """Common language types to exclude from import analysis."""
+        return frozenset()
+
+    def get_noise_terms(self) -> set[str]:
+        """Terms to filter from keyword extraction."""
+        return set()
+
+    def get_inject_annotations(self) -> set[str]:
+        """DI annotations for dependency extraction."""
+        return set()
+
+    def get_controller_annotations(self) -> list[str]:
+        """Annotations that mark controller/endpoint classes."""
+        return []
+
+    def get_entity_annotations(self) -> list[str]:
+        """Annotations that mark entity/model classes."""
+        return []
+
+    def get_source_extensions(self) -> list[str]:
+        """File extensions for source files in this language."""
+        return []
+
+    def get_test_path_patterns(self) -> list[str]:
+        """Path patterns that indicate test directories."""
+        return ["/test/", "/tests/", "/__tests__/"]
+
+    def get_split_name_suffixes(self) -> tuple[str, ...]:
+        """Class suffixes used for deriving semantic split names."""
+        return ()
+
+    def count_source_files(self, source_cache: Path) -> tuple[int, int]:
+        """Count (files, lines) for this language's source files.
+
+        Returns (0, 0) if not implemented — callers should handle gracefully.
+        """
+        return 0, 0
+
+    def extract_package_from_fqn(self, fqn: str) -> str:
+        """Extract package from a fully-qualified name."""
+        return ""
+
+    def get_focus_hint(self, doc_type: str) -> str:
+        """Return a focus hint for LLM-based split planning."""
+        return ""
+
+
+def load_hooks(preset_name: str) -> PresetHooks:
+    """Load preset-specific hooks, or return base (no-op) hooks.
+
+    Looks for presets/{preset_name}/hooks.py with a class named
+    `Hooks` that subclasses PresetHooks.
+    """
+    from core.preset import _find_preset_dir
+
+    preset_dir = _find_preset_dir(preset_name)
+    if preset_dir is None:
+        return PresetHooks()
+
+    hooks_path = preset_dir / "hooks.py"
+    if not hooks_path.exists():
+        return PresetHooks()
+
+    try:
+        spec = importlib.util.spec_from_file_location(
+            f"presets.{preset_name}.hooks", hooks_path
+        )
+        if spec is None or spec.loader is None:
+            return PresetHooks()
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+
+        hooks_cls = getattr(module, "Hooks", None)
+        if hooks_cls and issubclass(hooks_cls, PresetHooks):
+            return hooks_cls()
+
+        logger.warning("hooks.py for '%s' has no Hooks class", preset_name)
+        return PresetHooks()
+    except Exception as e:
+        logger.warning("failed to load hooks for '%s': %s", preset_name, e)
+        return PresetHooks()

core/preset_profile.py

@@ -0,0 +1,89 @@
+"""Preset profile resolution and show-config support.
+
+Provides module-type-specific profile resolution and configuration inspection.
+
+Usage:
+    from core.preset_profile import resolve_profile, show_config
+
+    effective = resolve_profile("java-spring", module_type="base-lib")
+    config = show_config("java-spring", section="split")
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+# ---------------------------------------------------------------------------
+# Profile resolution
+# ---------------------------------------------------------------------------
+
+
+def resolve_profile(preset_name: str, module_type: str = "service") -> dict[str, Any]:
+    """Resolve the effective profile for a given preset and module type.
+
+    Currently just returns the base preset — profile overrides are not yet used.
+    Module-type-specific skip rules are handled by module_types config in dispatch.
+
+    Args:
+        preset_name: Name of the preset (e.g., "java-spring")
+        module_type: Module type (e.g., "service", "base-lib", "api-contract")
+
+    Returns:
+        Preset configuration dict.
+    """
+    from core.preset import load_preset
+    return load_preset(preset_name)
+
+
+# ---------------------------------------------------------------------------
+# Show-config support (data retrieval, no I/O)
+# ---------------------------------------------------------------------------
+
+
+def show_config(preset_name: str, section: str | None = None) -> dict[str, Any]:
+    """Return preset configuration for inspection.
+
+    Args:
+        preset_name: Name of the preset to load.
+        section: Optional section to filter (e.g., "split", "doc_types", "limits").
+
+    Returns:
+        Full preset dict or specific section.
+    """
+    from core.preset import load_preset
+    preset = load_preset(preset_name)
+    if section:
+        value = preset.get(section)
+        if value is None:
+            raise KeyError(f"Section '{section}' not found in preset '{preset_name}'")
+        return {section: value}
+    return preset
+
+
+# ---------------------------------------------------------------------------
+# CLI entry point: python -m core.preset show-config --preset X --section Y
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    import argparse
+    import json as _json
+    import sys
+
+    parser = argparse.ArgumentParser(description="Preset configuration tool")
+    sub = parser.add_subparsers(dest="command")
+
+    p_show = sub.add_parser("show-config", help="Display preset configuration")
+    p_show.add_argument("--preset", required=True, help="Preset name")
+    p_show.add_argument("--section", default=None, help="Config section to show")
+
+    args = parser.parse_args()
+    if args.command == "show-config":
+        try:
+            data = show_config(args.preset, args.section)
+            print(_json.dumps(data, ensure_ascii=False, indent=2))
+        except (FileNotFoundError, KeyError) as e:
+            print(f"Error: {e}", file=sys.stderr)
+            sys.exit(1)
+    else:
+        parser.print_help()

core/prompt/__init__.py

@@ -0,0 +1,7 @@
+"""core.prompt — prompt rendering and content assembly.
+
+Sub-modules:
+    renderer    — Template loading, variable computation, rendering
+    content     — Source reading, skeleton reading, context building
+    templates   — PromptTemplate dataclass + registry
+"""

core/prompt/__main__.py

@@ -0,0 +1,147 @@
+"""CLI entry point for prompt rendering.
+
+Provides the render-prompt command for Agent mode:
+    python -m core.prompt render --template ... --module ... --doc-type ...
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+sys.stdout.reconfigure(encoding="utf-8")
+
+
+def cmd_render(args: argparse.Namespace) -> None:
+    """Render a sub-agent prompt from template."""
+    from core.config import load_config
+    from core.preset import load_preset
+    from core.prompt.renderer import render_prompt
+
+    config = load_config(Path(args.config) if args.config else None)
+    kb_config = config.get_kb(args.kb)
+    preset_name = kb_config.get("preset", "generic")
+    preset = load_preset(preset_name)
+
+    # In Agent mode, use ReferenceAssembler (paths only, no inline content)
+    from core.prompt.variables import ReferencePromptAssembler
+    assembler = ReferencePromptAssembler(project_root=Path(".").resolve(), preset=preset)
+
+    # Resolve template: explicit --template takes priority, otherwise lookup from doc_types.yaml
+    template_name = args.template
+    if not template_name:
+        doc_types = preset.get("doc_types", {})
+        dt_cfg = doc_types.get(args.doc_type, {})
+        template_name = dt_cfg.get("template")
+        if not template_name:
+            print(f"Error: no template mapping for doc-type '{args.doc_type}' in {preset_name}/doc_types.yaml. "
+                  f"Specify --template explicitly.", file=sys.stderr)
+            sys.exit(1)
+
+    # Find template
+    template_path = _find_template(template_name, preset_name)
+    if not template_path:
+        print(f"Error: template not found: {template_name}", file=sys.stderr)
+        sys.exit(1)
+
+    # Parse extras
+    extras = {}
+    if args.extra:
+        for item in args.extra:
+            if "=" in item:
+                k, v = item.split("=", 1)
+                extras[k] = v
+
+    # Load execution snippet
+    execution_snippet = ""
+    if args.mode == "readwrite":
+        snippet_path = Path("skills/kb-init/templates/core/readwrite.md")
+        if snippet_path.exists():
+            execution_snippet = snippet_path.read_text(encoding="utf-8")
+    elif args.mode == "output-only":
+        snippet_path = Path("skills/kb-init/templates/core/output-only.md")
+        if snippet_path.exists():
+            execution_snippet = snippet_path.read_text(encoding="utf-8")
+
+    rendered = render_prompt(
+        template_path=template_path,
+        config=config.raw,
+        kb_name=args.kb,
+        module_name=args.module,
+        doc_type=args.doc_type,
+        assembler=assembler,
+        extras=extras,
+        execution_snippet=execution_snippet,
+        preset=preset,
+    )
+
+    if args.output:
+        Path(args.output).parent.mkdir(parents=True, exist_ok=True)
+        Path(args.output).write_text(rendered, encoding="utf-8")
+        print(f"Rendered to: {args.output} ({len(rendered)} chars)")
+    else:
+        # Default: write to .meta/prompts/{doc_type}.md to avoid flooding stdout
+        meta_prompts = Path(f"knowledge/{args.module}/.meta/prompts")
+        meta_prompts.mkdir(parents=True, exist_ok=True)
+        out_path = meta_prompts / f"{args.doc_type}.md"
+        out_path.write_text(rendered, encoding="utf-8")
+        print(f"Rendered to: {out_path} ({len(rendered)} chars)")
+
+    print(json.dumps({"status": "ok", "chars": len(rendered)}, ensure_ascii=False), file=sys.stderr)
+
+
+def _find_template(template_name: str, preset_name: str) -> Path | None:
+    """Find template file by name. Templates live in presets/{preset}/templates/."""
+    # If it's already a valid path
+    p = Path(template_name)
+    if p.exists():
+        return p
+
+    # Search in preset templates (single source of truth)
+    candidate = Path("presets") / preset_name / "templates" / template_name
+    if candidate.exists():
+        return candidate
+    return None
+
+
+def main():
+    import warnings
+    warnings.warn(
+        "Use 'source-kb render' instead of 'python -m core.prompt render'",
+        DeprecationWarning, stacklevel=2,
+    )
+    print("[DEPRECATED] Use 'source-kb render' instead of 'python -m core.prompt'",
+          file=sys.stderr)
+    parser = argparse.ArgumentParser(prog="python -m core.prompt", description="Prompt tools")
+    sub = parser.add_subparsers(dest="command")
+
+    p = sub.add_parser("render", help="Render a sub-agent prompt")
+    p.add_argument("--template", help="Template filename or path (auto-resolved from doc_types.yaml if omitted)")
+    p.add_argument("--module", required=True, help="Module name")
+    p.add_argument("--config", help="kb-project.yaml path")
+    p.add_argument("--kb", required=True, help="Knowledge base name")
+    p.add_argument("--doc-type", required=True, help="Document type")
+    p.add_argument("--mode", default="readwrite", choices=["readwrite", "output-only"])
+    p.add_argument("--output", help="Output file path")
+    p.add_argument("--extra", nargs="*", help="Extra variables (key=value)")
+
+    p = sub.add_parser("validate-parity", help="Validate CLI/Agent template parity")
+    p.add_argument("--preset", required=True, help="Preset name")
+
+    args = parser.parse_args()
+    if not args.command:
+        parser.print_help()
+        sys.exit(1)
+
+    if args.command == "render":
+        cmd_render(args)
+    elif args.command == "validate-parity":
+        from core.prompt.validate_parity import main as parity_main
+        # Re-parse with validate_parity's own parser
+        parity_main()
+
+
+if __name__ == "__main__":
+    main()