buildlog 0.6.1__py3-none-any.whl → 0.8.0__py3-none-any.whl

buildlog/mcp/tools.py

@@ -12,6 +12,7 @@ from typing import Literal
 from buildlog.core import (
     diff,
     end_session,
+    get_bandit_status,
     get_experiment_report,
     get_rewards,
     get_session_metrics,
@@ -52,17 +53,17 @@ def buildlog_status(
 
 def buildlog_promote(
     skill_ids: list[str],
-    target: Literal["claude_md", "settings_json", "skill"] = "claude_md",
+    target: str = "claude_md",
     buildlog_dir: str = "buildlog",
 ) -> dict:
     """Promote skills to your agent's rules.
 
-    Writes selected skills to CLAUDE.md, .claude/settings.json, or
-    .claude/skills/buildlog-learned/SKILL.md (Anthropic Agent Skills format).
+    Writes selected skills to agent-specific rule files.
 
     Args:
         skill_ids: List of skill IDs to promote (e.g., ["arch-b0fcb62a1e"])
-        target: Where to write rules ("claude_md", "settings_json", or "skill")
+        target: Where to write rules. One of: claude_md, settings_json,
+            skill, cursor, copilot, windsurf, continue_dev.
         buildlog_dir: Path to buildlog directory
 
     Returns:
@@ -262,36 +263,47 @@ def buildlog_rewards(
 # -----------------------------------------------------------------------------
 
 
-def buildlog_start_session(
+def buildlog_experiment_start(
     error_class: str | None = None,
     notes: str | None = None,
+    select_k: int = 3,
     buildlog_dir: str = "buildlog",
 ) -> dict:
-    """Start a new experiment session.
+    """Start a new experiment session with Thompson Sampling rule selection.
 
-    Begins tracking for a learning experiment. Captures the current
-    set of active rules to measure learning over time.
+    Begins tracking for a learning experiment. Uses Thompson Sampling
+    to select which rules will be "active" for this session based on
+    the error class context.
+
+    The selected rules will receive feedback:
+    - Negative feedback (reward=0) when log_mistake() is called
+    - Explicit feedback when log_reward() is called
+
+    This teaches the bandit which rules are effective for which contexts.
 
     Args:
-        error_class: Error class being targeted (e.g., "missing_test")
+        error_class: Error class being targeted (e.g., "missing_test").
+                    This is the CONTEXT for contextual bandits.
         notes: Notes about this session
+        select_k: Number of rules to select via Thompson Sampling
         buildlog_dir: Path to buildlog directory
 
     Returns:
-        Dict with session_id, error_class, rules_count, message
+        Dict with session_id, error_class, rules_count, selected_rules, message
 
     Example:
-        buildlog_start_session(error_class="missing_test")
+        buildlog_start_session(error_class="type-errors", select_k=5)
     """
     result = start_session(
         Path(buildlog_dir),
         error_class=error_class,
         notes=notes,
+        select_k=select_k,
     )
     return asdict(result)
 
 
-def buildlog_end_session(
+def buildlog_experiment_end(
     entry_file: str | None = None,
     notes: str | None = None,
     buildlog_dir: str = "buildlog",
@@ -358,7 +370,7 @@ def buildlog_log_mistake(
     return asdict(result)
 
 
-def buildlog_session_metrics(
+def buildlog_experiment_metrics(
     session_id: str | None = None,
     buildlog_dir: str = "buildlog",
 ) -> dict:
@@ -405,3 +417,144 @@ def buildlog_experiment_report(
         buildlog_experiment_report()
     """
     return get_experiment_report(Path(buildlog_dir))
+
+
+def buildlog_bandit_status(
+    buildlog_dir: str = "buildlog",
+    context: str | None = None,
+    top_k: int = 10,
+) -> dict:
+    """Get Thompson Sampling bandit status and rule rankings.
+
+    Shows the bandit's learned beliefs about which rules are effective
+    for each error class context. Higher mean = bandit believes rule
+    is more effective.
+
+    The bandit uses Beta distributions to model uncertainty:
+    - High variance (wide CI) = uncertain, will explore more
+    - Low variance (narrow CI) = confident, will exploit
+
+    Args:
+        buildlog_dir: Path to buildlog directory
+        context: Specific error class to filter by (optional)
+        top_k: Number of top rules to show per context
+
+    Returns:
+        Dict with:
+            - summary: Total contexts, arms, observations
+            - top_rules: Best rules per context by expected value
+            - all_rules: Full stats if filtering by context
+
+    Example:
+        # See all bandit state
+        buildlog_bandit_status()
+
+        # See state for specific error class
+        buildlog_bandit_status(context="type-errors")
+    """
+    return get_bandit_status(Path(buildlog_dir), context, top_k)
+
+
+# -----------------------------------------------------------------------------
+# Gauntlet Loop MCP Tools
+# -----------------------------------------------------------------------------
+
+
+def buildlog_gauntlet_issues(
+    issues: list[dict],
+    iteration: int = 1,
+    source: str | None = None,
+    buildlog_dir: str = "buildlog",
+) -> dict:
+    """Process gauntlet review issues and determine next action.
+
+    Call this after running a gauntlet review. It categorizes issues by
+    severity, persists learnings, and returns the appropriate next action.
+
+    Args:
+        issues: List of issues from the gauntlet review, each with:
+            {
+                "severity": "critical|major|minor|nitpick",
+                "category": "security|testing|architectural|...",
+                "description": "What's wrong",
+                "rule_learned": "Generalizable rule",
+                "location": "file:line (optional)"
+            }
+        iteration: Current iteration number (for tracking loops)
+        source: Optional source identifier for learnings
+        buildlog_dir: Path to buildlog directory
+
+    Returns:
+        Dict with:
+            - action: What to do next:
+                - "fix_criticals": Criticals remain, auto-fix and loop
+                - "checkpoint_majors": No criticals, majors remain (ask user)
+                - "checkpoint_minors": Only minors remain (ask user)
+                - "clean": No issues remain
+            - criticals: List of critical issues
+            - majors: List of major issues
+            - minors: List of minor/nitpick issues
+            - iteration: Current iteration number
+            - learnings_persisted: Number of learnings saved
+            - message: Human-readable summary
+
+    Example:
+        # After running gauntlet review
+        result = buildlog_gauntlet_issues(
+            issues=[
+                {"severity": "critical", "category": "security", ...},
+                {"severity": "major", "category": "testing", ...},
+            ],
+            iteration=1
+        )
+        # result["action"] tells you what to do next
+    """
+    from buildlog.core import gauntlet_process_issues
+
+    result = gauntlet_process_issues(
+        Path(buildlog_dir),
+        issues=issues,
+        iteration=iteration,
+        source=source,
+    )
+    return asdict(result)
+
+
+def buildlog_gauntlet_accept_risk(
+    remaining_issues: list[dict],
+    create_github_issues: bool = False,
+    repo: str | None = None,
+) -> dict:
+    """Accept risk for remaining issues, optionally creating GitHub issues.
+
+    Call this when the user decides to accept remaining issues as risk
+    (e.g., only minors remain and they want to move on).
+
+    Args:
+        remaining_issues: Issues being accepted as risk
+        create_github_issues: Whether to create GitHub issues for tracking
+        repo: Repository for GitHub issues (uses current repo if None)
+
+    Returns:
+        Dict with:
+            - accepted_issues: Number of issues accepted
+            - github_issues_created: Number of GitHub issues created
+            - github_issue_urls: URLs of created issues
+            - message: Human-readable summary
+            - error: Error message if GitHub issue creation failed
+
+    Example:
+        # User accepts risk with minors, wants GitHub issues
+        result = buildlog_gauntlet_accept_risk(
+            remaining_issues=[...],
+            create_github_issues=True
+        )
+    """
+    from buildlog.core import gauntlet_accept_risk
+
+    result = gauntlet_accept_risk(
+        remaining_issues=remaining_issues,
+        create_github_issues=create_github_issues,
+        repo=repo,
+    )
+    return asdict(result)

buildlog/render/__init__.py

@@ -7,8 +7,12 @@ from typing import TYPE_CHECKING, Literal
 
 from buildlog.render.base import RenderTarget
 from buildlog.render.claude_md import ClaudeMdRenderer
+from buildlog.render.continue_dev import ContinueRenderer
+from buildlog.render.copilot import CopilotRenderer
+from buildlog.render.cursor import CursorRenderer
 from buildlog.render.settings_json import SettingsJsonRenderer
 from buildlog.render.skill import SkillRenderer
+from buildlog.render.windsurf import WindsurfRenderer
 
 if TYPE_CHECKING:
     from typing import Any
@@ -18,8 +22,13 @@ __all__ = [
     "ClaudeMdRenderer",
     "SettingsJsonRenderer",
     "SkillRenderer",
+    "CursorRenderer",
+    "CopilotRenderer",
+    "WindsurfRenderer",
+    "ContinueRenderer",
     "get_renderer",
     "RENDERERS",
+    "RENDER_TARGETS",
 ]
 
 # Registry of available renderers
@@ -28,18 +37,26 @@ RENDERERS: dict[str, type[RenderTarget]] = {
     "claude_md": ClaudeMdRenderer,
     "settings_json": SettingsJsonRenderer,
     "skill": SkillRenderer,
+    "cursor": CursorRenderer,
+    "copilot": CopilotRenderer,
+    "windsurf": WindsurfRenderer,
+    "continue_dev": ContinueRenderer,
 }
 
+# Valid target names (useful for CLI choices and type hints)
+RENDER_TARGETS = list(RENDERERS.keys())
+
 
 def get_renderer(
-    target: Literal["claude_md", "settings_json", "skill"],
+    target: str,
     path: Path | None = None,
     **kwargs: Any,
 ) -> RenderTarget:
     """Get renderer for target.
 
     Args:
-        target: Target format - "claude_md", "settings_json", or "skill".
+        target: Target format - one of: claude_md, settings_json, skill,
+            cursor, copilot, windsurf, continue_dev.
         path: Optional custom path for the target file.
         **kwargs: Additional arguments passed to the renderer constructor.
             Common kwargs (accepted by all renderers):

buildlog/render/claude_md.py

@@ -6,15 +6,24 @@ from datetime import datetime
 from pathlib import Path
 from typing import TYPE_CHECKING
 
-from buildlog.render.tracking import track_promoted
+from buildlog.render.tracking import get_promoted_ids, track_promoted
 from buildlog.skills import _to_imperative
 
 if TYPE_CHECKING:
     from buildlog.skills import Skill
 
+# Markers to identify the buildlog-managed section in CLAUDE.md
+_SECTION_START = "<!-- buildlog:rules:start -->"
+_SECTION_END = "<!-- buildlog:rules:end -->"
+
 
 class ClaudeMdRenderer:
-    """Appends promoted skills to CLAUDE.md."""
+    """Manages a dedicated rules section in CLAUDE.md.
+
+    Uses HTML comment markers to identify the buildlog-managed section.
+    On each promote, the section is replaced (not appended) with ALL
+    currently promoted rules, preventing duplicates.
+    """
 
     def __init__(self, path: Path | None = None, tracking_path: Path | None = None):
         """Initialize renderer.
@@ -31,10 +40,14 @@ class ClaudeMdRenderer:
             self.tracking_path = tracking_path
 
     def render(self, skills: list[Skill]) -> str:
-        """Append skills to CLAUDE.md.
+        """Write skills to CLAUDE.md, replacing the buildlog-managed section.
+
+        On first run, appends a marked section. On subsequent runs, finds
+        and replaces the marked section with updated rules. This prevents
+        the duplicate accumulation that append-only causes.
 
         Args:
-            skills: List of skills to append.
+            skills: List of skills to write.
 
         Returns:
             Confirmation message.
@@ -42,25 +55,71 @@ class ClaudeMdRenderer:
         if not skills:
             return "No skills to promote"
 
+        # Filter out already-promoted skills for tracking purposes,
+        # but we still rebuild the full section from ALL promoted skills
+        already_promoted = get_promoted_ids(self.tracking_path)
+        new_skills = [s for s in skills if s.id not in already_promoted]
+
+        if not new_skills:
+            return f"All {len(skills)} skills already promoted"
+
+        # Track the new skills first so the section includes them
+        track_promoted(new_skills, self.tracking_path)
+
+        # Build the section content from ALL skills being promoted now
+        # (not just new ones — we replace the entire section)
+        all_skills = skills  # All skills passed in this call
+        section = self._build_section(all_skills)
+
+        # Read existing file
+        if self.path.exists():
+            existing = self.path.read_text()
+        else:
+            existing = ""
+
+        # Replace or append the buildlog section
+        if _SECTION_START in existing and _SECTION_END in existing:
+            # Replace existing section
+            start_idx = existing.index(_SECTION_START)
+            end_idx = existing.index(_SECTION_END) + len(_SECTION_END)
+            updated = existing[:start_idx] + section + existing[end_idx:]
+        elif _SECTION_START in existing:
+            # Malformed: start marker but no end. Replace from start to EOF.
+            start_idx = existing.index(_SECTION_START)
+            updated = existing[:start_idx] + section
+        else:
+            # No existing section — append
+            updated = existing.rstrip() + "\n\n" + section + "\n"
+
+        self.path.write_text(updated)
+
+        skipped = len(skills) - len(new_skills)
+        msg = f"Wrote {len(new_skills)} new rules to {self.path} ({len(all_skills)} total in section)"
+        if skipped > 0:
+            msg += f" ({skipped} already tracked)"
+        return msg
+
+    def _build_section(self, skills: list[Skill]) -> str:
+        """Build the marked section content."""
+        category_titles = {
+            "architectural": "Architectural",
+            "workflow": "Workflow",
+            "tool_usage": "Tool Usage",
+            "domain_knowledge": "Domain Knowledge",
+        }
+
         # Group by category
         by_category: dict[str, list[Skill]] = {}
         for skill in skills:
             by_category.setdefault(skill.category, []).append(skill)
 
-        # Build section
         lines = [
+            _SECTION_START,
             "",
-            f"## Learned Rules (auto-generated {datetime.now().strftime('%Y-%m-%d')})",
+            f"## Learned Rules (buildlog, updated {datetime.now().strftime('%Y-%m-%d')})",
             "",
         ]
 
-        category_titles = {
-            "architectural": "Architectural",
-            "workflow": "Workflow",
-            "tool_usage": "Tool Usage",
-            "domain_knowledge": "Domain Knowledge",
-        }
-
         for category, cat_skills in by_category.items():
             title = category_titles.get(category, category.replace("_", " ").title())
             lines.append(f"### {title}")
@@ -70,16 +129,5 @@ class ClaudeMdRenderer:
                 lines.append(f"- {rule}")
             lines.append("")
 
-        content = "\n".join(lines)
-
-        # Append to file
-        if self.path.exists():
-            existing = self.path.read_text()
-            self.path.write_text(existing + content)
-        else:
-            self.path.write_text(content)
-
-        # Track promoted skill IDs using shared utility
-        track_promoted(skills, self.tracking_path)
-
-        return f"Appended {len(skills)} rules to {self.path}"
+        lines.append(_SECTION_END)
+        return "\n".join(lines)

buildlog/render/continue_dev.py

@@ -0,0 +1,102 @@
+"""Render skills to Continue.dev rules format.
+
+Creates .continue/rules/buildlog-rules.md with YAML frontmatter and
+Markdown body containing learned rules.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from buildlog.render.tracking import get_promoted_ids, track_promoted
+from buildlog.skills import _to_imperative
+
+if TYPE_CHECKING:
+    from buildlog.skills import Skill
+
+
+class ContinueRenderer:
+    """Creates .continue/rules/buildlog-rules.md for Continue.dev."""
+
+    def __init__(self, path: Path | None = None, tracking_path: Path | None = None):
+        """Initialize renderer.
+
+        Args:
+            path: Path to rules file.
+                Defaults to .continue/rules/buildlog-rules.md.
+            tracking_path: Path to promoted.json tracking file.
+                Defaults to .buildlog/promoted.json.
+        """
+        self.path = path or Path(".continue/rules/buildlog-rules.md")
+        self.tracking_path = tracking_path or Path(".buildlog/promoted.json")
+
+    def render(self, skills: list[Skill]) -> str:
+        """Render skills to Continue.dev rules file.
+
+        Overwrites the file with all promoted skills.
+
+        Args:
+            skills: List of skills to render.
+
+        Returns:
+            Confirmation message.
+        """
+        if not skills:
+            return "No skills to promote"
+
+        # Filter out already-promoted skills
+        already_promoted = get_promoted_ids(self.tracking_path)
+        new_skills = [s for s in skills if s.id not in already_promoted]
+
+        if not new_skills:
+            return f"All {len(skills)} skills already promoted"
+
+        # Group by category
+        by_category: dict[str, list[Skill]] = {}
+        for skill in new_skills:
+            by_category.setdefault(skill.category, []).append(skill)
+
+        category_titles = {
+            "architectural": "Architectural",
+            "workflow": "Workflow",
+            "tool_usage": "Tool Usage",
+            "domain_knowledge": "Domain Knowledge",
+        }
+
+        # Build content with YAML frontmatter
+        lines = [
+            "---",
+            "name: buildlog-learned-rules",
+            "---",
+            "",
+            "# Learned Rules",
+            "",
+            f"*Auto-generated by buildlog on {datetime.now().strftime('%Y-%m-%d')}*",
+            "",
+        ]
+
+        for category, cat_skills in by_category.items():
+            title = category_titles.get(category, category.replace("_", " ").title())
+            lines.append(f"## {title}")
+            lines.append("")
+            for skill in cat_skills:
+                rule = _to_imperative(skill.rule, skill.confidence)
+                lines.append(f"- {rule}")
+            lines.append("")
+
+        content = "\n".join(lines)
+
+        # Write file
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self.path.write_text(content)
+
+        # Track promoted skill IDs
+        track_promoted(new_skills, self.tracking_path)
+
+        skipped = len(skills) - len(new_skills)
+        msg = f"Wrote {len(new_skills)} rules to {self.path}"
+        if skipped > 0:
+            msg += f" ({skipped} already promoted, skipped)"
+        return msg

buildlog/render/copilot.py

@@ -0,0 +1,100 @@
+"""Render skills to GitHub Copilot instructions format.
+
+Appends a learned rules section to .github/copilot-instructions.md.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from buildlog.render.tracking import get_promoted_ids, track_promoted
+from buildlog.skills import _to_imperative
+
+if TYPE_CHECKING:
+    from buildlog.skills import Skill
+
+
+class CopilotRenderer:
+    """Appends promoted skills to .github/copilot-instructions.md."""
+
+    def __init__(self, path: Path | None = None, tracking_path: Path | None = None):
+        """Initialize renderer.
+
+        Args:
+            path: Path to copilot instructions file.
+                Defaults to .github/copilot-instructions.md.
+            tracking_path: Path to promoted.json tracking file.
+                Defaults to .buildlog/promoted.json.
+        """
+        self.path = path or Path(".github/copilot-instructions.md")
+        self.tracking_path = tracking_path or Path(".buildlog/promoted.json")
+
+    def render(self, skills: list[Skill]) -> str:
+        """Append skills to copilot-instructions.md.
+
+        Filters out already-promoted skills and appends a new section.
+
+        Args:
+            skills: List of skills to render.
+
+        Returns:
+            Confirmation message.
+        """
+        if not skills:
+            return "No skills to promote"
+
+        # Filter out already-promoted skills
+        already_promoted = get_promoted_ids(self.tracking_path)
+        new_skills = [s for s in skills if s.id not in already_promoted]
+
+        if not new_skills:
+            return f"All {len(skills)} skills already promoted"
+
+        # Group by category
+        by_category: dict[str, list[Skill]] = {}
+        for skill in new_skills:
+            by_category.setdefault(skill.category, []).append(skill)
+
+        category_titles = {
+            "architectural": "Architectural",
+            "workflow": "Workflow",
+            "tool_usage": "Tool Usage",
+            "domain_knowledge": "Domain Knowledge",
+        }
+
+        # Build section
+        lines = [
+            "",
+            f"## Learned Rules (buildlog {datetime.now().strftime('%Y-%m-%d')})",
+            "",
+        ]
+
+        for category, cat_skills in by_category.items():
+            title = category_titles.get(category, category.replace("_", " ").title())
+            lines.append(f"### {title}")
+            lines.append("")
+            for skill in cat_skills:
+                rule = _to_imperative(skill.rule, skill.confidence)
+                lines.append(f"- {rule}")
+            lines.append("")
+
+        content = "\n".join(lines)
+
+        # Append to file (create if needed)
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        if self.path.exists():
+            existing = self.path.read_text()
+            self.path.write_text(existing + content)
+        else:
+            self.path.write_text(content)
+
+        # Track promoted skill IDs
+        track_promoted(new_skills, self.tracking_path)
+
+        skipped = len(skills) - len(new_skills)
+        msg = f"Appended {len(new_skills)} rules to {self.path}"
+        if skipped > 0:
+            msg += f" ({skipped} already promoted, skipped)"
+        return msg