buildlog 0.1.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

buildlog/cli.py

@@ -9,7 +9,7 @@ from pathlib import Path
 import click
 
 from buildlog.distill import CATEGORIES, distill_all, format_output
-from buildlog.skills import generate_skills, format_skills
+from buildlog.skills import format_skills, generate_skills
 from buildlog.stats import calculate_stats, format_dashboard, format_json
 
 
@@ -27,6 +27,7 @@ def get_template_dir() -> Path | None:
 
     # 2. Check installed location (site-packages/../share/buildlog)
     import sysconfig
+
     data_dir = Path(sysconfig.get_path("data")) / "share" / "buildlog"
     if (data_dir / "copier.yml").exists():
         return data_dir
@@ -67,13 +68,16 @@ def init(no_claude_md: bool):
         try:
             subprocess.run(
                 [
-                    sys.executable, "-m", "copier", "copy",
+                    sys.executable,
+                    "-m",
+                    "copier",
+                    "copy",
                     "--trust",
                     *(["--data", "update_claude_md=false"] if no_claude_md else []),
                     str(template_dir),
-                    "."
+                    ".",
                 ],
-                check=True
+                check=True,
             )
         except subprocess.CalledProcessError:
             click.echo("Failed to initialize buildlog.", err=True)
@@ -84,13 +88,16 @@ def init(no_claude_md: bool):
         try:
             subprocess.run(
                 [
-                    sys.executable, "-m", "copier", "copy",
+                    sys.executable,
+                    "-m",
+                    "copier",
+                    "copy",
                     "--trust",
                     *(["--data", "update_claude_md=false"] if no_claude_md else []),
                     "gh:Peleke/buildlog-template",
-                    "."
+                    ".",
                 ],
-                check=True
+                check=True,
             )
         except subprocess.CalledProcessError:
             click.echo("Failed to initialize buildlog.", err=True)
@@ -102,7 +109,9 @@ def init(no_claude_md: bool):
 
 @main.command()
 @click.argument("slug")
