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

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/skills.py

@@ -5,11 +5,13 @@ from __future__ import annotations
 __all__ = [
     "Skill",
     "SkillSet",
+    "ConfidenceConfig",  # Re-exported for convenience
     "_deduplicate_insights",
     "_calculate_confidence",
     "_extract_tags",
     "_generate_skill_id",
     "_to_imperative",
+    "_build_confidence_metrics",
     "generate_skills",
     "format_skills",
 ]
@@ -23,6 +25,9 @@ from datetime import date, datetime, timezone
 from pathlib import Path
 from typing import Final, Literal, TypedDict
 
+from buildlog.confidence import ConfidenceConfig, ConfidenceMetrics
+from buildlog.confidence import calculate_confidence as calculate_continuous_confidence
+from buildlog.confidence import get_confidence_tier
 from buildlog.distill import CATEGORIES, PatternDict, distill_all
 from buildlog.embeddings import EmbeddingBackend, get_backend, get_default_backend
 
@@ -39,8 +44,8 @@ OutputFormat = Literal["yaml", "json", "markdown", "rules", "settings"]
 ConfidenceLevel = Literal["high", "medium", "low"]
 
 
-class SkillDict(TypedDict):
-    """Type for skill dictionary representation."""
+class _SkillDictRequired(TypedDict):
+    """Required fields for skill dictionary (base class)."""
 
     id: str
     category: str
@@ -51,6 +56,17 @@ class SkillDict(TypedDict):
     tags: list[str]
 
 
+class SkillDict(_SkillDictRequired, total=False):
+    """Type for skill dictionary representation.
+
+    Inherits required fields from _SkillDictRequired.
+    Optional fields are only present when continuous confidence is enabled.
+    """
+
+    confidence_score: float
+    confidence_tier: str
+
+
 class SkillSetDict(TypedDict):
     """Type for full skill set dictionary."""
 
@@ -66,6 +82,17 @@ class Skill:
 
     Represents a single actionable rule derived from one or more
     similar insights across buildlog entries.
+
+    Attributes:
+        id: Stable identifier for the skill.
+        category: Category (architectural, workflow, etc.).
+        rule: The actionable rule text.
+        frequency: How many times this pattern was seen.
+        confidence: Discrete confidence level (high/medium/low).
+        sources: List of source files where this pattern appeared.
+        tags: Extracted technology/concept tags.
+        confidence_score: Continuous confidence score (0-1), if calculated.
+        confidence_tier: Descriptive tier (speculative/provisional/stable/entrenched).
     """
 
     id: str
@@ -75,10 +102,16 @@ class Skill:
     confidence: ConfidenceLevel
     sources: list[str] = field(default_factory=list)
     tags: list[str] = field(default_factory=list)
+    confidence_score: float | None = None
+    confidence_tier: str | None = None
 
     def to_dict(self) -> SkillDict:
-        """Convert to dictionary for serialization."""
-        return SkillDict(
+        """Convert to dictionary for serialization.
+
+        Only includes optional fields (confidence_score, confidence_tier)
+        when they are set.
+        """
+        result = SkillDict(
             id=self.id,
             category=self.category,
             rule=self.rule,
@@ -87,6 +120,11 @@ class Skill:
             sources=self.sources,
             tags=self.tags,
         )
+        if self.confidence_score is not None:
+            result["confidence_score"] = self.confidence_score
+        if self.confidence_tier is not None:
+            result["confidence_tier"] = self.confidence_tier
+        return result
 
 
 @dataclass
@@ -253,7 +291,7 @@ def _deduplicate_insights(
     patterns: list[PatternDict],
     threshold: float = MIN_SIMILARITY_THRESHOLD,
     backend: EmbeddingBackend | None = None,
-) -> list[tuple[str, int, list[str], date | None]]:
+) -> list[tuple[str, int, list[str], date | None, date | None]]:
     """Deduplicate similar insights into merged rules.
 
     Args:
