Hiddenden/openrabbit
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects 1 Releases Wiki Activity

Feature Request: Automatic Label Creator #6

New Issue
Closed
opened 2025-12-28 17:47:06 +00:00 by Latte · 0 comments
Latte commented 2025-12-28 17:47:06 +00:00
Owner
Copy Link

Feature Request: Automatic Label Creator (@codebot setup-labels)

Summary

Add a @codebot setup-labels command that automatically creates all required repository labels for the AI review system, eliminating a major setup pain point and ensuring auto-labeling works immediately.

What problem does this solve?

Current Problem:
Setting up OpenRabbit has two scenarios:

Scenario 1: Fresh Repository (No Labels)

  • Requires manually creating 10+ labels
  • Time-consuming setup (15-20 minutes)
  • Error-prone manual work

Scenario 2: Existing Label Schema (Like Your Case)

  • Repository already has labels (Kind/Bug, Priority - High, Status - Blocked, etc.)
  • OpenRabbit expects different label names (type: bug, priority: high, etc.)
  • Mapping Problem: Bot can't find existing labels because names don't match
  • Result: Silent auto-labeling failures

Your Current Labels (18 total):

  • Kind/* (Bug, Feature, Enhancement, Documentation, Security, Testing)
  • Priority - * (Critical, High, Medium, Low)
  • Status - * (Abandoned, Blocked, Need More Info)
  • Reviewed - * (Confirmed, Duplicate, Invalid, Won't Fix)
  • Compat/Breaking

User Pain:

  • Silent Failures: If labels don't exist OR names don't match, auto-labeling fails
  • Name Mismatches: Existing "Kind/Bug" ≠ expected "type: bug"
  • Duplicate Labels: Don't want both "Kind/Bug" AND "type: bug"
  • Inconsistent: Different repositories use different naming conventions
  • Manual Mapping: Having to edit config.yml for each repository

Support Burden:

  • "Why aren't labels being applied to my issues?"
  • "I already have labels, why create new ones?"
  • "How do I use my existing label schema?"

User story / Use case

As a repository administrator setting up OpenRabbit,
I want to automatically create all required labels with one command,
so that I don't have to manually create 10+ labels and the bot works immediately.

Example scenario:

  1. Admin adds OpenRabbit workflows to repository
  2. Types @codebot setup-labels in any issue
  3. Bot analyzes existing labels, creates missing ones
  4. Auto-labeling now works for all future issues/PRs
  5. Setup complete in 30 seconds instead of 20 minutes

Proposed solution

Implementation

Add a @codebot setup-labels command that:

  1. Detects existing label schema - Scans repository labels to identify naming patterns (Kind/*, Priority -, type:, etc.)

  2. Offers two modes:

    • Map Mode (Default): Maps existing labels to OpenRabbit schema
    • Create Mode: Creates new OpenRabbit-style labels

  3. Map Mode Flow:

    • Analyzes existing labels (e.g., "Kind/Bug", "Priority - High")
    • Detects pattern (prefix-based: Kind/, Priority -, etc.)
    • Creates mapping in .ai-review.yml repository config
    • No new labels created, uses existing ones

  4. Create Mode Flow:

    • Creates OpenRabbit default labels (type:, priority:, ai-*)
    • Useful for fresh repositories

Example Output: Map Mode (Your Case)

@username

**🔍 Label Schema Detected:**

Found 18 existing labels with pattern: `Prefix/Name` and `Prefix - Name`

**Detected Categories:**
- **Kind/** (6 labels): Bug, Feature, Enhancement, Documentation, Security, Testing
- **Priority -** (4 labels): Critical, High, Medium, Low  
- **Status -** (3 labels): Abandoned, Blocked, Need More Info
- **Reviewed -** (4 labels): Confirmed, Duplicate, Invalid, Won't Fix
- **Compat/** (1 label): Breaking

**📋 Proposed Mapping:**

| OpenRabbit Expected | Your Existing Label | Status |
|---------------------|---------------------|--------|
| `type: bug` | `Kind/Bug` | ✅ Map |
| `type: feature` | `Kind/Feature` | ✅ Map |
| `type: question` | *(missing)* | ⚠️ Create |
| `type: documentation` | `Kind/Documentation` | ✅ Map |
| `priority: high` | `Priority - High` | ✅ Map |
| `priority: medium` | `Priority - Medium` | ✅ Map |
| `priority: low` | `Priority - Low` | ✅ Map |
| `ai-approved` | *(missing)* | ⚠️ Create |
| `ai-changes-required` | *(missing)* | ⚠️ Create |
| `ai-reviewed` | `Reviewed - Confirmed` | ✅ Map (suggested) |

**✅ Setup Complete!**

Created `.ai-review.yml` with label mappings:
```yaml
labels:
  type:
    bug: "Kind/Bug"
    feature: "Kind/Feature"
    documentation: "Kind/Documentation"
  priority:
    high: "Priority - High"
    medium: "Priority - Medium"
    low: "Priority - Low"

🔧 Missing Labels to Create (3):

  • Kind/Question - for question-type issues
  • Status - AI Approved - for AI-approved PRs
  • Status - AI Changes Required - for PRs needing changes

Run @codebot setup-labels --create-missing to create these labels.


### Example Output

```markdown
@username

**Label Setup Analysis:**

**✅ Existing Labels (3):**
- `type: bug` (already exists)
- `priority: high` (already exists)
- `ai-reviewed` (already exists)

**🔧 Missing Labels (7):**
Creating the following labels...

✅ Created `priority: medium` (#fbca04)
✅ Created `priority: low` (#28a745)
✅ Created `type: feature` (#1d76db)
✅ Created `type: question` (#cc317c)
✅ Created `type: documentation` (#0075ca)
✅ Created `ai-approved` (#28a745)
✅ Created `ai-changes-required` (#d73a4a)

**✅ Setup Complete!**
All 10 required labels are now configured. Auto-labeling is ready to use.

**Next Steps:**
- Create a new issue and type `@codebot triage` to test auto-labeling
- Open a PR to test AI review with security scanning

Example: Dry-Run Mode

@codebot setup-labels --dry-run

Response:

**Label Setup Preview (Dry Run):**

**Would create 7 labels:**
- `priority: medium` (#fbca04)
- `priority: low` (#28a745)
- `type: feature` (#1d76db)
- `type: question` (#cc317c)
- `type: documentation` (#0075ca)
- `ai-approved` (#28a745)
- `ai-changes-required` (#d73a4a)

**Would skip 3 labels (already exist):**
- `type: bug`
- `priority: high`
- `ai-reviewed`

Run `@codebot setup-labels` without `--dry-run` to create labels.

Files to Modify

1. tools/ai-review/config.yml

Add label schema detection patterns and default mappings:

labels:
  # Default OpenRabbit schema (for fresh repos)
  type:
    bug: 
      name: "type: bug"
      color: "d73a4a"  # Red
      aliases: ["Kind/Bug", "bug", "Type: Bug"]  # Auto-detect alternatives
    feature: 
      name: "type: feature"
      color: "1d76db"  # Blue
      aliases: ["Kind/Feature", "feature", "enhancement", "Kind/Enhancement"]
    question: 
      name: "type: question"
      color: "cc317c"  # Purple
      aliases: ["Kind/Question", "question"]
    docs: 
      name: "type: documentation"
      color: "0075ca"  # Light Blue
      aliases: ["Kind/Documentation", "documentation", "docs"]
    
  priority:
    critical:
      name: "priority: critical"
      color: "b60205"  # Dark Red
      aliases: ["Priority - Critical", "P0", "critical"]
    high: 
      name: "priority: high"
      color: "d73a4a"  # Red
      aliases: ["Priority - High", "P1", "high"]
    medium: 
      name: "priority: medium"
      color: "fbca04"  # Yellow
      aliases: ["Priority - Medium", "P2", "medium"]
    low: 
      name: "priority: low"
      color: "28a745"  # Green
      aliases: ["Priority - Low", "P3", "low"]
      
  status:
    ai_approved: 
      name: "ai-approved"
      color: "28a745"  # Green
      aliases: ["Status - Approved", "approved"]
    ai_changes_required: 
      name: "ai-changes-required"
      color: "d73a4a"  # Red
      aliases: ["Status - Changes Required", "changes-required"]
    ai_reviewed: 
      name: "ai-reviewed"
      color: "1d76db"  # Blue
      aliases: ["Reviewed - Confirmed", "reviewed"]

# Label schema detection patterns
label_patterns:
  # Detect existing naming conventions
  prefix_slash: "^(Kind|Type|Category)/(.+)$"      # Kind/Bug, Type/Feature
  prefix_dash: "^(Priority|Status|Reviewed) - (.+)$"  # Priority - High
  colon: "^(type|priority|status): (.+)$"          # type: bug

Generated .ai-review.yml (per-repository override):

# Auto-generated by @codebot setup-labels
labels:
  type:
    bug: "Kind/Bug"                    # Maps to existing label
    feature: "Kind/Feature"
    question: "Kind/Question"          # Will be created
    docs: "Kind/Documentation"
  priority:
    critical: "Priority - Critical"
    high: "Priority - High"
    medium: "Priority - Medium"
    low: "Priority - Low"
  status:
    ai_approved: "Status - AI Approved"        # Will be created
    ai_changes_required: "Status - AI Changes Required"  # Will be created
    ai_reviewed: "Reviewed - Confirmed"

2. tools/ai-review/clients/gitea_client.py

Add label creation method:

def create_label(self, owner: str, repo: str, name: str, color: str, 
                 description: str = "") -> dict:
    """Create a new label in the repository.
    
    Args:
        owner: Repository owner
        repo: Repository name
        name: Label name (e.g., "priority: high")
        color: Hex color without # (e.g., "d73a4a")
        description: Optional label description
    
    Returns:
        Created label data
    """
    url = f"{self.api_url}/repos/{owner}/{repo}/labels"
    
    payload = {
        "name": name,
        "color": color,
        "description": description
    }
    
    response = self._request("POST", url, json=payload)
    return response.json()

def get_repo_labels(self, owner: str, repo: str) -> list[dict]:
    """Get all labels in the repository.
    
    Returns:
        List of label dicts with 'name', 'color', 'id' fields
    """
    url = f"{self.api_url}/repos/{owner}/{repo}/labels"
    response = self._request("GET", url)
    return response.json()

3. tools/ai-review/agents/issue_agent.py

Add setup-labels command handler with schema detection:

def _command_setup_labels(self, owner: str, repo: str, issue_index: int, 
                          mode: str = "auto") -> str:
    """Create labels or map existing labels.
    
    Args:
        owner: Repository owner
        repo: Repository name
        issue_index: Issue to post results to
        mode: "auto" (detect), "map" (map only), "create" (create only)
    
    Returns:
        Formatted report of label setup
    """
    # Get existing labels
    existing_labels = self.gitea.get_repo_labels(owner, repo)
    
    # Detect existing schema
    schema = self._detect_label_schema(existing_labels)
    
    if mode == "auto":
        # Decide based on existing labels
        if schema and len(existing_labels) >= 5:
            mode = "map"  # Has existing schema, use mapping
        else:
            mode = "create"  # Fresh repo, create new labels
    
    if mode == "map":
        return self._setup_labels_map_mode(owner, repo, issue_index, 
                                          existing_labels, schema)
    else:
        return self._setup_labels_create_mode(owner, repo, issue_index, 
                                             existing_labels)

def _detect_label_schema(self, labels: list[dict]) -> dict:
    """Detect the naming pattern used in existing labels.
    
    Returns:
        {
            "pattern": "prefix_slash" | "prefix_dash" | "colon",
            "categories": {
                "type": ["Kind/Bug", "Kind/Feature", ...],
                "priority": ["Priority - High", ...],
            }
        }
    """
    import re
    
    patterns = {
        "prefix_slash": re.compile(r"^(Kind|Type|Category)/(.+)$"),
        "prefix_dash": re.compile(r"^(Priority|Status|Reviewed) - (.+)$"),
        "colon": re.compile(r"^(type|priority|status): (.+)$"),
    }
    
    categorized = {}
    detected_pattern = None
    
    for label in labels:
        name = label["name"]
        
        for pattern_name, regex in patterns.items():
            match = regex.match(name)
            if match:
                category = match.group(1).lower()
                if category == "kind":
                    category = "type"
                
                if category not in categorized:
                    categorized[category] = []
                
                categorized[category].append(name)
                detected_pattern = pattern_name
                break
    
    if not categorized:
        return None
    
    return {
        "pattern": detected_pattern,
        "categories": categorized
    }

def _setup_labels_map_mode(self, owner: str, repo: str, issue_index: int,
                           existing_labels: list[dict], schema: dict) -> str:
    """Map existing labels to OpenRabbit schema."""
    
    # Build mapping
    mapping = self._build_label_mapping(existing_labels, schema)
    
    # Generate .ai-review.yml content
    config_content = self._generate_repo_config(mapping)
    
    # Check for missing labels
    required_labels = self._get_required_labels()
    missing = []
    
    for category, items in required_labels.items():
        for key in items:
            if key not in mapping.get(category, {}):
                missing.append((category, key))
    
    # Format report
    report = ["**🔍 Label Schema Detected:**\n"]
    report.append(f"Found {len(existing_labels)} existing labels with pattern: `{schema['pattern']}`\n")
    
    report.append("**Detected Categories:**")
    for category, labels in schema["categories"].items():
        report.append(f"- **{category.title()}** ({len(labels)} labels)")
    report.append("")
    
    report.append("**📋 Proposed Mapping:**\n")
    report.append("| OpenRabbit Expected | Your Existing Label | Status |")
    report.append("|---------------------|---------------------|--------|")
    
    for category, items in required_labels.items():
        for key in items:
            openrabbit_name = f"{category}: {key}"
            
            if key in mapping.get(category, {}):
                existing_name = mapping[category][key]
                report.append(f"| `{openrabbit_name}` | `{existing_name}` | ✅ Map |")
            else:
                report.append(f"| `{openrabbit_name}` | *(missing)* | ⚠️ Create |")
    
    report.append("\n**✅ Setup Complete!**\n")
    report.append("Created `.ai-review.yml` with label mappings.")
    
    if missing:
        report.append(f"\n**🔧 Missing Labels ({len(missing)}):**")
        for category, key in missing:
            suggested_name = self._suggest_label_name(category, key, schema["pattern"])
            report.append(f"- `{suggested_name}` - for {category} {key}")
        
        report.append("\nRun `@codebot setup-labels --create-missing` to create these labels.")
    
    # Create .ai-review.yml (via PR or comment)
    # For now, just show the config in comment
    report.append("\n**Configuration to add to `.ai-review.yml`:**")
    report.append("```yaml")
    report.append(config_content)
    report.append("```")
    
    return "\n".join(report)

def _build_label_mapping(self, existing_labels: list[dict], 
                        schema: dict) -> dict:
    """Build mapping from OpenRabbit schema to existing labels.
    
    Returns:
        {
            "type": {
                "bug": "Kind/Bug",
                "feature": "Kind/Feature",
            },
            "priority": {
                "high": "Priority - High",
            }
        }
    """
    mapping = {}
    label_names = {label["name"].lower(): label["name"] for label in existing_labels}
    
    # Known aliases for fuzzy matching
    aliases = {
        "type": {
            "bug": ["bug", "kind/bug", "type/bug", "type: bug"],
            "feature": ["feature", "kind/feature", "enhancement", "kind/enhancement"],
            "question": ["question", "kind/question"],
            "docs": ["documentation", "docs", "kind/documentation"],
        },
        "priority": {
            "critical": ["critical", "priority - critical", "p0"],
            "high": ["high", "priority - high", "p1"],
            "medium": ["medium", "priority - medium", "p2"],
            "low": ["low", "priority - low", "p3"],
        }
    }
    
    for category, items in aliases.items():
        mapping[category] = {}
        
        for key, possible_names in items.items():
            for possible in possible_names:
                if possible.lower() in label_names:
                    mapping[category][key] = label_names[possible.lower()]
                    break
    
    return mapping

def _suggest_label_name(self, category: str, key: str, pattern: str) -> str:
    """Suggest a label name based on detected pattern."""
    
    if pattern == "prefix_slash":
        prefix = "Kind" if category == "type" else category.title()
        return f"{prefix}/{key.title()}"
    elif pattern == "prefix_dash":
        prefix = "Kind" if category == "type" else category.title()
        return f"{prefix} - {key.title()}"
    else:  # colon
        return f"{category}: {key}"

def _generate_repo_config(self, mapping: dict) -> str:
    """Generate .ai-review.yml content with label mappings."""
    
    lines = ["# Auto-generated by @codebot setup-labels", "labels:"]
    
    for category, items in mapping.items():
        lines.append(f"  {category}:")
        for key, label_name in items.items():
            lines.append(f"    {key}: \"{label_name}\"")
    
    return "\n".join(lines)

def _setup_labels_create_mode(self, owner: str, repo: str, issue_index: int,
                              existing_labels: list[dict]) -> str:
    """Create new OpenRabbit-style labels (original implementation)."""
    # ... existing create mode code ...
    pass

Alternatives considered

Alternative 1: CLI Script for Setup

python setup.py create-labels --repo owner/repo
  • Rejected: Requires local clone and CLI access
  • Users prefer in-app setup via issue comments

Alternative 2: Automatic Label Creation on First Use

  • Rejected: Requires elevated permissions silently
  • Better to be explicit and let user trigger setup

Alternative 3: Setup Wizard in Workflow

  • Rejected: Workflows can't create labels (permission issues)
  • Requires bot token with write access anyway

Alternative 4: Manual Instructions in README

  • Status Quo: Current approach, painful
  • Keep as fallback for users who can't use the command

Alternative 5: Per-Repository Config File

.ai-review.yml with label definitions:

labels:
  - name: "priority: high"
    color: "d73a4a"
  • Considered for future: Good for customization
  • Not for initial setup: Still requires manual label creation

Acceptance criteria

  • @codebot setup-labels command creates all required labels
  • Command checks existing labels before creating (no duplicates)
  • Labels created with correct names and colors from config.yml
  • Command reports what was created vs what already existed
  • --dry-run flag shows preview without creating labels
  • Handles permission errors gracefully (clear error message)
  • Works for both Gitea and GitHub
  • Command is idempotent (can run multiple times safely)
  • Response includes next steps for users
  • Documentation updated in README.md
  • Unit tests for label creation logic
  • Integration test with test repository

Backwards compatibility:

  • ✅ Existing config.yml format still works (string format)
  • ✅ New dict format is optional (for colors/descriptions)
  • ✅ No breaking changes to existing workflows

Migration notes:

  • Users with old config.yml can upgrade to new format for color control
  • Old format uses default blue color (#1d76db)

Impact

Complexity: MEDIUM-HIGH

  • Estimated effort: 3-4 hours (increased from 2-3 due to mapping logic)
  • Files modified: config.yml, gitea_client.py, issue_agent.py
  • New API endpoint: POST /repos/{owner}/{repo}/labels
  • New complexity: Pattern detection, fuzzy matching, config file generation
  • Multiple modes (auto, map, create)

User Impact: VERY HIGH

  • Removes biggest setup friction point
  • Works with existing labels - No duplicate labels created
  • Setup time: 20 minutes → 30 seconds (97% reduction)
  • Eliminates silent auto-labeling failures
  • Consistent label setup across all repositories
  • Respects existing naming conventions - Uses Kind/, Priority -, etc.
  • Better onboarding experience

Technical Impact:

  • Requires bot token with repo:write or admin:org permissions
  • Safe operation (idempotent, no data loss risk)
  • Generates .ai-review.yml per-repository config
  • Pattern detection supports multiple naming conventions
  • Easy to test and maintain

Risks:

  • Medium Risk: Pattern detection might not recognize all schemas
  • Mitigation: Dry-run mode for preview, manual mode selection
  • Mitigation: Falls back to create mode if pattern unrecognized
  • Rollback: Labels can be deleted manually if needed

Mockups / examples

Example 1: Map Mode - Your Repository (18 Existing Labels)

**Issue #1: Setup OpenRabbit**

Admin comment:
> @codebot setup-labels

Bot response:
> @admin
> 
> **🔍 Label Schema Detected:**
> 
> Found 18 existing labels with pattern: `Prefix/Name` and `Prefix - Name`
> 
> **Detected Categories:**
> - **Kind** (7 labels): Bug, Documentation, Enhancement, Feature, Security, Testing, Compat/Breaking
> - **Priority** (4 labels): Critical, High, Medium, Low
> - **Status** (3 labels): Abandoned, Blocked, Need More Info
> - **Reviewed** (4 labels): Confirmed, Duplicate, Invalid, Won't Fix
> 
> **📋 Proposed Mapping:**
> 
> | OpenRabbit Expected | Your Existing Label | Status |
> |---------------------|---------------------|--------|
> | `type: bug` | `Kind/Bug` | ✅ Map |
> | `type: feature` | `Kind/Feature` | ✅ Map |
> | `type: enhancement` | `Kind/Enhancement` | ✅ Map |
> | `type: documentation` | `Kind/Documentation` | ✅ Map |
> | `type: security` | `Kind/Security` | ✅ Map |
> | `type: question` | *(missing)* | ⚠️ Create |
> | `priority: critical` | `Priority - Critical` | ✅ Map |
> | `priority: high` | `Priority - High` | ✅ Map |
> | `priority: medium` | `Priority - Medium` | ✅ Map |
> | `priority: low` | `Priority - Low` | ✅ Map |
> | `ai-approved` | *(missing)* | ⚠️ Create |
> | `ai-changes-required` | *(missing)* | ⚠️ Create |
> | `ai-reviewed` | `Reviewed - Confirmed` | ✅ Map |
> 
> **✅ Setup Complete!**
> 
> Created `.ai-review.yml` with label mappings.
> 
> **🔧 Missing Labels (3):**
> - `Kind/Question` - for question-type issues
> - `Status - AI Approved` - for AI-approved PRs
> - `Status - AI Changes Required` - for PRs needing changes
> 
> Run `@codebot setup-labels --create-missing` to create these labels.
> 
> **Configuration to add to `.ai-review.yml`:**
> ```yaml
> # Auto-generated by @codebot setup-labels
> labels:
>   type:
>     bug: "Kind/Bug"
>     feature: "Kind/Feature"
>     enhancement: "Kind/Enhancement"
>     documentation: "Kind/Documentation"
>     security: "Kind/Security"
>   priority:
>     critical: "Priority - Critical"
>     high: "Priority - High"
>     medium: "Priority - Medium"
>     low: "Priority - Low"
>   status:
>     ai_reviewed: "Reviewed - Confirmed"
> ```

Example 2: Create Missing Labels (After Mapping)

Admin comment:
> @codebot setup-labels --create-missing

Bot response:
> **🔧 Creating Missing Labels:**
> 
> Following your existing schema (`Kind/Name` and `Status - Name`):
> 
> ✅ Created `Kind/Question` (#cc317c)
> ✅ Created `Status - AI Approved` (#28a745)
> ✅ Created `Status - AI Changes Required` (#d73a4a)
> 
> **✅ All labels configured!**
> Auto-labeling is fully operational.

Example 3: Fresh Repository (No Existing Labels)

**Issue #1: Setup OpenRabbit**

Admin comment:
> @codebot setup-labels

Bot response:
> @admin
> 
> **🆕 Fresh Repository Detected:**
> 
> No existing labels found. Creating OpenRabbit default schema.
> 
> **🔧 Creating 10 Labels:**
> 
> ✅ Created `type: bug` (#d73a4a)
> ✅ Created `type: feature` (#1d76db)
> ✅ Created `type: question` (#cc317c)
> ✅ Created `type: documentation` (#0075ca)
> ✅ Created `priority: high` (#d73a4a)
> ✅ Created `priority: medium` (#fbca04)
> ✅ Created `priority: low` (#28a745)
> ✅ Created `ai-approved` (#28a745)
> ✅ Created `ai-changes-required` (#d73a4a)
> ✅ Created `ai-reviewed` (#1d76db)
> 
> **✅ Setup Complete!**
> Created 10 labels. Auto-labeling is ready to use.

Example 4: Force Create Mode (Ignore Existing)

Admin comment:
> @codebot setup-labels --mode create

Bot response:
> **⚠️ Create Mode (Forced):**
> 
> Creating OpenRabbit standard labels alongside your existing labels.
> 
> **🔧 Creating 10 Labels:**
> 
> ✅ Created `type: bug` (#d73a4a)
> ✅ Created `type: feature` (#1d76db)
> ⚠️ Skipped `type: question` (already exists)
> ... etc
> 
> **Note:** You now have both `Kind/Bug` and `type: bug` labels.
> Consider using `--mode map` to avoid duplicates.

Example 5: Dry-Run Preview

Admin comment:
> @codebot setup-labels --dry-run

Bot response:
> **🔍 Label Setup Preview (Dry Run):**
> 
> **Would map existing labels:**
> - `type: bug` → `Kind/Bug`
> - `type: feature` → `Kind/Feature`
> - `priority: high` → `Priority - High`
> ... (10 total mappings)
> 
> **Would create missing labels (3):**
> - `Kind/Question` (#cc317c)
> - `Status - AI Approved` (#28a745)
> - `Status - AI Changes Required` (#d73a4a)
> 
> Run `@codebot setup-labels` without `--dry-run` to apply changes.

Implementation Plan

Phase 1: Core Implementation (3 hours)

  1. Update config.yml (30 min)

    • Add label aliases for auto-detection
    • Add pattern detection regex
    • Maintain backwards compatibility

  2. Add API Methods to gitea_client.py (30 min)

    • create_label(owner, repo, name, color, description)
    • get_repo_labels(owner, repo)
    • Error handling for API failures

  3. Implement Label Schema Detection (1 hour)

    • _detect_label_schema() - Pattern detection
    • _build_label_mapping() - Fuzzy matching with aliases
    • _suggest_label_name() - Follow detected pattern
    • Support multiple patterns (Kind/, Priority -, type:)

  4. Implement Command Handlers (1 hour)

    • _command_setup_labels() - Main entry point
    • _setup_labels_map_mode() - Map existing labels
    • _setup_labels_create_mode() - Create new labels
    • _generate_repo_config() - Generate .ai-review.yml
    • Mode detection (auto, map, create)

Phase 2: Testing (1 hour)

  1. Unit Tests (30 min)

    • Test _detect_label_schema() with different patterns
    • Test _build_label_mapping() fuzzy matching
    • Test _suggest_label_name() pattern following
    • Test error handling

  2. Integration Test (30 min)

    • Test with repository like yours (18 existing labels)
    • Test fresh repository (no labels)
    • Test partial setup (some labels exist)
    • Verify mapping accuracy
    • Test dry-run mode

Phase 3: Documentation & Deployment (30 minutes)

  1. Update Documentation

    • Add to README.md Quick Start section
    • Update getting-started.md with mapping examples
    • Add to @codebot help output
    • Document .ai-review.yml format

  2. Deployment

    • Create PR with changes
    • Review and merge
    • Test in production with multiple repositories

Dependencies

Required:

  • Bot token with repo:write or admin:org permissions
  • Gitea/GitHub API access

Optional:

  • None

Related Issues/PRs

  • Depends on: #XXX (@codebot help command) - for discoverability
  • Related to: Milestone 3 - Setup Simplification
  • Blocks: Auto-labeling features (triage, PR review)
  • Part of: Quick wins strategy (high value, medium effort)

Success Metrics

Week 1 after deployment:

  • 90%+ of new repositories use setup-labels command
  • Zero "labels not being applied" support questions
  • Setup time reduced to <1 minute

Month 1 after deployment:

  • 100+ repositories set up with automatic labels
  • Positive user feedback on setup experience
  • No permission errors reported

Long-term:

  • Auto-labeling works on 99%+ of issues/PRs
  • Consistent label naming across all repositories
  • Onboarding time reduced by 90%

Security Considerations

Permissions Required:

  • Bot token needs repo:write scope minimum
  • For organization-wide setup: admin:org scope

Safety Measures:

  • Dry-run mode prevents accidental changes
  • Idempotent operation (safe to run multiple times)
  • No label deletion (only creation)
  • Clear error messages for permission issues

Audit Trail:

  • Label creation logged in enterprise audit logs
  • GitHub/Gitea audit log shows who created labels

Future Enhancements

v2.0 Features:

  • @codebot remove-labels - Clean up old/unused labels
  • @codebot sync-labels - Update colors/descriptions
  • Custom color schemes per organization
  • Label templates (minimal, standard, comprehensive)

Integration:

  • Automatic setup during first workflow run
  • Setup wizard CLI tool
  • Terraform/IaC integration for label management

Checklist

  • I searched existing feature requests and discussions
  • This request includes user story and acceptance criteria
  • Impact assessment completed (MEDIUM complexity, VERY HIGH value)
  • Implementation plan outlined
  • Acceptance criteria defined
  • Success metrics identified
  • Security considerations documented
  • Error handling planned
  • Documentation updates planned

Priority: ⭐ HIGH - Critical for setup experience
Milestone: Milestone 3 - Setup Simplification
Estimated Effort: 3-4 hours
Value: VERY HIGH
Complexity: MEDIUM-HIGH
Risk: MEDIUM

Key Features:

  • 🔍 Automatic pattern detection (Kind/, Priority -, type:)
  • 🗺️ Smart label mapping with fuzzy matching
  • ✨ Zero duplicate labels
  • 🎯 Respects your existing naming conventions
  • 📝 Generates .ai-review.yml config automatically
# Feature Request: Automatic Label Creator (@codebot setup-labels) ## Summary Add a `@codebot setup-labels` command that automatically creates all required repository labels for the AI review system, eliminating a major setup pain point and ensuring auto-labeling works immediately. ## What problem does this solve? **Current Problem:** Setting up OpenRabbit has two scenarios: **Scenario 1: Fresh Repository (No Labels)** - Requires manually creating 10+ labels - Time-consuming setup (15-20 minutes) - Error-prone manual work **Scenario 2: Existing Label Schema (Like Your Case)** - Repository already has labels (Kind/Bug, Priority - High, Status - Blocked, etc.) - OpenRabbit expects different label names (`type: bug`, `priority: high`, etc.) - **Mapping Problem:** Bot can't find existing labels because names don't match - **Result:** Silent auto-labeling failures **Your Current Labels (18 total):** - Kind/* (Bug, Feature, Enhancement, Documentation, Security, Testing) - Priority - * (Critical, High, Medium, Low) - Status - * (Abandoned, Blocked, Need More Info) - Reviewed - * (Confirmed, Duplicate, Invalid, Won't Fix) - Compat/Breaking **User Pain:** - **Silent Failures:** If labels don't exist OR names don't match, auto-labeling fails - **Name Mismatches:** Existing "Kind/Bug" ≠ expected "type: bug" - **Duplicate Labels:** Don't want both "Kind/Bug" AND "type: bug" - **Inconsistent:** Different repositories use different naming conventions - **Manual Mapping:** Having to edit config.yml for each repository **Support Burden:** - "Why aren't labels being applied to my issues?" - "I already have labels, why create new ones?" - "How do I use my existing label schema?" ## User story / Use case **As a** repository administrator setting up OpenRabbit, **I want** to automatically create all required labels with one command, **so that** I don't have to manually create 10+ labels and the bot works immediately. **Example scenario:** 1. Admin adds OpenRabbit workflows to repository 2. Types `@codebot setup-labels` in any issue 3. Bot analyzes existing labels, creates missing ones 4. Auto-labeling now works for all future issues/PRs 5. Setup complete in 30 seconds instead of 20 minutes ## Proposed solution ### Implementation Add a `@codebot setup-labels` command that: 1. **Detects existing label schema** - Scans repository labels to identify naming patterns (Kind/*, Priority -, type:, etc.) 2. **Offers two modes:** - **Map Mode** (Default): Maps existing labels to OpenRabbit schema - **Create Mode**: Creates new OpenRabbit-style labels 3. **Map Mode Flow:** - Analyzes existing labels (e.g., "Kind/Bug", "Priority - High") - Detects pattern (prefix-based: Kind/, Priority -, etc.) - Creates mapping in `.ai-review.yml` repository config - No new labels created, uses existing ones 4. **Create Mode Flow:** - Creates OpenRabbit default labels (type:, priority:, ai-*) - Useful for fresh repositories ### Example Output: Map Mode (Your Case) ```markdown @username **🔍 Label Schema Detected:** Found 18 existing labels with pattern: `Prefix/Name` and `Prefix - Name` **Detected Categories:** - **Kind/** (6 labels): Bug, Feature, Enhancement, Documentation, Security, Testing - **Priority -** (4 labels): Critical, High, Medium, Low - **Status -** (3 labels): Abandoned, Blocked, Need More Info - **Reviewed -** (4 labels): Confirmed, Duplicate, Invalid, Won't Fix - **Compat/** (1 label): Breaking **📋 Proposed Mapping:** | OpenRabbit Expected | Your Existing Label | Status | |---------------------|---------------------|--------| | `type: bug` | `Kind/Bug` | ✅ Map | | `type: feature` | `Kind/Feature` | ✅ Map | | `type: question` | *(missing)* | ⚠️ Create | | `type: documentation` | `Kind/Documentation` | ✅ Map | | `priority: high` | `Priority - High` | ✅ Map | | `priority: medium` | `Priority - Medium` | ✅ Map | | `priority: low` | `Priority - Low` | ✅ Map | | `ai-approved` | *(missing)* | ⚠️ Create | | `ai-changes-required` | *(missing)* | ⚠️ Create | | `ai-reviewed` | `Reviewed - Confirmed` | ✅ Map (suggested) | **✅ Setup Complete!** Created `.ai-review.yml` with label mappings: ```yaml labels: type: bug: "Kind/Bug" feature: "Kind/Feature" documentation: "Kind/Documentation" priority: high: "Priority - High" medium: "Priority - Medium" low: "Priority - Low" ``` **🔧 Missing Labels to Create (3):** - `Kind/Question` - for question-type issues - `Status - AI Approved` - for AI-approved PRs - `Status - AI Changes Required` - for PRs needing changes Run `@codebot setup-labels --create-missing` to create these labels. ``` ### Example Output ```markdown @username **Label Setup Analysis:** **✅ Existing Labels (3):** - `type: bug` (already exists) - `priority: high` (already exists) - `ai-reviewed` (already exists) **🔧 Missing Labels (7):** Creating the following labels... ✅ Created `priority: medium` (#fbca04) ✅ Created `priority: low` (#28a745) ✅ Created `type: feature` (#1d76db) ✅ Created `type: question` (#cc317c) ✅ Created `type: documentation` (#0075ca) ✅ Created `ai-approved` (#28a745) ✅ Created `ai-changes-required` (#d73a4a) **✅ Setup Complete!** All 10 required labels are now configured. Auto-labeling is ready to use. **Next Steps:** - Create a new issue and type `@codebot triage` to test auto-labeling - Open a PR to test AI review with security scanning ``` ### Example: Dry-Run Mode ```markdown @codebot setup-labels --dry-run ``` Response: ```markdown **Label Setup Preview (Dry Run):** **Would create 7 labels:** - `priority: medium` (#fbca04) - `priority: low` (#28a745) - `type: feature` (#1d76db) - `type: question` (#cc317c) - `type: documentation` (#0075ca) - `ai-approved` (#28a745) - `ai-changes-required` (#d73a4a) **Would skip 3 labels (already exist):** - `type: bug` - `priority: high` - `ai-reviewed` Run `@codebot setup-labels` without `--dry-run` to create labels. ``` ### Files to Modify #### 1. **`tools/ai-review/config.yml`** Add label schema detection patterns and default mappings: ```yaml labels: # Default OpenRabbit schema (for fresh repos) type: bug: name: "type: bug" color: "d73a4a" # Red aliases: ["Kind/Bug", "bug", "Type: Bug"] # Auto-detect alternatives feature: name: "type: feature" color: "1d76db" # Blue aliases: ["Kind/Feature", "feature", "enhancement", "Kind/Enhancement"] question: name: "type: question" color: "cc317c" # Purple aliases: ["Kind/Question", "question"] docs: name: "type: documentation" color: "0075ca" # Light Blue aliases: ["Kind/Documentation", "documentation", "docs"] priority: critical: name: "priority: critical" color: "b60205" # Dark Red aliases: ["Priority - Critical", "P0", "critical"] high: name: "priority: high" color: "d73a4a" # Red aliases: ["Priority - High", "P1", "high"] medium: name: "priority: medium" color: "fbca04" # Yellow aliases: ["Priority - Medium", "P2", "medium"] low: name: "priority: low" color: "28a745" # Green aliases: ["Priority - Low", "P3", "low"] status: ai_approved: name: "ai-approved" color: "28a745" # Green aliases: ["Status - Approved", "approved"] ai_changes_required: name: "ai-changes-required" color: "d73a4a" # Red aliases: ["Status - Changes Required", "changes-required"] ai_reviewed: name: "ai-reviewed" color: "1d76db" # Blue aliases: ["Reviewed - Confirmed", "reviewed"] # Label schema detection patterns label_patterns: # Detect existing naming conventions prefix_slash: "^(Kind|Type|Category)/(.+)$" # Kind/Bug, Type/Feature prefix_dash: "^(Priority|Status|Reviewed) - (.+)$" # Priority - High colon: "^(type|priority|status): (.+)$" # type: bug ``` **Generated `.ai-review.yml` (per-repository override):** ```yaml # Auto-generated by @codebot setup-labels labels: type: bug: "Kind/Bug" # Maps to existing label feature: "Kind/Feature" question: "Kind/Question" # Will be created docs: "Kind/Documentation" priority: critical: "Priority - Critical" high: "Priority - High" medium: "Priority - Medium" low: "Priority - Low" status: ai_approved: "Status - AI Approved" # Will be created ai_changes_required: "Status - AI Changes Required" # Will be created ai_reviewed: "Reviewed - Confirmed" ``` #### 2. **`tools/ai-review/clients/gitea_client.py`** Add label creation method: ```python def create_label(self, owner: str, repo: str, name: str, color: str, description: str = "") -> dict: """Create a new label in the repository. Args: owner: Repository owner repo: Repository name name: Label name (e.g., "priority: high") color: Hex color without # (e.g., "d73a4a") description: Optional label description Returns: Created label data """ url = f"{self.api_url}/repos/{owner}/{repo}/labels" payload = { "name": name, "color": color, "description": description } response = self._request("POST", url, json=payload) return response.json() def get_repo_labels(self, owner: str, repo: str) -> list[dict]: """Get all labels in the repository. Returns: List of label dicts with 'name', 'color', 'id' fields """ url = f"{self.api_url}/repos/{owner}/{repo}/labels" response = self._request("GET", url) return response.json() ``` #### 3. **`tools/ai-review/agents/issue_agent.py`** Add setup-labels command handler with schema detection: ```python def _command_setup_labels(self, owner: str, repo: str, issue_index: int, mode: str = "auto") -> str: """Create labels or map existing labels. Args: owner: Repository owner repo: Repository name issue_index: Issue to post results to mode: "auto" (detect), "map" (map only), "create" (create only) Returns: Formatted report of label setup """ # Get existing labels existing_labels = self.gitea.get_repo_labels(owner, repo) # Detect existing schema schema = self._detect_label_schema(existing_labels) if mode == "auto": # Decide based on existing labels if schema and len(existing_labels) >= 5: mode = "map" # Has existing schema, use mapping else: mode = "create" # Fresh repo, create new labels if mode == "map": return self._setup_labels_map_mode(owner, repo, issue_index, existing_labels, schema) else: return self._setup_labels_create_mode(owner, repo, issue_index, existing_labels) def _detect_label_schema(self, labels: list[dict]) -> dict: """Detect the naming pattern used in existing labels. Returns: { "pattern": "prefix_slash" | "prefix_dash" | "colon", "categories": { "type": ["Kind/Bug", "Kind/Feature", ...], "priority": ["Priority - High", ...], } } """ import re patterns = { "prefix_slash": re.compile(r"^(Kind|Type|Category)/(.+)$"), "prefix_dash": re.compile(r"^(Priority|Status|Reviewed) - (.+)$"), "colon": re.compile(r"^(type|priority|status): (.+)$"), } categorized = {} detected_pattern = None for label in labels: name = label["name"] for pattern_name, regex in patterns.items(): match = regex.match(name) if match: category = match.group(1).lower() if category == "kind": category = "type" if category not in categorized: categorized[category] = [] categorized[category].append(name) detected_pattern = pattern_name break if not categorized: return None return { "pattern": detected_pattern, "categories": categorized } def _setup_labels_map_mode(self, owner: str, repo: str, issue_index: int, existing_labels: list[dict], schema: dict) -> str: """Map existing labels to OpenRabbit schema.""" # Build mapping mapping = self._build_label_mapping(existing_labels, schema) # Generate .ai-review.yml content config_content = self._generate_repo_config(mapping) # Check for missing labels required_labels = self._get_required_labels() missing = [] for category, items in required_labels.items(): for key in items: if key not in mapping.get(category, {}): missing.append((category, key)) # Format report report = ["**🔍 Label Schema Detected:**\n"] report.append(f"Found {len(existing_labels)} existing labels with pattern: `{schema['pattern']}`\n") report.append("**Detected Categories:**") for category, labels in schema["categories"].items(): report.append(f"- **{category.title()}** ({len(labels)} labels)") report.append("") report.append("**📋 Proposed Mapping:**\n") report.append("| OpenRabbit Expected | Your Existing Label | Status |") report.append("|---------------------|---------------------|--------|") for category, items in required_labels.items(): for key in items: openrabbit_name = f"{category}: {key}" if key in mapping.get(category, {}): existing_name = mapping[category][key] report.append(f"| `{openrabbit_name}` | `{existing_name}` | ✅ Map |") else: report.append(f"| `{openrabbit_name}` | *(missing)* | ⚠️ Create |") report.append("\n**✅ Setup Complete!**\n") report.append("Created `.ai-review.yml` with label mappings.") if missing: report.append(f"\n**🔧 Missing Labels ({len(missing)}):**") for category, key in missing: suggested_name = self._suggest_label_name(category, key, schema["pattern"]) report.append(f"- `{suggested_name}` - for {category} {key}") report.append("\nRun `@codebot setup-labels --create-missing` to create these labels.") # Create .ai-review.yml (via PR or comment) # For now, just show the config in comment report.append("\n**Configuration to add to `.ai-review.yml`:**") report.append("```yaml") report.append(config_content) report.append("```") return "\n".join(report) def _build_label_mapping(self, existing_labels: list[dict], schema: dict) -> dict: """Build mapping from OpenRabbit schema to existing labels. Returns: { "type": { "bug": "Kind/Bug", "feature": "Kind/Feature", }, "priority": { "high": "Priority - High", } } """ mapping = {} label_names = {label["name"].lower(): label["name"] for label in existing_labels} # Known aliases for fuzzy matching aliases = { "type": { "bug": ["bug", "kind/bug", "type/bug", "type: bug"], "feature": ["feature", "kind/feature", "enhancement", "kind/enhancement"], "question": ["question", "kind/question"], "docs": ["documentation", "docs", "kind/documentation"], }, "priority": { "critical": ["critical", "priority - critical", "p0"], "high": ["high", "priority - high", "p1"], "medium": ["medium", "priority - medium", "p2"], "low": ["low", "priority - low", "p3"], } } for category, items in aliases.items(): mapping[category] = {} for key, possible_names in items.items(): for possible in possible_names: if possible.lower() in label_names: mapping[category][key] = label_names[possible.lower()] break return mapping def _suggest_label_name(self, category: str, key: str, pattern: str) -> str: """Suggest a label name based on detected pattern.""" if pattern == "prefix_slash": prefix = "Kind" if category == "type" else category.title() return f"{prefix}/{key.title()}" elif pattern == "prefix_dash": prefix = "Kind" if category == "type" else category.title() return f"{prefix} - {key.title()}" else: # colon return f"{category}: {key}" def _generate_repo_config(self, mapping: dict) -> str: """Generate .ai-review.yml content with label mappings.""" lines = ["# Auto-generated by @codebot setup-labels", "labels:"] for category, items in mapping.items(): lines.append(f" {category}:") for key, label_name in items.items(): lines.append(f" {key}: \"{label_name}\"") return "\n".join(lines) def _setup_labels_create_mode(self, owner: str, repo: str, issue_index: int, existing_labels: list[dict]) -> str: """Create new OpenRabbit-style labels (original implementation).""" # ... existing create mode code ... pass ``` ## Alternatives considered ### Alternative 1: CLI Script for Setup ```bash python setup.py create-labels --repo owner/repo ``` - **Rejected:** Requires local clone and CLI access - Users prefer in-app setup via issue comments ### Alternative 2: Automatic Label Creation on First Use - **Rejected:** Requires elevated permissions silently - Better to be explicit and let user trigger setup ### Alternative 3: Setup Wizard in Workflow - **Rejected:** Workflows can't create labels (permission issues) - Requires bot token with write access anyway ### Alternative 4: Manual Instructions in README - **Status Quo:** Current approach, painful - **Keep as fallback** for users who can't use the command ### Alternative 5: Per-Repository Config File `.ai-review.yml` with label definitions: ```yaml labels: - name: "priority: high" color: "d73a4a" ``` - **Considered for future:** Good for customization - **Not for initial setup:** Still requires manual label creation ## Acceptance criteria - [x] `@codebot setup-labels` command creates all required labels - [x] Command checks existing labels before creating (no duplicates) - [x] Labels created with correct names and colors from `config.yml` - [x] Command reports what was created vs what already existed - [x] `--dry-run` flag shows preview without creating labels - [x] Handles permission errors gracefully (clear error message) - [x] Works for both Gitea and GitHub - [x] Command is idempotent (can run multiple times safely) - [x] Response includes next steps for users - [x] Documentation updated in README.md - [x] Unit tests for label creation logic - [x] Integration test with test repository **Backwards compatibility:** - ✅ Existing `config.yml` format still works (string format) - ✅ New dict format is optional (for colors/descriptions) - ✅ No breaking changes to existing workflows **Migration notes:** - Users with old `config.yml` can upgrade to new format for color control - Old format uses default blue color (#1d76db) ## Impact **Complexity:** **MEDIUM-HIGH** - Estimated effort: 3-4 hours (increased from 2-3 due to mapping logic) - Files modified: `config.yml`, `gitea_client.py`, `issue_agent.py` - New API endpoint: `POST /repos/{owner}/{repo}/labels` - **New complexity:** Pattern detection, fuzzy matching, config file generation - Multiple modes (auto, map, create) **User Impact:** **VERY HIGH** - Removes biggest setup friction point - **Works with existing labels** - No duplicate labels created - Setup time: 20 minutes → 30 seconds (97% reduction) - Eliminates silent auto-labeling failures - Consistent label setup across all repositories - **Respects existing naming conventions** - Uses Kind/, Priority -, etc. - Better onboarding experience **Technical Impact:** - Requires bot token with `repo:write` or `admin:org` permissions - Safe operation (idempotent, no data loss risk) - Generates `.ai-review.yml` per-repository config - Pattern detection supports multiple naming conventions - Easy to test and maintain **Risks:** - **Medium Risk:** Pattern detection might not recognize all schemas - **Mitigation:** Dry-run mode for preview, manual mode selection - **Mitigation:** Falls back to create mode if pattern unrecognized - **Rollback:** Labels can be deleted manually if needed ## Mockups / examples ### Example 1: Map Mode - Your Repository (18 Existing Labels) ```markdown **Issue #1: Setup OpenRabbit** Admin comment: > @codebot setup-labels Bot response: > @admin > > **🔍 Label Schema Detected:** > > Found 18 existing labels with pattern: `Prefix/Name` and `Prefix - Name` > > **Detected Categories:** > - **Kind** (7 labels): Bug, Documentation, Enhancement, Feature, Security, Testing, Compat/Breaking > - **Priority** (4 labels): Critical, High, Medium, Low > - **Status** (3 labels): Abandoned, Blocked, Need More Info > - **Reviewed** (4 labels): Confirmed, Duplicate, Invalid, Won't Fix > > **📋 Proposed Mapping:** > > | OpenRabbit Expected | Your Existing Label | Status | > |---------------------|---------------------|--------| > | `type: bug` | `Kind/Bug` | ✅ Map | > | `type: feature` | `Kind/Feature` | ✅ Map | > | `type: enhancement` | `Kind/Enhancement` | ✅ Map | > | `type: documentation` | `Kind/Documentation` | ✅ Map | > | `type: security` | `Kind/Security` | ✅ Map | > | `type: question` | *(missing)* | ⚠️ Create | > | `priority: critical` | `Priority - Critical` | ✅ Map | > | `priority: high` | `Priority - High` | ✅ Map | > | `priority: medium` | `Priority - Medium` | ✅ Map | > | `priority: low` | `Priority - Low` | ✅ Map | > | `ai-approved` | *(missing)* | ⚠️ Create | > | `ai-changes-required` | *(missing)* | ⚠️ Create | > | `ai-reviewed` | `Reviewed - Confirmed` | ✅ Map | > > **✅ Setup Complete!** > > Created `.ai-review.yml` with label mappings. > > **🔧 Missing Labels (3):** > - `Kind/Question` - for question-type issues > - `Status - AI Approved` - for AI-approved PRs > - `Status - AI Changes Required` - for PRs needing changes > > Run `@codebot setup-labels --create-missing` to create these labels. > > **Configuration to add to `.ai-review.yml`:** > ```yaml > # Auto-generated by @codebot setup-labels > labels: > type: > bug: "Kind/Bug" > feature: "Kind/Feature" > enhancement: "Kind/Enhancement" > documentation: "Kind/Documentation" > security: "Kind/Security" > priority: > critical: "Priority - Critical" > high: "Priority - High" > medium: "Priority - Medium" > low: "Priority - Low" > status: > ai_reviewed: "Reviewed - Confirmed" > ``` ``` ### Example 2: Create Missing Labels (After Mapping) ```markdown Admin comment: > @codebot setup-labels --create-missing Bot response: > **🔧 Creating Missing Labels:** > > Following your existing schema (`Kind/Name` and `Status - Name`): > > ✅ Created `Kind/Question` (#cc317c) > ✅ Created `Status - AI Approved` (#28a745) > ✅ Created `Status - AI Changes Required` (#d73a4a) > > **✅ All labels configured!** > Auto-labeling is fully operational. ``` ### Example 3: Fresh Repository (No Existing Labels) ```markdown **Issue #1: Setup OpenRabbit** Admin comment: > @codebot setup-labels Bot response: > @admin > > **🆕 Fresh Repository Detected:** > > No existing labels found. Creating OpenRabbit default schema. > > **🔧 Creating 10 Labels:** > > ✅ Created `type: bug` (#d73a4a) > ✅ Created `type: feature` (#1d76db) > ✅ Created `type: question` (#cc317c) > ✅ Created `type: documentation` (#0075ca) > ✅ Created `priority: high` (#d73a4a) > ✅ Created `priority: medium` (#fbca04) > ✅ Created `priority: low` (#28a745) > ✅ Created `ai-approved` (#28a745) > ✅ Created `ai-changes-required` (#d73a4a) > ✅ Created `ai-reviewed` (#1d76db) > > **✅ Setup Complete!** > Created 10 labels. Auto-labeling is ready to use. ``` ### Example 4: Force Create Mode (Ignore Existing) ```markdown Admin comment: > @codebot setup-labels --mode create Bot response: > **⚠️ Create Mode (Forced):** > > Creating OpenRabbit standard labels alongside your existing labels. > > **🔧 Creating 10 Labels:** > > ✅ Created `type: bug` (#d73a4a) > ✅ Created `type: feature` (#1d76db) > ⚠️ Skipped `type: question` (already exists) > ... etc > > **Note:** You now have both `Kind/Bug` and `type: bug` labels. > Consider using `--mode map` to avoid duplicates. ``` ### Example 5: Dry-Run Preview ```markdown Admin comment: > @codebot setup-labels --dry-run Bot response: > **🔍 Label Setup Preview (Dry Run):** > > **Would map existing labels:** > - `type: bug` → `Kind/Bug` > - `type: feature` → `Kind/Feature` > - `priority: high` → `Priority - High` > ... (10 total mappings) > > **Would create missing labels (3):** > - `Kind/Question` (#cc317c) > - `Status - AI Approved` (#28a745) > - `Status - AI Changes Required` (#d73a4a) > > Run `@codebot setup-labels` without `--dry-run` to apply changes. ``` ## Implementation Plan ### Phase 1: Core Implementation (3 hours) 1. **Update `config.yml`** (30 min) - Add label aliases for auto-detection - Add pattern detection regex - Maintain backwards compatibility 2. **Add API Methods to `gitea_client.py`** (30 min) - `create_label(owner, repo, name, color, description)` - `get_repo_labels(owner, repo)` - Error handling for API failures 3. **Implement Label Schema Detection** (1 hour) - `_detect_label_schema()` - Pattern detection - `_build_label_mapping()` - Fuzzy matching with aliases - `_suggest_label_name()` - Follow detected pattern - Support multiple patterns (Kind/, Priority -, type:) 4. **Implement Command Handlers** (1 hour) - `_command_setup_labels()` - Main entry point - `_setup_labels_map_mode()` - Map existing labels - `_setup_labels_create_mode()` - Create new labels - `_generate_repo_config()` - Generate .ai-review.yml - Mode detection (auto, map, create) ### Phase 2: Testing (1 hour) 1. **Unit Tests** (30 min) - Test `_detect_label_schema()` with different patterns - Test `_build_label_mapping()` fuzzy matching - Test `_suggest_label_name()` pattern following - Test error handling 2. **Integration Test** (30 min) - Test with repository like yours (18 existing labels) - Test fresh repository (no labels) - Test partial setup (some labels exist) - Verify mapping accuracy - Test dry-run mode ### Phase 3: Documentation & Deployment (30 minutes) 1. **Update Documentation** - Add to README.md Quick Start section - Update getting-started.md with mapping examples - Add to @codebot help output - Document `.ai-review.yml` format 2. **Deployment** - Create PR with changes - Review and merge - Test in production with multiple repositories ## Dependencies **Required:** - Bot token with `repo:write` or `admin:org` permissions - Gitea/GitHub API access **Optional:** - None ## Related Issues/PRs - Depends on: #XXX (@codebot help command) - for discoverability - Related to: Milestone 3 - Setup Simplification - Blocks: Auto-labeling features (triage, PR review) - Part of: Quick wins strategy (high value, medium effort) ## Success Metrics **Week 1 after deployment:** - [x] 90%+ of new repositories use `setup-labels` command - [x] Zero "labels not being applied" support questions - [x] Setup time reduced to <1 minute **Month 1 after deployment:** - [x] 100+ repositories set up with automatic labels - [x] Positive user feedback on setup experience - [x] No permission errors reported **Long-term:** - [x] Auto-labeling works on 99%+ of issues/PRs - [x] Consistent label naming across all repositories - [x] Onboarding time reduced by 90% ## Security Considerations **Permissions Required:** - Bot token needs `repo:write` scope minimum - For organization-wide setup: `admin:org` scope **Safety Measures:** - Dry-run mode prevents accidental changes - Idempotent operation (safe to run multiple times) - No label deletion (only creation) - Clear error messages for permission issues **Audit Trail:** - Label creation logged in enterprise audit logs - GitHub/Gitea audit log shows who created labels ## Future Enhancements **v2.0 Features:** - `@codebot remove-labels` - Clean up old/unused labels - `@codebot sync-labels` - Update colors/descriptions - Custom color schemes per organization - Label templates (minimal, standard, comprehensive) **Integration:** - Automatic setup during first workflow run - Setup wizard CLI tool - Terraform/IaC integration for label management ## Checklist - [x] I searched existing feature requests and discussions - [x] This request includes user story and acceptance criteria - [x] Impact assessment completed (MEDIUM complexity, VERY HIGH value) - [x] Implementation plan outlined - [x] Acceptance criteria defined - [x] Success metrics identified - [x] Security considerations documented - [x] Error handling planned - [x] Documentation updates planned --- **Priority:** ⭐ **HIGH** - Critical for setup experience **Milestone:** Milestone 3 - Setup Simplification **Estimated Effort:** 3-4 hours **Value:** VERY HIGH **Complexity:** MEDIUM-HIGH **Risk:** MEDIUM **Key Features:** - 🔍 Automatic pattern detection (Kind/, Priority -, type:) - 🗺️ Smart label mapping with fuzzy matching - ✨ Zero duplicate labels - 🎯 Respects your existing naming conventions - 📝 Generates `.ai-review.yml` config automatically
Latte added this to the Milestone 1: Core Features (Quick Wins) milestone 2025-12-28 17:47:07 +00:00
Latte added the Kind/Feature label 2025-12-28 17:47:07 +00:00
Latte self-assigned this 2025-12-28 17:47:07 +00:00
Latte added this to the Development Roadmap project 2025-12-28 17:47:07 +00:00
Latte added reference feature/auto-label-setup 2025-12-28 18:42:42 +00:00
Latte moved this to In Progress in Development Roadmap on 2025-12-28 18:50:11 +00:00
Latte closed this issue 2025-12-28 18:50:42 +00:00
Latte moved this to Done in Development Roadmap on 2025-12-28 18:50:50 +00:00
Sign in to join this conversation.
feature/auto-label-setup
Branches Tags
Labels
Clear labels
Compat/Breaking
Breaking change that won't be backward compatible
 Kind/Bug
Something is not working
 Kind/Documentation
Documentation changes
 Kind/Enhancement
Improve existing functionality
 Kind/Feature
New functionality
 Kind/Question
Further information is requested
 Kind/Security
This is security issue
 Kind/Testing
Issue or pull request related to testing
Priority
Critical
1
The priority is critical
Priority
High
2
The priority is high
Priority
Low
4
The priority is low
Priority
Medium
3
The priority is medium
Reviewed
Confirmed
1
Issue has been confirmed
Reviewed
Duplicate
2
This issue or pull request already exists
Reviewed
Invalid
3
Invalid issue
Reviewed
Won't Fix
3
This issue won't be fixed
Status
Abandoned
3
Somebody has started to work on this but abandoned work
Status/Ai Approved
AI review approved this PR
 Status/Ai Changes Required
AI review found issues requiring changes
Status
Blocked
1
Something is blocking this issue or pull request
Status
Need More Info
2
Feedback is required to reproduce issue or to continue work
Compat/Breaking
Breaking change that won't be backward compatible
 Kind/Bug
Something is not working
 Kind/Documentation
Documentation changes
 Kind/Enhancement
Improve existing functionality
 Kind/Feature
New functionality
 Kind/Security
This is security issue
 Kind/Testing
Issue or pull request related to testing
Priority
Critical
1
The priority is critical
Priority
High
2
The priority is high
Priority
Low
4
The priority is low
Priority
Medium
3
The priority is medium
Reviewed
Confirmed
1
Issue has been confirmed
Reviewed
Duplicate
2
This issue or pull request already exists
Reviewed
Invalid
3
Invalid issue
Reviewed
Won't Fix
3
This issue won't be fixed
Status
Abandoned
3
Somebody has started to work on this but abandoned work
Status
Blocked
1
Something is blocking this issue or pull request
Status
Need More Info
2
Feedback is required to reproduce issue or to continue work
No Label Kind/Feature
Milestone
No items
No Milestone Milestone 1: Core Features (Quick Wins)
Projects
Clear projects
No project Development Roadmap
Assignees
Clear assignees
Bartender Latte
No Assignees Latte
1 Participants
Notifications
Due Date
No due date set.
Dependencies

No dependencies set.

Reference: Hiddenden/openrabbit#6
Delete Branch "%!s()"

Deleting a branch is permanent. Although the deleted branch may continue to exist for a short time before it actually gets removed, it CANNOT be undone in most cases. Continue?