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

buildlog/cli.py

@@ -8,7 +8,8 @@ from pathlib import Path
 
 import click
 
-from buildlog.core import get_rewards, log_reward
+from buildlog.core import diff as core_diff
+from buildlog.core import get_rewards, log_reward, promote, reject, status
 from buildlog.distill import CATEGORIES, distill_all, format_output
 from buildlog.skills import format_skills, generate_skills
 from buildlog.stats import calculate_stats, format_dashboard, format_json
@@ -49,11 +50,18 @@ def main():
 
 @main.command()
 @click.option("--no-claude-md", is_flag=True, help="Don't update CLAUDE.md")
-def init(no_claude_md: bool):
+@click.option(
+    "--defaults",
+    is_flag=True,
+    help="Use default values for all prompts (non-interactive)",
+)
+def init(no_claude_md: bool, defaults: bool):
     """Initialize buildlog in the current directory.
 
     Sets up the buildlog/ directory with templates and optionally
     adds instructions to CLAUDE.md.
+
+    Use --defaults for non-interactive environments (CI, scripts, agents).
     """
     buildlog_dir = Path("buildlog")
 
@@ -66,46 +74,186 @@ def init(no_claude_md: bool):
     if template_dir:
         # Use local template
         click.echo("Initializing buildlog from local template...")
-        try:
-            subprocess.run(
-                [
-                    sys.executable,
-                    "-m",
-                    "copier",
-                    "copy",
-                    "--trust",
-                    *(["--data", "update_claude_md=false"] if no_claude_md else []),
-                    str(template_dir),
-                    ".",
-                ],
-                check=True,
-            )
-        except subprocess.CalledProcessError:
-            click.echo("Failed to initialize buildlog.", err=True)
-            raise SystemExit(1)
+        subprocess.run(
+            [
+                sys.executable,
+                "-m",
+                "copier",
+                "copy",
+                "--trust",
+                *(["--defaults"] if defaults else []),
+                *(["--data", "update_claude_md=false"] if no_claude_md else []),
+                str(template_dir),
+                ".",
+            ],
+        )
     else:
         # Fall back to GitHub
         click.echo("Initializing buildlog from GitHub...")
-        try:
-            subprocess.run(
-                [
-                    sys.executable,
-                    "-m",
-                    "copier",
-                    "copy",
-                    "--trust",
-                    *(["--data", "update_claude_md=false"] if no_claude_md else []),
-                    "gh:Peleke/buildlog-template",
-                    ".",
-                ],
-                check=True,
-            )
-        except subprocess.CalledProcessError:
-            click.echo("Failed to initialize buildlog.", err=True)
-            raise SystemExit(1)
+        subprocess.run(
+            [
+                sys.executable,
+                "-m",
+                "copier",
+                "copy",
+                "--trust",
+                *(["--defaults"] if defaults else []),
+                *(["--data", "update_claude_md=false"] if no_claude_md else []),
+                "gh:Peleke/buildlog-template",
+                ".",
+            ],
+        )
+
+    # Verify the buildlog directory was actually created
+    if not buildlog_dir.exists():
+        click.echo("Failed to initialize buildlog.", err=True)
+        raise SystemExit(1)
+
+    # Update CLAUDE.md if it exists and user didn't opt out
+    if not no_claude_md:
+        claude_md = Path("CLAUDE.md")
+        if claude_md.exists():
+            content = claude_md.read_text()
+            if "## Build Journal" not in content:
+                section = (
+                    "\n## Build Journal\n\n"
+                    "After completing significant work (features, debugging sessions, "
+                    "deployments,\n"
+                    "2+ hour focused sessions), write a build journal entry.\n\n"
+                    "**Location:** `buildlog/YYYY-MM-DD-{slug}.md`\n"
+                    "**Template:** `buildlog/_TEMPLATE.md`\n"
+                )
+                with open(claude_md, "a") as f:
+                    f.write(section)
+                click.echo("Added Build Journal section to CLAUDE.md")
 
     click.echo("\n✓ buildlog initialized!")
