buildlog 0.1.0__py3-none-any.whl

buildlog/core/operations.py

@@ -0,0 +1,392 @@
+"""Core operations for buildlog skill management.
+
+This module contains the business logic that can be exposed via
+MCP, CLI, HTTP, or any other interface.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Literal
+
+from buildlog.render import get_renderer
+from buildlog.skills import Skill, SkillSet, generate_skills
+
+__all__ = [
+    "StatusResult",
+    "PromoteResult",
+    "RejectResult",
+    "DiffResult",
+    "status",
+    "promote",
+    "reject",
+    "diff",
+    "find_skills_by_ids",
+]
+
+
+@dataclass
+class StatusResult:
+    """Result of a status operation."""
+
+    skills: dict[str, list[dict]]
+    """Skills grouped by category."""
+
+    total_entries: int
+    """Number of buildlog entries processed."""
+
+    total_skills: int
+    """Total number of skills found."""
+
+    by_confidence: dict[str, int]
+    """Count of skills by confidence level."""
+
+    promotable_ids: list[str]
+    """IDs of high-confidence skills ready for promotion."""
+
+    error: str | None = None
+    """Error message if operation failed."""
+
+
+@dataclass
+class PromoteResult:
+    """Result of a promote operation."""
+
+    promoted_ids: list[str]
+    """IDs of skills that were promoted."""
+
+    target: str
+    """Target format (claude_md or settings_json)."""
+
+    rules_added: int
+    """Number of rules added."""
+
+    not_found_ids: list[str] = field(default_factory=list)
+    """IDs that were not found."""
+
+    message: str = ""
+    """Confirmation message."""
+
+    error: str | None = None
+    """Error message if operation failed."""
+
+
+@dataclass
+class RejectResult:
+    """Result of a reject operation."""
+
+    rejected_ids: list[str]
+    """IDs that were rejected."""
+
+    total_rejected: int
+    """Total number of rejected skills."""
+
+    error: str | None = None
+    """Error message if operation failed."""
+
+
+@dataclass
+class DiffResult:
+    """Result of a diff operation."""
+
+    pending: dict[str, list[dict]]
+    """Skills pending review, grouped by category."""
+
+    total_pending: int
+    """Total number of pending skills."""
+
+    already_promoted: int
+    """Number of previously promoted skills."""
+
+    already_rejected: int
+    """Number of previously rejected skills."""
+
+    error: str | None = None
+    """Error message if operation failed."""
+
+
+def _get_rejected_path(buildlog_dir: Path) -> Path:
+    """Get path to rejected.json file."""
+    return buildlog_dir / ".buildlog" / "rejected.json"
+
+
+def _get_promoted_path(buildlog_dir: Path) -> Path:
+    """Get path to promoted.json file."""
+    return buildlog_dir / ".buildlog" / "promoted.json"
+
+
+def _load_json_set(path: Path, key: str) -> set[str]:
+    """Load a set of IDs from a JSON file."""
+    if not path.exists():
+        return set()
+    try:
+        data = json.loads(path.read_text())
+        return set(data.get(key, []))
+    except (json.JSONDecodeError, OSError):
+        return set()
+
+
+def find_skills_by_ids(
+    skill_set: SkillSet,
+    skill_ids: list[str],
+) -> tuple[list[Skill], list[str]]:
+    """Find skills by their IDs.
+
+    Args:
+        skill_set: The SkillSet to search.
+        skill_ids: List of skill IDs to find.
+
+    Returns:
+        Tuple of (found_skills, not_found_ids).
+    """
+    found: list[Skill] = []
+    not_found: list[str] = []
+
+    # Build lookup map
+    id_to_skill: dict[str, Skill] = {}
+    for category_skills in skill_set.skills.values():
+        for skill in category_skills:
+            id_to_skill[skill.id] = skill
+
+    for skill_id in skill_ids:
+        if skill_id in id_to_skill:
+            found.append(id_to_skill[skill_id])
+        else:
+            not_found.append(skill_id)
+
+    return found, not_found
+
+
+def status(
+    buildlog_dir: Path,
+    min_confidence: Literal["low", "medium", "high"] = "low",
+) -> StatusResult:
+    """Get current skills extracted from buildlog entries.
+
+    Args:
+        buildlog_dir: Path to buildlog directory.
+        min_confidence: Minimum confidence level to include.
+
+    Returns:
+        StatusResult with skills grouped by category and summary statistics.
+    """
+    if not buildlog_dir.exists():
+        return StatusResult(
+            skills={},
+            total_entries=0,
+            total_skills=0,
+            by_confidence={"high": 0, "medium": 0, "low": 0},
+            promotable_ids=[],
+            error=f"No buildlog directory found at {buildlog_dir}",
+        )
+
+    skill_set = generate_skills(buildlog_dir)
+
+    # Load rejected IDs to filter them out
+    rejected_ids = _load_json_set(_get_rejected_path(buildlog_dir), "skill_ids")
+
+    # Filter by confidence and exclude rejected
+    confidence_order = {"low": 0, "medium": 1, "high": 2}
+    min_level = confidence_order[min_confidence]
+
+    filtered: dict[str, list[dict]] = {}
+    by_confidence = {"high": 0, "medium": 0, "low": 0}
+    promotable: list[str] = []
+
+    for category, skill_list in skill_set.skills.items():
+        category_skills = []
+        for skill in skill_list:
+            # Skip rejected skills
+            if skill.id in rejected_ids:
+                continue
+
+            # Count by confidence (before filtering)
+            by_confidence[skill.confidence] += 1
+
+            # Track promotable (high confidence, not rejected)
+            if skill.confidence == "high":
+                promotable.append(skill.id)
+
+            # Apply confidence filter
+            if confidence_order[skill.confidence] >= min_level:
+                category_skills.append(skill.to_dict())
+
+        if category_skills:
+            filtered[category] = category_skills
+
+    # Calculate actual total (sum of by_confidence, which excludes rejected)
+    actual_total = sum(by_confidence.values())
+
+    return StatusResult(
+        skills=filtered,
+        total_entries=skill_set.source_entries,
+        total_skills=actual_total,
+        by_confidence=by_confidence,
+        promotable_ids=promotable,
+    )
+
+
+def promote(
+    buildlog_dir: Path,
+    skill_ids: list[str],
+    target: Literal["claude_md", "settings_json"] = "claude_md",
+    target_path: Path | None = None,
+) -> PromoteResult:
+    """Promote skills to agent rules.
+
+    Args:
+        buildlog_dir: Path to buildlog directory.
+        skill_ids: List of skill IDs to promote.
+        target: Where to write rules ("claude_md" or "settings_json").
+        target_path: Optional custom path for the target file.
+
+    Returns:
+        PromoteResult with confirmation.
+    """
+    if not buildlog_dir.exists():
+        return PromoteResult(
+            promoted_ids=[],
+            target=target,
+            rules_added=0,
+            error=f"No buildlog directory found at {buildlog_dir}",
+        )
+
+    if not skill_ids:
+        return PromoteResult(
+            promoted_ids=[],
+            target=target,
+            rules_added=0,
+            error="No skill IDs provided",
+        )
+
+    skill_set = generate_skills(buildlog_dir)
+    found_skills, not_found_ids = find_skills_by_ids(skill_set, skill_ids)
+
+    if not found_skills:
+        return PromoteResult(
+            promoted_ids=[],
+            target=target,
+            rules_added=0,
+            not_found_ids=not_found_ids,
+            error="No valid skill IDs provided",
+        )
+
+    # Set up tracking path in buildlog directory
+    tracking_path = _get_promoted_path(buildlog_dir)
+
+    # Get renderer with custom paths
+    if target == "claude_md":
+        from buildlog.render.claude_md import ClaudeMdRenderer
+        renderer = ClaudeMdRenderer(path=target_path, tracking_path=tracking_path)
+    else:
+        from buildlog.render.settings_json import SettingsJsonRenderer
+        renderer = SettingsJsonRenderer(path=target_path, tracking_path=tracking_path)
+
+    message = renderer.render(found_skills)
+
+    return PromoteResult(
+        promoted_ids=[s.id for s in found_skills],
+        target=target,
+        rules_added=len(found_skills),
+        not_found_ids=not_found_ids,
+        message=message,
+    )
+
+
+def reject(
+    buildlog_dir: Path,
+    skill_ids: list[str],
+) -> RejectResult:
+    """Mark skills as rejected so they won't be suggested again.
+
+    Args:
+        buildlog_dir: Path to buildlog directory.
+        skill_ids: List of skill IDs to reject.
+
+    Returns:
+        RejectResult with confirmation.
+    """
+    if not skill_ids:
+        return RejectResult(
+            rejected_ids=[],
+            total_rejected=0,
+            error="No skill IDs provided",
+        )
+
+    reject_file = _get_rejected_path(buildlog_dir)
+    reject_file.parent.mkdir(parents=True, exist_ok=True)
+
+    # Load existing rejections
+    if reject_file.exists():
+        try:
+            rejected = json.loads(reject_file.read_text())
+        except json.JSONDecodeError:
+            rejected = {"rejected_at": {}, "skill_ids": []}
+    else:
+        rejected = {"rejected_at": {}, "skill_ids": []}
+
+    # Add new rejections
+    now = datetime.now().isoformat()
+    newly_rejected: list[str] = []
+    for skill_id in skill_ids:
+        if skill_id not in rejected["skill_ids"]:
+            rejected["skill_ids"].append(skill_id)
+            rejected["rejected_at"][skill_id] = now
+            newly_rejected.append(skill_id)
+
+    reject_file.write_text(json.dumps(rejected, indent=2))
+
+    return RejectResult(
+        rejected_ids=newly_rejected,
+        total_rejected=len(rejected["skill_ids"]),
+    )
+
+
+def diff(
+    buildlog_dir: Path,
+) -> DiffResult:
+    """Show skills that haven't been promoted or rejected yet.
+
+    Args:
+        buildlog_dir: Path to buildlog directory.
+
+    Returns:
+        DiffResult with pending skills.
+    """
+    if not buildlog_dir.exists():
+        return DiffResult(
+            pending={},
+            total_pending=0,
+            already_promoted=0,
+            already_rejected=0,
+            error=f"No buildlog directory found at {buildlog_dir}",
+        )
+
+    skill_set = generate_skills(buildlog_dir)
+
+    # Load rejected and promoted IDs
+    rejected_ids = _load_json_set(_get_rejected_path(buildlog_dir), "skill_ids")
+    promoted_ids = _load_json_set(_get_promoted_path(buildlog_dir), "skill_ids")
+
+    # Find unpromoted, unrejected skills
+    pending: dict[str, list[dict]] = {}
+    total_pending = 0
+
+    for category, skill_list in skill_set.skills.items():
+        pending_skills = [
+            s.to_dict() for s in skill_list
+            if s.id not in rejected_ids and s.id not in promoted_ids
+        ]
+        if pending_skills:
+            pending[category] = pending_skills
+            total_pending += len(pending_skills)
+
+    return DiffResult(
+        pending=pending,
+        total_pending=total_pending,
+        already_promoted=len(promoted_ids),
+        already_rejected=len(rejected_ids),
+    )