@@ -262,7 +300,8 @@ def _deduplicate_insights(
         backend: Embedding backend for similarity computation.
 
     Returns:
-        List of (rule, frequency, sources, most_recent_date) tuples.
+        List of (rule, frequency, sources, most_recent_date, earliest_date) tuples.
+        Both dates can be None if no valid dates are found in the patterns.
     """
     if not patterns:
         return []
@@ -289,7 +328,7 @@ def _deduplicate_insights(
             groups.append([pattern])
 
     # Convert groups to deduplicated rules
-    results: list[tuple[str, int, list[str], date | None]] = []
+    results: list[tuple[str, int, list[str], date | None, date | None]] = []
 
     for group in groups:
         # Use the shortest insight as the canonical rule (often cleaner)
@@ -298,7 +337,7 @@ def _deduplicate_insights(
         frequency = len(group)
         sources = sorted(set(p["source"] for p in group))
 
-        # Find most recent date
+        # Find most recent and earliest dates
         dates: list[date] = []
         for p in group:
             try:
@@ -307,16 +346,58 @@ def _deduplicate_insights(
                 pass
 
         most_recent = max(dates) if dates else None
-        results.append((rule, frequency, sources, most_recent))
+        earliest = min(dates) if dates else None
+        results.append((rule, frequency, sources, most_recent, earliest))
 
     return results
 
 
+def _build_confidence_metrics(
+    frequency: int,
+    most_recent: date | None,
+    earliest: date | None,
+) -> ConfidenceMetrics:
+    """Build ConfidenceMetrics from deduplication results.
+
+    Args:
+        frequency: Number of times the pattern was seen.
+        most_recent: Most recent occurrence date.
+        earliest: Earliest occurrence date.
+
+    Returns:
+        ConfidenceMetrics for continuous confidence calculation.
+    """
+    # Use midnight UTC for date-based timestamps
+    now = datetime.now(timezone.utc)
+
+    if most_recent is not None:
+        last_reinforced = datetime(
+            most_recent.year, most_recent.month, most_recent.day, tzinfo=timezone.utc
+        )
+    else:
+        last_reinforced = now
+
+    if earliest is not None:
+        first_seen = datetime(
+            earliest.year, earliest.month, earliest.day, tzinfo=timezone.utc
+        )
+    else:
+        first_seen = last_reinforced
+
+    return ConfidenceMetrics(
+        reinforcement_count=frequency,
+        last_reinforced=last_reinforced,
+        contradiction_count=0,  # Deferred: no contradiction tracking yet
+        first_seen=first_seen,
+    )
+
+
 def generate_skills(
     buildlog_dir: Path,
     min_frequency: int = 1,
     since_date: date | None = None,
     embedding_backend: str | None = None,
+    confidence_config: ConfidenceConfig | None = None,
 ) -> SkillSet:
     """Generate skills from buildlog patterns.
 
@@ -326,6 +407,9 @@ def generate_skills(
         since_date: Only include patterns from this date onward.
         embedding_backend: Name of embedding backend for deduplication.
             Options: "token" (default), "sentence-transformers", "openai".
+        confidence_config: Configuration for continuous confidence scoring.
+            If provided, skills will include confidence_score and confidence_tier.
+            If None, only discrete confidence levels (high/medium/low) are computed.
 
     Returns:
         SkillSet with generated skills.
@@ -341,6 +425,9 @@ def generate_skills(
     )
     logger.info("Using embedding backend: %s", backend.name)
 
+    # Capture reference time for confidence calculations
+    t_now = datetime.now(timezone.utc) if confidence_config else None
+
     skills_by_category: dict[str, list[Skill]] = {}
 
     for category in CATEGORIES:
@@ -348,10 +435,22 @@ def generate_skills(
         deduplicated = _deduplicate_insights(patterns, backend=backend)
 
         skills: list[Skill] = []
-        for rule, frequency, sources, most_recent in deduplicated:
+        for rule, frequency, sources, most_recent, earliest in deduplicated:
             if frequency < min_frequency:
                 continue
 
+            # Calculate continuous confidence if config provided
+            confidence_score: float | None = None
+            confidence_tier: str | None = None
+            if confidence_config is not None and t_now is not None:
+                metrics = _build_confidence_metrics(frequency, most_recent, earliest)
+                confidence_score = calculate_continuous_confidence(
+                    metrics, confidence_config, t_now
+                )
+                confidence_tier = get_confidence_tier(
+                    confidence_score, confidence_config
+                ).value
+
             skill = Skill(
                 id=_generate_skill_id(category, rule),
                 category=category,
@@ -360,6 +459,8 @@ def generate_skills(
                 confidence=_calculate_confidence(frequency, most_recent),
                 sources=sources,
                 tags=_extract_tags(rule),
+                confidence_score=confidence_score,
+                confidence_tier=confidence_tier,
             )
             skills.append(skill)
 

{buildlog-0.2.0.data → buildlog-0.3.0.data}/data/share/buildlog/post_gen.py

@@ -1,13 +1,13 @@
 #!/usr/bin/env python3
 """Post-generation script to update CLAUDE.md with buildlog instructions."""
 
-import os
 from pathlib import Path
 
-CLAUDE_MD_SECTION = '''
+CLAUDE_MD_SECTION = """
 ## Build Journal
 
-After completing significant work (features, debugging sessions, deployments, 2+ hour focused sessions), write a build journal entry.
+After completing significant work (features, debugging sessions, deployments,
+2+ hour focused sessions), write a build journal entry.
 
 **Location:** `buildlog/YYYY-MM-DD-{slug}.md`
 **Template:** `buildlog/_TEMPLATE.md`
@@ -15,18 +15,21 @@ After completing significant work (features, debugging sessions, deployments, 2+
 ### Required Sections
 1. **The Goal** - What we built and why
 2. **What We Built** - Architecture diagram, components table
-3. **The Journey** - Chronological INCLUDING mistakes, wrong turns, actual error messages
+3. **The Journey** - Chronological INCLUDING mistakes, wrong turns, actual errors
 4. **Test Results** - Actual commands run, actual outputs received
 5. **Code Samples** - Key snippets with context (not full files)
 6. **AI Experience Reflection** - Meta-commentary on the collaboration
-7. **Improvements** - Actionable learnings: architectural, workflow, tool usage, domain knowledge
+7. **Improvements** - Actionable learnings: architectural, workflow, tool usage
 
-The **Improvements** section is critical - capture concrete insights like "Should have defined the API contract before implementing the client" not vague observations like "Should have planned better."
+The **Improvements** section is critical - capture concrete insights like
+"Should have defined the API contract before implementing the client"
+not vague observations like "Should have planned better."
 
 **Quality bar:** Publishable as a $500+ Envato Tuts+/Manning tutorial.
 
 After significant work, ask: "Should I write a build journal entry for this?"
-'''
+"""
+
 
 def main():
     claude_md = Path("CLAUDE.md")
@@ -47,5 +50,6 @@ def main():
 
     print("Added Build Journal section to CLAUDE.md")
 
+
 if __name__ == "__main__":
     main()

{buildlog-0.2.0.dist-info → buildlog-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: buildlog
-Version: 0.2.0
+Version: 0.3.0
 Summary: Engineering notebook for AI-assisted development
 Project-URL: Homepage, https://github.com/Peleke/buildlog-template
 Project-URL: Repository, https://github.com/Peleke/buildlog-template
@@ -33,6 +33,7 @@ Requires-Dist: black>=24.0.0; extra == 'dev'
 Requires-Dist: flake8>=7.0.0; extra == 'dev'
 Requires-Dist: isort>=5.13.0; extra == 'dev'
 Requires-Dist: mypy>=1.8.0; extra == 'dev'
+Requires-Dist: pre-commit>=3.6.0; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
 Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
 Requires-Dist: pytest>=7.0.0; extra == 'dev'
@@ -59,7 +60,7 @@ Description-Content-Type: text/markdown
 
 **Capture your work as publishable content. Include the fuckups.**
 
-<img src="assets/hero3.png" alt="Chaos to Order - buildlog transforms messy development sessions into structured knowledge" width="800"/>
+<img src="assets/hero-notebook.png" alt="buildlog - Engineering Notebook for AI-Assisted Development" width="800"/>
 
 [Quick Start](#-quick-start) · [The Pipeline](#-the-pipeline) · [Commands](#-commands) · [Philosophy](#-philosophy)
 

{buildlog-0.2.0.dist-info → buildlog-0.3.0.dist-info}/RECORD

@@ -1,8 +1,9 @@
 buildlog/__init__.py,sha256=FrgjyZhC19YyB40rOXHJWTA4xKWx2Yn2heIhVraaZ7A,90
 buildlog/cli.py,sha256=cmg77_RVJx8mdtStApS1KXxBUUB8Id6psHZjtHo33iE,14350
+buildlog/confidence.py,sha256=EOkPxIH1_y7k6B3Hl7Wn0iR2qK_lumvOyyyqUdafXVY,9382
 buildlog/distill.py,sha256=fqXW_YyBFIFhwIWhnR-TQ7U65gypqG-mcAzNBr-qaag,11262
 buildlog/embeddings.py,sha256=vPydWjJVkYp172zFou-lJ737qsu6vRMQAMs143RGIpA,12364
-buildlog/skills.py,sha256=gu26MuIBgo-Jm6GQcVvbXHmV6MNp-HX3h7WC5buiyJ8,20686
+buildlog/skills.py,sha256=ZR3cTn19WCCB2DjDRN2jyJOhXs7FazDkulRXYAZnquU,24757
 buildlog/stats.py,sha256=2WdHdmzUNGobtWngmm9nA_UmqM7DQeAnZL8_rLQN8aw,13256
 buildlog/core/__init__.py,sha256=07N1gRiPQQTBtLp9rsEErh39sgXWZSlEKWBn708SoQk,412
 buildlog/core/operations.py,sha256=o01z2Sy0fgiBK6Z90Lkg6ACoqihH3-HC-hkPBSdj9mA,10656
@@ -15,15 +16,15 @@ buildlog/render/claude_md.py,sha256=Z_E6MbJyVM_hJSoB4KL2rvbt5UEQHekTpJijj106lsI,
 buildlog/render/settings_json.py,sha256=4DS5OWksPrFCa7MIgWIu0t4rxYmItpMdGfTqMX3aMNs,2495
 buildlog/render/skill.py,sha256=_7umIS1Ms1oQ2_PopYueFjX41nMq1p28yJp6DhXFdgU,5981
 buildlog/render/tracking.py,sha256=6O0RIU-1gjVG-_S5dmXLz6RCMsQoHOR2u5___UpqXEo,1294
-buildlog-0.2.0.data/data/share/buildlog/copier.yml,sha256=A-1JKV59kOe0BQosGUBgRCg7iQozP_qyA3zfoHwpBKY,927
-buildlog-0.2.0.data/data/share/buildlog/post_gen.py,sha256=ffVG-1MMXbffKT8OMNvaQmyVDcBjwD8qTYpCaoyyZAQ,1778
-buildlog-0.2.0.data/data/share/buildlog/template/buildlog/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-buildlog-0.2.0.data/data/share/buildlog/template/buildlog/2026-01-01-example.md,sha256=7x9sKmydfmfKyNz9hV7MtYnQJuBwbxNanbPOcpQDDZQ,7040
-buildlog-0.2.0.data/data/share/buildlog/template/buildlog/BUILDLOG_SYSTEM.md,sha256=osclytWwl5jUiTgSpuT4cT3h3oPvCkZ5GPCnFuJZNcY,3802
-buildlog-0.2.0.data/data/share/buildlog/template/buildlog/_TEMPLATE.md,sha256=CUvxgcx1-9XT_EdQ8e_vnuPq_h-u1uhXJgForJU2Pso,2932
-buildlog-0.2.0.data/data/share/buildlog/template/buildlog/assets/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-buildlog-0.2.0.dist-info/METADATA,sha256=pRmXAYYlZhVCwjRXdbTQdtmf8Bz2KijyBGHn65hPYKQ,24161
-buildlog-0.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-buildlog-0.2.0.dist-info/entry_points.txt,sha256=BMFclPOomp_sgaa0OqBg6LfqCMlqzjZV88ww5TrPPoo,87
-buildlog-0.2.0.dist-info/licenses/LICENSE,sha256=fAgt-akug9nAwIj6M-SIf8u3ck-T7pJTwfmy9vWYASk,1074
-buildlog-0.2.0.dist-info/RECORD,,
+buildlog-0.3.0.data/data/share/buildlog/copier.yml,sha256=A-1JKV59kOe0BQosGUBgRCg7iQozP_qyA3zfoHwpBKY,927
+buildlog-0.3.0.data/data/share/buildlog/post_gen.py,sha256=XFlo40LuPpAsBhIRRRtHqvU3_5POss4L401hp35ijhw,1744
+buildlog-0.3.0.data/data/share/buildlog/template/buildlog/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+buildlog-0.3.0.data/data/share/buildlog/template/buildlog/2026-01-01-example.md,sha256=7x9sKmydfmfKyNz9hV7MtYnQJuBwbxNanbPOcpQDDZQ,7040
+buildlog-0.3.0.data/data/share/buildlog/template/buildlog/BUILDLOG_SYSTEM.md,sha256=osclytWwl5jUiTgSpuT4cT3h3oPvCkZ5GPCnFuJZNcY,3802
+buildlog-0.3.0.data/data/share/buildlog/template/buildlog/_TEMPLATE.md,sha256=CUvxgcx1-9XT_EdQ8e_vnuPq_h-u1uhXJgForJU2Pso,2932
+buildlog-0.3.0.data/data/share/buildlog/template/buildlog/assets/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+buildlog-0.3.0.dist-info/METADATA,sha256=v2RWbkwAEgpZtshu6jiqr5X9cV713Ml_SGhhVywmLLA,24188
+buildlog-0.3.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+buildlog-0.3.0.dist-info/entry_points.txt,sha256=BMFclPOomp_sgaa0OqBg6LfqCMlqzjZV88ww5TrPPoo,87
+buildlog-0.3.0.dist-info/licenses/LICENSE,sha256=fAgt-akug9nAwIj6M-SIf8u3ck-T7pJTwfmy9vWYASk,1074
+buildlog-0.3.0.dist-info/RECORD,,