-    click.echo("\nNext: buildlog new my-feature")
+    click.echo()
+    click.echo("How it works:")
+    click.echo("  1. Write entries     buildlog new my-feature (or --quick)")
+    click.echo("  2. Extract rules     buildlog skills")
+    click.echo("  3. Promote to agent  buildlog promote <id> --target cursor")
+    click.echo("  4. Measure learning  buildlog overview")
+    click.echo()
+    click.echo(
+        "Targets: claude_md, cursor, copilot, windsurf, continue_dev, settings_json, skill"
+    )
+    click.echo()
+    click.echo("Start now: buildlog new my-first-task --quick")
+
+
+@main.command()
+@click.option("--json", "output_json", is_flag=True, help="Output as JSON")
+def overview(output_json: bool):
+    """Show the full state of your buildlog at a glance.
+
+    Entries, skills, promoted rules, experiments — everything in one view.
+
+    Examples:
+
+        buildlog overview
+        buildlog overview --json
+    """
+    import json as json_module
+
+    buildlog_dir = Path("buildlog")
+
+    if not buildlog_dir.exists():
+        click.echo("No buildlog/ directory found. Run 'buildlog init' first.", err=True)
+        raise SystemExit(1)
+
+    # Count entries
+    entries = sorted(buildlog_dir.glob("20??-??-??-*.md"))
+
+    # Try to get skills
+    try:
+        skill_set = generate_skills(buildlog_dir)
+        total_skills = skill_set.total_skills
+        by_confidence = {"high": 0, "medium": 0, "low": 0}
+        for cat_skills in skill_set.skills.values():
+            for s in cat_skills:
+                by_confidence[s.confidence] += 1
+    except Exception:
+        total_skills = 0
+        by_confidence = {"high": 0, "medium": 0, "low": 0}
+
+    # Promoted/rejected counts
+    promoted_path = buildlog_dir / ".buildlog" / "promoted.json"
+    rejected_path = buildlog_dir / ".buildlog" / "rejected.json"
+    promoted_count = 0
+    rejected_count = 0
+    if promoted_path.exists():
+        try:
+            data = json_module.loads(promoted_path.read_text())
+            promoted_count = len(data.get("skill_ids", []))
+        except (json_module.JSONDecodeError, OSError):
+            pass
+    if rejected_path.exists():
+        try:
+            data = json_module.loads(rejected_path.read_text())
+            rejected_count = len(data.get("skill_ids", []))
+        except (json_module.JSONDecodeError, OSError):
+            pass
+
+    # Active session?
+    active_session_path = buildlog_dir / ".buildlog" / "active_session.json"
+    active_session = None
+    if active_session_path.exists():
+        try:
+            active_session = json_module.loads(active_session_path.read_text())
+        except (json_module.JSONDecodeError, OSError):
+            pass
+
+    # Render targets with files
+    from buildlog.render import RENDERERS
+
+    result = {
+        "entries": len(entries),
+        "skills": {
+            "total": total_skills,
+            "by_confidence": by_confidence,
+            "promoted": promoted_count,
+            "rejected": rejected_count,
+            "pending": total_skills - promoted_count - rejected_count,
+        },
+        "active_session": active_session.get("id") if active_session else None,
+        "render_targets": list(RENDERERS.keys()),
+    }
+
+    if output_json:
+        click.echo(json_module.dumps(result, indent=2))
+    else:
+        click.echo("buildlog overview")
+        click.echo("=" * 40)
+        click.echo(f"  Entries:     {len(entries)}")
+        click.echo(f"  Skills:      {total_skills}")
+        if total_skills > 0:
+            conf_parts = [f"{k}={v}" for k, v in by_confidence.items() if v > 0]
+            click.echo(f"    confidence: {', '.join(conf_parts)}")
+        click.echo(f"  Promoted:    {promoted_count}")
+        click.echo(f"  Rejected:    {rejected_count}")
+        pending = total_skills - promoted_count - rejected_count
+        if pending > 0:
+            click.echo(f"  Pending:     {pending}")
+        if active_session:
+            click.echo(f"  Session:     {active_session.get('id', '?')} (active)")
+        click.echo()
+
+        if len(entries) == 0:
+            click.echo("Get started:")
+            click.echo("  buildlog new my-first-task        # Full template")
+            click.echo("  buildlog new my-first-task --quick # Short template")
+        elif total_skills == 0:
+            click.echo("Next steps:")
+            click.echo(
+                "  buildlog skills                    # Extract rules from entries"
+            )
+        elif promoted_count == 0:
+            click.echo("Next steps:")
+            click.echo("  buildlog status                    # See extracted skills")
+            click.echo("  buildlog promote <id> --target cursor  # Push to your agent")
+        else:
+            click.echo("Targets: " + ", ".join(RENDERERS.keys()))
 
 
 @main.command()
