buildlog 0.7.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

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

@@ -12,9 +12,18 @@ 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,12 +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.
 
-        Filters out skills that have already been promoted to prevent duplicates.
+        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.
@@ -44,25 +55,52 @@ class ClaudeMdRenderer:
         if not skills:
             return "No skills to promote"
 
-        # Filter out already-promoted skills
+        # 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"
 
-        # Group by category
-        by_category: dict[str, list[Skill]] = {}
-        for skill in new_skills:
-            by_category.setdefault(skill.category, []).append(skill)
+        # Track the new skills first so the section includes them
+        track_promoted(new_skills, self.tracking_path)
 
-        # Build section
-        lines = [
-            "",
-            f"## Learned Rules (auto-generated {datetime.now().strftime('%Y-%m-%d')})",
-            "",
-        ]
+        # 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",
@@ -70,6 +108,18 @@ class ClaudeMdRenderer:
             "domain_knowledge": "Domain Knowledge",
         }
 
+        # Group by category
+        by_category: dict[str, list[Skill]] = {}
+        for skill in skills:
+            by_category.setdefault(skill.category, []).append(skill)
+
+        lines = [
+            _SECTION_START,
+            "",
+            f"## Learned Rules (buildlog, updated {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}")
@@ -79,20 +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(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
+        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

buildlog/render/cursor.py

@@ -0,0 +1,105 @@
+"""Render skills to Cursor rules format.
+
+Creates .cursor/rules/buildlog-rules.mdc 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
+
+if TYPE_CHECKING:
+    from buildlog.skills import Skill
+
+
+class CursorRenderer:
+    """Creates .cursor/rules/buildlog-rules.mdc for Cursor IDE."""
+
+    def __init__(self, path: Path | None = None, tracking_path: Path | None = None):
+        """Initialize renderer.
+
+        Args:
+            path: Path to .mdc rules file. Defaults to .cursor/rules/buildlog-rules.mdc.
+            tracking_path: Path to promoted.json tracking file.
+                Defaults to .buildlog/promoted.json.
+        """
+        self.path = path or Path(".cursor/rules/buildlog-rules.mdc")
+        self.tracking_path = tracking_path or Path(".buildlog/promoted.json")
+
+    def render(self, skills: list[Skill]) -> str:
+        """Render skills to Cursor .mdc rules file.
+
+        Overwrites the file with all promoted skills (not append-only) since
+        Cursor reads the entire file on each invocation.
+
+        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 MDC content with YAML frontmatter
+        lines = [
+            "---",
+            "description: Buildlog-learned rules for code quality",
+            "alwaysApply: true",
+            "---",
+            "",
+            "# 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:
+                conf = skill.confidence
+                freq = skill.frequency
+                lines.append(
+                    f"- **{skill.rule}** (confidence: {conf}, frequency: {freq})"
+                )
+            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/windsurf.py

@@ -0,0 +1,95 @@
+"""Render skills to Windsurf rules format.
+
+Creates .windsurf/rules/buildlog-rules.md with learned rules in
+plain Markdown format.
+"""
+
+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 WindsurfRenderer:
+    """Creates .windsurf/rules/buildlog-rules.md for Windsurf IDE."""
+
+    def __init__(self, path: Path | None = None, tracking_path: Path | None = None):
+        """Initialize renderer.
+
+        Args:
+            path: Path to rules file. Defaults to .windsurf/rules/buildlog-rules.md.
+            tracking_path: Path to promoted.json tracking file.
+                Defaults to .buildlog/promoted.json.
+        """
+        self.path = path or Path(".windsurf/rules/buildlog-rules.md")
+        self.tracking_path = tracking_path or Path(".buildlog/promoted.json")
+
+    def render(self, skills: list[Skill]) -> str:
+        """Render skills to Windsurf 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 Markdown content
+        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)
+
+        # 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/seed_engine/__init__.py

@@ -33,6 +33,7 @@ from buildlog.seed_engine.categorizers import (
 )
 from buildlog.seed_engine.extractors import ManualExtractor, RuleExtractor
 from buildlog.seed_engine.generators import SeedGenerator
+from buildlog.seed_engine.llm_extractor import LLMExtractor
 from buildlog.seed_engine.models import (
     CandidateRule,
     CategorizedRule,
@@ -59,6 +60,7 @@ __all__ = [
     # Extractors
     "RuleExtractor",
     "ManualExtractor",
+    "LLMExtractor",
     # Categorizers
     "Categorizer",
     "TagBasedCategorizer",