-@click.option("--date", "-d", "entry_date", default=None, help="Date for entry (YYYY-MM-DD)")
+@click.option(
+    "--date", "-d", "entry_date", default=None, help="Date for entry (YYYY-MM-DD)"
+)
 def new(slug: str, entry_date: str | None):
     """Create a new buildlog entry.
 
@@ -121,7 +130,9 @@ def new(slug: str, entry_date: str | None):
         raise SystemExit(1)
 
     if not template_file.exists():
-        click.echo("No _TEMPLATE.md found in buildlog/. Run 'buildlog init' first.", err=True)
+        click.echo(
+            "No _TEMPLATE.md found in buildlog/. Run 'buildlog init' first.", err=True
+        )
         raise SystemExit(1)
 
     # Determine date
@@ -170,8 +181,7 @@ def list():
         raise SystemExit(1)
 
     entries = sorted(
-        buildlog_dir.glob("20??-??-??-*.md"),
-        reverse=True  # Most recent first
+        buildlog_dir.glob("20??-??-??-*.md"), reverse=True  # Most recent first
     )
 
     if not entries:
@@ -183,7 +193,9 @@ def list():
         # Extract title from first line if possible
         try:
             first_line = entry.read_text().split("\n")[0]
-            title = first_line.replace("# Build Journal: ", "").replace("# ", "").strip()
+            title = (
+                first_line.replace("# Build Journal: ", "").replace("# ", "").strip()
+            )
             if title == "[TITLE]":
                 title = "(untitled)"
         except Exception:
@@ -202,21 +214,23 @@ def update():
         click.echo("Updating from local template...")
         try:
             subprocess.run(
-                [sys.executable, "-m", "copier", "update", "--trust"],
-                check=True
+                [sys.executable, "-m", "copier", "update", "--trust"], check=True
             )
         except subprocess.CalledProcessError:
-            click.echo("Failed to update. Try running 'copier update' directly.", err=True)
+            click.echo(
+                "Failed to update. Try running 'copier update' directly.", err=True
+            )
             raise SystemExit(1)
     else:
         click.echo("Updating from GitHub...")
         try:
             subprocess.run(
-                [sys.executable, "-m", "copier", "update", "--trust"],
-                check=True
+                [sys.executable, "-m", "copier", "update", "--trust"], check=True
             )
         except subprocess.CalledProcessError:
-            click.echo("Failed to update. Try running 'copier update' directly.", err=True)
+            click.echo(
+                "Failed to update. Try running 'copier update' directly.", err=True
+            )
             raise SystemExit(1)
 
     click.echo("\n✓ buildlog updated!")
@@ -273,7 +287,7 @@ def distill(output: str | None, fmt: str, since: datetime | None, category: str
 
     # Format output
     try:
-        formatted = format_output(result, fmt)
+        formatted = format_output(result, fmt)  # type: ignore[arg-type]
     except ImportError as e:
         click.echo(str(e), err=True)
         raise SystemExit(1)
@@ -283,7 +297,9 @@ def distill(output: str | None, fmt: str, since: datetime | None, category: str
         output_path = Path(output)
         try:
             output_path.write_text(formatted, encoding="utf-8")
-            click.echo(f"Wrote {result.statistics.get('total_patterns', 0)} patterns to {output_path}")
+            click.echo(
+                f"Wrote {result.statistics.get('total_patterns', 0)} patterns to {output_path}"
+            )
         except Exception as e:
             click.echo(f"Failed to write output: {e}", err=True)
             raise SystemExit(1)
@@ -293,8 +309,15 @@ def distill(output: str | None, fmt: str, since: datetime | None, category: str
 
 @main.command()
 @click.option("--json", "output_json", is_flag=True, help="Output as JSON")
-@click.option("--detailed", is_flag=True, help="Show detailed breakdown including top sources")
-@click.option("--since", "since_date", default=None, help="Only include entries since date (YYYY-MM-DD)")
+@click.option(
+    "--detailed", is_flag=True, help="Show detailed breakdown including top sources"
+)
+@click.option(
+    "--since",
+    "since_date",
+    default=None,
+    help="Only include entries since date (YYYY-MM-DD)",
+)
 def stats(output_json: bool, detailed: bool, since_date: str | None):
     """Show buildlog statistics and analytics.
 