@@ -113,7 +261,12 @@ def init(no_claude_md: bool):
 @click.option(
     "--date", "-d", "entry_date", default=None, help="Date for entry (YYYY-MM-DD)"
 )
-def new(slug: str, entry_date: str | None):
+@click.option(
+    "--quick",
+    is_flag=True,
+    help="Use the short template (good for small tasks)",
+)
+def new(slug: str, entry_date: str | None, quick: bool):
     """Create a new buildlog entry.
 
     SLUG is a short identifier for the entry (e.g., 'auth-api', 'bugfix-login').
@@ -121,10 +274,16 @@ def new(slug: str, entry_date: str | None):
     Examples:
 
         buildlog new auth-api
+        buildlog new bugfix-login --quick
         buildlog new runpod-deploy --date 2026-01-15
     """
     buildlog_dir = Path("buildlog")
-    template_file = buildlog_dir / "_TEMPLATE.md"
+    template_name = "_TEMPLATE_QUICK.md" if quick else "_TEMPLATE.md"
+    template_file = buildlog_dir / template_name
+
+    # Fall back to full template if quick template doesn't exist
+    if quick and not template_file.exists():
+        template_file = buildlog_dir / "_TEMPLATE.md"
 
     if not buildlog_dir.exists():
         click.echo("No buildlog/ directory found. Run 'buildlog init' first.", err=True)
@@ -139,11 +298,11 @@ def new(slug: str, entry_date: str | None):
     # Determine date
     if entry_date:
         try:
-            # Validate date format
-            year, month, day = entry_date.split("-")
-            date_str = f"{int(year):04d}-{int(month):02d}-{int(day):02d}"
+            # Validate date format AND range (month 1-12, day 1-31)
+            parsed = datetime.strptime(entry_date, "%Y-%m-%d").date()
+            date_str = parsed.isoformat()
         except ValueError:
-            click.echo("Invalid date format. Use YYYY-MM-DD.", err=True)
+            click.echo("Invalid date. Use YYYY-MM-DD with valid values.", err=True)
             raise SystemExit(1)
     else:
         date_str = date.today().isoformat()
@@ -172,6 +331,161 @@ def new(slug: str, entry_date: str | None):
     click.echo(f"\nOpen it: $EDITOR {entry_path}")
 
 
+@main.command(
+    context_settings={"ignore_unknown_options": True, "allow_extra_args": True}
+)
+@click.option(
+    "--slug",
+    "-s",
+    default=None,
+    help="Entry slug (default: derived from branch name)",
+)
+@click.option(
+    "--entry",
+    "-e",
+    type=click.Path(),
+    default=None,
+    help="Explicit entry file to append to",
+)
+@click.option(
+    "--no-entry",
+    is_flag=True,
+    help="Skip buildlog entry update (just run git commit)",
+)
+@click.pass_context
+def commit(ctx, slug: str | None, entry: str | None, no_entry: bool):
+    """Commit code and update the buildlog entry in one step.
+
+    Wraps `git commit` and appends commit context to today's buildlog
+    entry. If no entry exists for today, creates one automatically.
+
+    All unknown options/arguments are passed through to git commit.
+
+    Examples:
+
+        buildlog commit -m "feat: add LLM extractor"
+        buildlog commit --slug llm-extractor -m "feat: add LLM extractor"
+        buildlog commit --no-entry -m "chore: formatting"
+    """
+    buildlog_dir = Path("buildlog")
+
+    # Build git commit command — extra args are passed through from Click context
+    git_cmd = ["git", "commit", *ctx.args]
+
+    # Run git commit first
+    result = subprocess.run(git_cmd, capture_output=True, text=True)
+    sys.stdout.write(result.stdout)
+    sys.stderr.write(result.stderr)
+
+    if result.returncode != 0:
+        raise SystemExit(result.returncode)
+
+    if no_entry or not buildlog_dir.exists():
+        return
+
+    # Get commit info from what we just committed
+    try:
+        commit_hash = subprocess.run(
+            ["git", "rev-parse", "--short", "HEAD"],
+            capture_output=True,
+            text=True,
+            check=True,
+        ).stdout.strip()
+        commit_msg = subprocess.run(
+            ["git", "log", "-1", "--format=%s"],
+            capture_output=True,
+            text=True,
+            check=True,
+        ).stdout.strip()
+        # diff-tree needs special handling for root commit
+        diff_result = subprocess.run(
+            ["git", "diff-tree", "--no-commit-id", "--name-only", "-r", "HEAD"],
+            capture_output=True,
+            text=True,
+        )
+        if diff_result.returncode == 0 and diff_result.stdout.strip():
+            files_changed = diff_result.stdout.strip()
+        else:
+            # Root commit fallback
+            files_changed = subprocess.run(
+                ["git", "diff", "--name-only", "--cached", "HEAD~1"],
+                capture_output=True,
+                text=True,
+            ).stdout.strip()
+            if not files_changed:
+                # Truly initial commit — list all tracked files
+                files_changed = subprocess.run(
+                    ["git", "ls-tree", "--name-only", "-r", "HEAD"],
+                    capture_output=True,
+                    text=True,
+                ).stdout.strip()
+    except subprocess.CalledProcessError:
+        click.echo("Warning: could not read commit info", err=True)
+        return
+
+    # Resolve entry file
+    today = date.today().isoformat()
+    entry_path = _resolve_entry_path(buildlog_dir, today, slug, entry)
+
+    # Append commit block
+    commit_block = f"\n### `{commit_hash}` — {commit_msg}\n\n"
+    if files_changed:
+        file_list = files_changed.split("\n")
+        commit_block += "Files:\n"
+        for f in file_list[:20]:  # cap at 20 to avoid noise
+            commit_block += f"- `{f}`\n"
+        if len(file_list) > 20:
+            commit_block += f"- ...and {len(file_list) - 20} more\n"
+    commit_block += "\n"
+
+    # Ensure commits section exists, append to it
+    if entry_path.exists():
+        content = entry_path.read_text()
+        if "## Commits" not in content:
+            content = content.rstrip() + "\n\n## Commits\n"
+        content += commit_block
+    else:
+        # Auto-create minimal entry
+        content = f"# {today}\n\n## Commits\n{commit_block}"
+
+    entry_path.write_text(content)
+    click.echo(f"buildlog: updated {entry_path}")
+
+
+def _resolve_entry_path(
+    buildlog_dir: Path, today: str, slug: str | None, explicit: str | None
+) -> Path:
+    """Find or create the entry path for today."""
+    if explicit:
+        return Path(explicit)
+
+    # Check for existing entry with today's date
+    existing = list(buildlog_dir.glob(f"{today}-*.md"))
+    if existing:
+        return existing[0]
+
+    # Derive slug from branch name if not provided
+    if slug is None:
+        try:
+            branch = subprocess.run(
+                ["git", "branch", "--show-current"],
+                capture_output=True,
+                text=True,
+                check=True,
+            ).stdout.strip()
+            # Clean branch name into slug
+            slug = branch.split("/")[-1]  # strip prefix like feat/
+            slug = slug.lower().replace("_", "-")
+            slug = "".join(c for c in slug if c.isalnum() or c == "-")
+        except subprocess.CalledProcessError:
+            slug = "session"
+
+    if not slug:
+        slug = "session"
+
+    return buildlog_dir / f"{today}-{slug}.md"
+
+
 @main.command("list")
 def list_entries():
     """List all buildlog entries."""
@@ -257,7 +571,18 @@ def update():
     type=click.Choice(CATEGORIES),
     help="Filter to a specific category",
 )