@@ -409,7 +432,7 @@ def skills(
 
     # Format output
     try:
-        formatted = format_skills(skill_set, fmt)
+        formatted = format_skills(skill_set, fmt)  # type: ignore[arg-type]
     except ImportError as e:
         click.echo(str(e), err=True)
         raise SystemExit(1)

buildlog/confidence.py

@@ -0,0 +1,311 @@
+"""Confidence scoring for rules and patterns.
+
+Confidence represents structural inertia - how hard it would be for the system
+to stop believing a rule. It reflects accumulated mass from reinforcement,
+not objective correctness.
+
+A rule gains mass when:
+- It shows up again (frequency)
+- It shows up recently (recency)
+- It survives contradictions
+
+A rule loses mass when:
+- It's unused (time decay)
+- It's contradicted
+- It's contextually bypassed
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from enum import Enum
+from typing import TypedDict
+
+__all__ = [
+    "ConfidenceTier",
+    "ConfidenceConfig",
+    "ConfidenceMetrics",
+    "ConfidenceMetricsDict",
+    "calculate_confidence",
+    "get_confidence_tier",
+    "merge_confidence_metrics",
+    "add_contradiction",
+]
+
+
+class ConfidenceTier(str, Enum):
+    """Descriptive tiers for rule confidence.
+
+    These are purely descriptive labels for human interpretation.
+    No logic gates or hard thresholds are enforced by the system.
+    """
+
+    SPECULATIVE = "speculative"  # Low mass, recently introduced
+    PROVISIONAL = "provisional"  # Growing mass, some reinforcement
+    STABLE = "stable"  # Consistent reinforcement, moderate mass
+    ENTRENCHED = "entrenched"  # High mass, sustained over time
+
+
+@dataclass(frozen=True)
+class ConfidenceConfig:
+    """Configuration parameters for confidence calculation.
+
+    Attributes:
+        tau: Half-life for recency decay (in days). Smaller = twitchier system.
+        k: Saturation constant for frequency. Larger = slower saturation.
+        lambda_: Decay constant for contradiction penalty.
+        tier_thresholds: Confidence score thresholds for each tier.
+    """
+
+    tau: float = 30.0  # 30-day half-life by default
+    k: float = 5.0  # Frequency saturation constant
+    lambda_: float = 2.0  # Contradiction decay constant
+    tier_thresholds: tuple[float, float, float] = (0.2, 0.4, 0.7)
+
+    def __post_init__(self) -> None:
+        if self.tau <= 0:
+            raise ValueError("tau must be positive")
+        if self.k <= 0:
+            raise ValueError("k must be positive")
+        if self.lambda_ <= 0:
+            raise ValueError("lambda_ must be positive")
+        low, mid, high = self.tier_thresholds
+        if not (0 <= low <= mid <= high <= 1):
+            raise ValueError(
+                "tier_thresholds must be monotonically increasing in [0, 1]"
+            )
+
+
+class ConfidenceMetricsDict(TypedDict):
+    """Serializable form of confidence metrics."""
+
+    reinforcement_count: int
+    last_reinforced: str  # ISO format timestamp
+    contradiction_count: int
+    first_seen: str  # ISO format timestamp
+
+
+@dataclass
+class ConfidenceMetrics:
+    """Tracked metrics for confidence calculation.
+
+    These are the raw inputs that feed into the confidence formula.
+    """
+
+    reinforcement_count: int = 1
+    last_reinforced: datetime = field(
+        default_factory=lambda: datetime.now(timezone.utc)
+    )
+    contradiction_count: int = 0
+    first_seen: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+
+    def __post_init__(self) -> None:
+        if self.reinforcement_count < 0:
+            raise ValueError("reinforcement_count must be non-negative")
+        if self.contradiction_count < 0:
+            raise ValueError("contradiction_count must be non-negative")
+
+    def to_dict(self) -> ConfidenceMetricsDict:
+        """Convert to serializable dictionary."""
+        return {
+            "reinforcement_count": self.reinforcement_count,
+            "last_reinforced": self.last_reinforced.isoformat(),
+            "contradiction_count": self.contradiction_count,
+            "first_seen": self.first_seen.isoformat(),
+        }
+
+    @classmethod
+    def from_dict(cls, data: ConfidenceMetricsDict) -> ConfidenceMetrics:
+        """Reconstruct from serialized dictionary.
+
+        Note: Timezone-naive datetimes are assumed to be UTC.
+        """
+        last_reinforced = datetime.fromisoformat(data["last_reinforced"])
+        first_seen = datetime.fromisoformat(data["first_seen"])
+
+        # Ensure timezone awareness (assume UTC for naive datetimes)
+        if last_reinforced.tzinfo is None:
+            last_reinforced = last_reinforced.replace(tzinfo=timezone.utc)
+        if first_seen.tzinfo is None:
+            first_seen = first_seen.replace(tzinfo=timezone.utc)
+
+        return cls(
+            reinforcement_count=data["reinforcement_count"],
+            last_reinforced=last_reinforced,
+            contradiction_count=data["contradiction_count"],
+            first_seen=first_seen,
+        )
+
+
+def calculate_frequency_weight(n: int, k: float) -> float:
+    """Calculate frequency weight with saturation.
+
+    Uses bounded exponential: 1 - exp(-n/k)
+    This makes early reinforcement matter more than late spam.
+
+    Args:
+        n: Reinforcement count
+        k: Saturation constant (larger = slower saturation)
+
+    Returns:
+        Weight in range (0, 1), approaching 1 as n grows
+    """
+    return 1.0 - math.exp(-n / k)
+
+
+def calculate_recency_weight(
+    t_last: datetime,
+    t_now: datetime,
+    tau: float,
+) -> float:
+    """Calculate recency weight with exponential decay.
+
+    Uses: exp(-(t_now - t_last) / tau)
+
+    Args:
+        t_last: Timestamp of last reinforcement
+        t_now: Current timestamp
+        tau: Half-life in days
+
+    Returns:
+        Weight in range (0, 1], decaying over time.
+        If t_last is in the future, clamps to 1.0.
+    """
+    days_elapsed = (t_now - t_last).total_seconds() / (24 * 60 * 60)
+    if days_elapsed < 0:
+        return 1.0  # Future timestamps treated as "just now"
+    return math.exp(-days_elapsed / tau)
+
+
+def calculate_contradiction_penalty(c: int, lambda_: float) -> float:
+    """Calculate contradiction penalty (drag).
+
+    Rules don't die from contradictions, they get heavy and sink.
+    Uses: exp(-c / lambda)
+
+    Args:
+        c: Contradiction count
+        lambda_: Decay constant
+
+    Returns:
+        Penalty multiplier in range (0, 1]
+    """
+    return math.exp(-c / lambda_)
+
+
+def calculate_confidence(
+    metrics: ConfidenceMetrics,
+    config: ConfidenceConfig | None = None,
+    t_now: datetime | None = None,
+) -> float:
+    """Calculate confidence score for a rule.
+
+    Confidence = frequency_weight * recency_weight * contradiction_penalty
+
+    This gives a scalar that:
+    - Rises fast early
+    - Decays naturally over time
+    - Never quite hits zero
+    - Never explodes to infinity
+
+    Args:
+        metrics: Tracked metrics for the rule
+        config: Scoring configuration (uses defaults if None)
+        t_now: Current time (uses now if None)
+
+    Returns:
+        Confidence score in range (0, 1)
+    """
+    if config is None:
+        config = ConfidenceConfig()
+    if t_now is None:
+        t_now = datetime.now(timezone.utc)
+
+    freq = calculate_frequency_weight(metrics.reinforcement_count, config.k)
+    recency = calculate_recency_weight(metrics.last_reinforced, t_now, config.tau)
+    penalty = calculate_contradiction_penalty(
+        metrics.contradiction_count, config.lambda_
+    )
+
+    return freq * recency * penalty
+
+
+def get_confidence_tier(
+    score: float,
+    config: ConfidenceConfig | None = None,
+) -> ConfidenceTier:
+    """Map confidence score to descriptive tier.
+
+    Args:
+        score: Confidence score in range [0, 1]
+        config: Configuration with tier thresholds
+
+    Returns:
+        Descriptive tier label
+
+    Raises:
+        ValueError: If score is outside [0, 1] range
+    """
+    if not (0.0 <= score <= 1.0):
+        raise ValueError(f"score must be in [0, 1], got {score}")
+
+    if config is None:
+        config = ConfidenceConfig()
+
+    low, mid, high = config.tier_thresholds
+
+    if score < low:
+        return ConfidenceTier.SPECULATIVE
+    elif score < mid:
+        return ConfidenceTier.PROVISIONAL
+    elif score < high:
+        return ConfidenceTier.STABLE
+    else:
+        return ConfidenceTier.ENTRENCHED
+
+
+def merge_confidence_metrics(
+    existing: ConfidenceMetrics,
+    new_occurrence: datetime | None = None,
+) -> ConfidenceMetrics:
+    """Merge a new occurrence into existing metrics.
+
+    This is called when a rule is reinforced (seen again).
+
+    Args:
+        existing: Current metrics for the rule
+        new_occurrence: Timestamp of new occurrence (uses now if None)
+
+    Returns:
+        Updated metrics with incremented count and updated timestamp
+    """
+    if new_occurrence is None:
+        new_occurrence = datetime.now(timezone.utc)
+
+    return ConfidenceMetrics(
+        reinforcement_count=existing.reinforcement_count + 1,
+        last_reinforced=new_occurrence,
+        contradiction_count=existing.contradiction_count,
+        first_seen=existing.first_seen,
+    )
+
+
+def add_contradiction(metrics: ConfidenceMetrics) -> ConfidenceMetrics:
+    """Record a contradiction against a rule.
+
+    Contradictions add drag but don't invalidate rules.
+
+    Args:
+        metrics: Current metrics for the rule
+
+    Returns:
+        Updated metrics with incremented contradiction count
+    """
+    return ConfidenceMetrics(
+        reinforcement_count=metrics.reinforcement_count,
+        last_reinforced=metrics.last_reinforced,
+        contradiction_count=metrics.contradiction_count + 1,
+        first_seen=metrics.first_seen,
+    )

buildlog/core/operations.py

@@ -59,7 +59,7 @@ class PromoteResult:
     """IDs of skills that were promoted."""
 
     target: str
-    """Target format (claude_md or settings_json)."""
+    """Target format (claude_md, settings_json, or skill)."""
 
     rules_added: int
     """Number of rules added."""
@@ -192,7 +192,7 @@ def status(
     confidence_order = {"low": 0, "medium": 1, "high": 2}
     min_level = confidence_order[min_confidence]
 
-    filtered: dict[str, list[dict]] = {}
+    filtered: dict[str, list[dict]] = {}  # type: ignore[type-arg]
     by_confidence = {"high": 0, "medium": 0, "low": 0}
     promotable: list[str] = []
 
@@ -215,7 +215,7 @@ def status(
                 category_skills.append(skill.to_dict())
 
         if category_skills:
-            filtered[category] = category_skills
+            filtered[category] = category_skills  # type: ignore[assignment]
 
     # Calculate actual total (sum of by_confidence, which excludes rejected)
     actual_total = sum(by_confidence.values())
@@ -232,7 +232,7 @@ def status(
 def promote(
     buildlog_dir: Path,
     skill_ids: list[str],
-    target: Literal["claude_md", "settings_json"] = "claude_md",
+    target: Literal["claude_md", "settings_json", "skill"] = "claude_md",
     target_path: Path | None = None,
 ) -> PromoteResult:
     """Promote skills to agent rules.
@@ -240,7 +240,7 @@ def promote(
     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: Where to write rules ("claude_md", "settings_json", or "skill").
         target_path: Optional custom path for the target file.
 
     Returns:
@@ -277,13 +277,8 @@ def promote(
     # 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)
+    # Get renderer using the registry pattern
+    renderer = get_renderer(target, path=target_path, tracking_path=tracking_path)
 
     message = renderer.render(found_skills)
 
@@ -372,16 +367,17 @@ def diff(
     promoted_ids = _load_json_set(_get_promoted_path(buildlog_dir), "skill_ids")
 
     # Find unpromoted, unrejected skills
-    pending: dict[str, list[dict]] = {}
+    pending: dict[str, list[dict]] = {}  # type: ignore[type-arg]
     total_pending = 0
 
     for category, skill_list in skill_set.skills.items():
         pending_skills = [
-            s.to_dict() for s in skill_list
+            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
+            pending[category] = pending_skills  # type: ignore[assignment]
             total_pending += len(pending_skills)
 
     return DiffResult(

buildlog/distill.py

@@ -17,7 +17,7 @@ import logging
 import re
 from collections.abc import Iterator
 from dataclasses import dataclass, field
-from datetime import UTC, date, datetime
+from datetime import date, datetime, timezone
 from pathlib import Path
 from typing import Final, Literal, TypedDict
 
@@ -81,7 +81,7 @@ class DistillResult:
     extracted_at: str
     entry_count: int
     patterns: dict[str, list[PatternDict]] = field(default_factory=dict)
-    statistics: StatisticsDict = field(default_factory=dict)
+    statistics: StatisticsDict = field(default_factory=dict)  # type: ignore[assignment]
 
     def to_dict(self) -> DistillResultDict:
         """Convert to dictionary for JSON/YAML serialization."""
@@ -333,7 +333,7 @@ def distill_all(
     statistics = _compute_statistics(patterns, by_month)
 
     return DistillResult(
-        extracted_at=datetime.now(UTC).isoformat().replace("+00:00", "Z"),
+        extracted_at=datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"),
         entry_count=entry_count,
         patterns=patterns,
         statistics=statistics,