-def distill(output: str | None, fmt: str, since: datetime | None, category: str | None):
+@click.option(
+    "--llm",
+    is_flag=True,
+    help="Use LLM-backed extraction (Ollama/Anthropic, falls back to regex)",
+)
+def distill(
+    output: str | None,
+    fmt: str,
+    since: datetime | None,
+    category: str | None,
+    llm: bool,
+):
     """Extract patterns from all buildlog entries.
 
     Parses the Improvements section of each buildlog entry and aggregates
@@ -282,7 +607,9 @@ def distill(output: str | None, fmt: str, since: datetime | None, category: str
 
     # Run distillation
     try:
-        result = distill_all(buildlog_dir, since=since_date, category_filter=category)
+        result = distill_all(
+            buildlog_dir, since=since_date, category_filter=category, llm=llm
+        )
     except Exception as e:
         click.echo(f"Failed to distill entries: {e}", err=True)
         raise SystemExit(1)
@@ -383,12 +710,18 @@ def stats(output_json: bool, detailed: bool, since_date: str | None):
     default=None,
     help="Embedding backend for semantic deduplication",
 )
+@click.option(
+    "--llm",
+    is_flag=True,
+    help="Use LLM for extraction, canonical selection, and scoring (Ollama/Anthropic)",
+)
 def skills(
     output: str | None,
     fmt: str,
     min_frequency: int,
     since: datetime | None,
     embeddings: str | None,
+    llm: bool = False,
 ):
     """Generate agent-consumable skills from buildlog patterns.
 
@@ -424,6 +757,7 @@ def skills(
             min_frequency=min_frequency,
             since_date=since_date,
             embedding_backend=embeddings,
+            llm=llm,
         )
     except ImportError as e:
         click.echo(f"Missing dependency: {e}", err=True)
@@ -584,6 +918,219 @@ def rewards(limit: int | None, output_json: bool):
             click.echo("Log your first with: buildlog reward accepted")
 
 
+# -----------------------------------------------------------------------------
+# Skill Management Commands (status, promote, reject, diff)
+# -----------------------------------------------------------------------------
+
+
+@main.command()
+@click.option(
+    "--min-confidence",
+    type=click.Choice(["low", "medium", "high"]),
+    default="low",
+    help="Minimum confidence level to include",
+)
+@click.option("--json", "output_json", is_flag=True, help="Output as JSON")
+def status_cmd(min_confidence: str, output_json: bool):
+    """Show extracted skills by category and confidence.
+
+    Displays all skills extracted from buildlog entries, grouped by category,
+    with confidence levels and promotion status.
+
+    Examples:
+
+        buildlog status
+        buildlog status --min-confidence medium
+        buildlog status --json
+    """
+    import json as json_module
+    from dataclasses import asdict
+
+    buildlog_dir = Path("buildlog")
+
+    if not buildlog_dir.exists():
+        click.echo("No buildlog/ directory found. Run 'buildlog init' first.", err=True)
+        raise SystemExit(1)
+
+    result = status(buildlog_dir, min_confidence=min_confidence)  # type: ignore[arg-type]
+
+    if result.error:
+        click.echo(f"Error: {result.error}", err=True)
+        raise SystemExit(1)
+
+    if output_json:
+        click.echo(json_module.dumps(asdict(result), indent=2))
+    else:
+        click.echo(
+            f"Skills: {result.total_skills} total from {result.total_entries} entries"
+        )
+        conf_str = ", ".join(
+            f"{k}={v}" for k, v in result.by_confidence.items() if v > 0
+        )
+        click.echo(f"  By confidence: {conf_str}")
+        click.echo()
+        for category, skills in result.skills.items():
+            if not skills:
+                continue
+            click.echo(f"  {category} ({len(skills)})")
+            for s in skills:
+                conf = s.get("confidence", "?")
+                click.echo(f"    [{conf}] {s['id']}: {s['rule'][:70]}")
+        if result.promotable_ids:
+            click.echo(f"\nPromotable: {', '.join(result.promotable_ids)}")
+
+
+# Register with the name "status" (avoiding collision with Python builtin)
+status_cmd.name = "status"
+
+
+@main.command()
+@click.argument("skill_ids", nargs=-1, required=True)
+@click.option(
+    "--target",
+    type=click.Choice(
+        [
+            "claude_md",
+            "settings_json",
+            "skill",
+            "cursor",
+            "copilot",
+            "windsurf",
+            "continue_dev",
+        ]
+    ),
+    default="claude_md",
+    help="Where to write promoted rules",
+)
+@click.option(
+    "--target-path", type=click.Path(), help="Custom path for the target file"
+)
+@click.option("--json", "output_json", is_flag=True, help="Output as JSON")
+def promote_cmd(
+    skill_ids: tuple[str, ...], target: str, target_path: str | None, output_json: bool
+):
+    """Promote skills to agent rules.
+
+    Surface high-confidence skills to your agent via CLAUDE.md, settings.json,
+    or Agent Skills.
+
+    Examples:
+
+        buildlog promote arch-b0fcb62a1e
+        buildlog promote arch-123 wf-456 --target skill
+        buildlog promote arch-123 --target settings_json --target-path .claude/settings.json
+    """
+    import json as json_module
+    from dataclasses import asdict
+
+    buildlog_dir = Path("buildlog")
+
+    if not buildlog_dir.exists():
+        click.echo("No buildlog/ directory found. Run 'buildlog init' first.", err=True)
+        raise SystemExit(1)
+
+    result = promote(
+        buildlog_dir,
+        skill_ids=list(skill_ids),
+        target=target,  # type: ignore[arg-type]
+        target_path=Path(target_path) if target_path else None,
+    )
+
+    if result.error:
+        click.echo(f"Error: {result.error}", err=True)
+        raise SystemExit(1)
+
+    if output_json:
+        click.echo(json_module.dumps(asdict(result), indent=2))
+    else:
+        click.echo(f"✓ {result.message}")
+        if result.not_found_ids:
+            click.echo(f"  Not found: {', '.join(result.not_found_ids)}")
+
+
+promote_cmd.name = "promote"
+
+
+@main.command("reject")
+@click.argument("skill_ids", nargs=-1, required=True)
+@click.option("--json", "output_json", is_flag=True, help="Output as JSON")
+def reject_cmd(skill_ids: tuple[str, ...], output_json: bool):
+    """Mark skills as rejected (false positives).
+
+    Rejected skills won't be suggested for promotion again.
+
+    Examples:
+
+        buildlog reject arch-b0fcb62a1e
+        buildlog reject dk-123 wf-456
+    """
+    import json as json_module
+    from dataclasses import asdict
+
+    buildlog_dir = Path("buildlog")
+
+    if not buildlog_dir.exists():
+        click.echo("No buildlog/ directory found. Run 'buildlog init' first.", err=True)
+        raise SystemExit(1)
+
+    result = reject(buildlog_dir, skill_ids=list(skill_ids))
+
+    if result.error:
+        click.echo(f"Error: {result.error}", err=True)
+        raise SystemExit(1)
+
+    if output_json:
+        click.echo(json_module.dumps(asdict(result), indent=2))
+    else:
+        click.echo(f"✓ Rejected {len(result.rejected_ids)} skills")
+        click.echo(f"  Total rejected: {result.total_rejected}")
+
+
+@main.command("diff")
+@click.option("--json", "output_json", is_flag=True, help="Output as JSON")
+def diff_cmd(output_json: bool):
+    """Show skills pending review (not yet promoted or rejected).
+
+    Useful for seeing what's new since the last time you reviewed skills.
+
+    Examples:
+
+        buildlog diff
+        buildlog diff --json
+    """
+    import json as json_module
+    from dataclasses import asdict
+
+    buildlog_dir = Path("buildlog")
+
+    if not buildlog_dir.exists():
+        click.echo("No buildlog/ directory found. Run 'buildlog init' first.", err=True)
+        raise SystemExit(1)
+
+    result = core_diff(buildlog_dir)
+
+    if result.error:
+        click.echo(f"Error: {result.error}", err=True)
+        raise SystemExit(1)
+
+    if output_json:
+        click.echo(json_module.dumps(asdict(result), indent=2))
+    else:
+        click.echo(
+            f"Pending: {result.total_pending} | "
+            f"Promoted: {result.already_promoted} | "
+            f"Rejected: {result.already_rejected}"
+        )
+        click.echo()
+        for category, skills in result.pending.items():
+            if not skills:
+                continue
+            click.echo(f"  {category} ({len(skills)})")
+            for s in skills:
+                conf = s.get("confidence", "?")
+                click.echo(f"    [{conf}] {s['id']}: {s['rule'][:70]}")
+
+
 # -----------------------------------------------------------------------------
 # Experiment Commands (Session Tracking for Issue #21)
 # -----------------------------------------------------------------------------
@@ -708,7 +1255,7 @@ def experiment_end(
 
 @experiment.command("log-mistake")
 @click.option(
-    "--class",
+    "--error-class",
     "error_class",
     required=True,
     help="Error class (e.g., 'missing_test', 'validation_boundary')",
@@ -739,8 +1286,8 @@ def experiment_log_mistake(
 
     Examples:
 
-        buildlog experiment log-mistake --class missing_test -d "Forgot tests"
-        buildlog experiment log-mistake --class validation -d "No max length" -r val-123
+        buildlog experiment log-mistake --error-class missing_test -d "Forgot tests"
+        buildlog experiment log-mistake --error-class validation -d "No max length" -r val-123
     """
     import json as json_module
     from dataclasses import asdict
@@ -885,6 +1432,7 @@ PERSONAS = {
     "security_karen": "OWASP Top 10 security review",
     "test_terrorist": "Comprehensive testing coverage audit",
     "ruthless_reviewer": "Code quality and functional principles",
+    "bragi": "Detect and flag LLM-ish prose patterns in markdown",
 }
 
 
@@ -1264,6 +1812,69 @@ def gauntlet_learn(issues_file: str, source: str | None, output_json: bool):
         click.echo(f"  Total processed: {result.total_issues_processed}")
 
 
+@gauntlet.command("generate")
+@click.argument("source_text", type=click.Path(exists=True))
+@click.option("--persona", "-p", required=True, help="Persona name for the seed file")
+@click.option(
+    "--output-dir",
+    "-o",
+    type=click.Path(),
+    default=".buildlog/seeds",
+    help="Output directory for seed YAML",
+)
+@click.option("--dry-run", is_flag=True, help="Preview without writing")
+def gauntlet_generate(source_text: str, persona: str, output_dir: str, dry_run: bool):
+    """Generate seed rules from source text using LLM extraction.
+
+    Runs the seed engine pipeline with LLMExtractor to produce
+    a YAML seed file from arbitrary source content.
+
+    Examples:
+
+        buildlog gauntlet generate docs/security.md --persona security_karen
+        buildlog gauntlet generate notes.txt -p test_terrorist --dry-run
+    """
+    import json as json_module
+
+    from buildlog.llm import get_llm_backend
+    from buildlog.seed_engine import Pipeline, Source, SourceType
+
+    backend = get_llm_backend()
+    if backend is None:
+        click.echo(
+            "No LLM backend available. Install ollama or set ANTHROPIC_API_KEY.",
+            err=True,
+        )
+        raise SystemExit(1)
+
+    content = Path(source_text).read_text()
+    source = Source(
+        name=Path(source_text).stem,
+        url=f"file://{Path(source_text).resolve()}",
+        source_type=SourceType.REFERENCE_DOC,
+        domain=persona.split("_")[0] if "_" in persona else "general",
+        description=content,
+    )
+
+    pipeline = Pipeline.with_llm(
+        persona=persona,
+        backend=backend,
+        source_content={source.url: content},
+    )
+
+    if dry_run:
+        preview = pipeline.dry_run([source])
+        click.echo(json_module.dumps(preview, indent=2))
+        return
+
+    out = Path(output_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    result = pipeline.run([source], output_dir=out)
+    click.echo(f"Generated {result.rule_count} rules for {persona}")
+    if result.output_path:
+        click.echo(f"Seed file: {result.output_path}")
+
+
 @gauntlet.command("loop")
 @click.argument("target", type=click.Path(exists=True))
 @click.option(