Phase D: Packages - Complete Automation System

Overview

Phase D implements complete automation features using AI-powered labeling, commit-to-issue automation, and PR comment task automation. This phase eliminates manual labeling and task creation through intelligent automation.

Status

• Status: Complete
• Priority: High
• Duration: 4 hours
• Agent: CodeGenAgent

GitHub as OS Mapping

GitHub Packages → Package Registry / Storage
GitHub Actions → Automation Runtime
AI Labeling → Auto-classification System
Commit Automation → Task Generation Pipeline

Goals and Objectives

Primary Goals

1. Implement AI-powered auto-labeling with Claude
2. Create commit-to-issue automation workflow
3. Enable PR comment task automation
4. Achieve zero-learning-cost user experience
5. Eliminate manual labeling overhead

Success Metrics

• AI labeling accuracy > 80%
• Automatic issue creation success rate > 95%
• PR comment task creation < 5 seconds
• Zero manual labeling required
• Full automation pipeline functional

Implementation Details

1. AI Auto-Labeling with Claude

File: scripts/ai-label-issue.ts

Uses Claude AI to analyze Issue title and body, then suggests appropriate labels.

Label Categories

• Type: bug, feature, docs, refactor, test, architecture, deployment
• Priority: P0-Critical, P1-High, P2-Medium, P3-Low
• Phase: planning, implementation, testing, deployment, monitoring
• Agent: coordinator, codegen, review, issue, pr, deployment
• Special: security, cost-watch, learning, experiment, good-first-issue

Usage

npm run ai:label <owner> <repo> <issue-number>

# Example
npm run ai:label ShunsukeHayashi Autonomous-Operations 19

Implementation

import Anthropic from '@anthropic-ai/sdk';
import { Octokit } from '@octokit/rest';

async function aiLabelIssue(
  owner: string,
  repo: string,
  issueNumber: number
): Promise<void> {
  const octokit = new Octokit({ auth: process.env.GITHUB_TOKEN });
  const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });

  // Fetch issue
  const { data: issue } = await octokit.rest.issues.get({
    owner,
    repo,
    issue_number: issueNumber,
  });

  console.log(`🔍 Analyzing Issue #${issueNumber}...`);
  console.log(`📝 Title: ${issue.title}`);

  // AI analysis
  const prompt = `
Analyze this GitHub Issue and suggest appropriate labels.

Title: ${issue.title}
Body: ${issue.body}

Available labels:
- Type: bug, feature, docs, refactor, test, architecture, deployment
- Priority: P0-Critical, P1-High, P2-Medium, P3-Low
- Phase: planning, implementation, testing, deployment, monitoring
- Agent: coordinator, codegen, review, issue, pr, deployment
- Special: security, cost-watch, learning, experiment, good-first-issue

Respond with:
1. Suggested labels (one from each category if applicable)
2. Brief reasoning for each label

Format as JSON.
  `;

  const response = await anthropic.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 1024,
    messages: [{ role: 'user', content: prompt }],
  });

  const analysis = JSON.parse(response.content[0].text);

  console.log('🤖 Consulting Claude AI...\n');
  console.log('📊 AI Suggestion:');
  console.log(`  Type: ${analysis.labels.type}`);
  console.log(`  Priority: ${analysis.labels.priority}`);
  console.log(`  Phase: ${analysis.labels.phase}`);
  console.log(`  Agent: ${analysis.labels.agent}`);
  if (analysis.labels.special) {
    console.log(`  Special: ${analysis.labels.special}`);
  }
  console.log(`\n💡 Reasoning: ${analysis.reasoning}`);

  // Apply labels
  const labels = Object.values(analysis.labels).filter(Boolean);

  await octokit.rest.issues.addLabels({
    owner,
    repo,
    issue_number: issueNumber,
    labels,
  });

  console.log(`\n✅ Applied ${labels.length} labels to Issue #${issueNumber}`);

  // Add analysis comment
  await octokit.rest.issues.createComment({
    owner,
    repo,
    issue_number: issueNumber,
    body: `
## 🤖 AI Analysis

**Suggested Labels:**
${labels.map((l) => `- \`${l}\``).join('\n')}

**Reasoning:**
${analysis.reasoning}

*Analyzed by Claude Sonnet 4*
    `,
  });

  console.log(`✅ Added analysis comment to Issue #${issueNumber}`);
}

Workflow

File: .github/workflows/ai-auto-label.yml

name: AI Auto-Label

on:
  issues:
    types: [opened]

jobs:
  label:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - uses: actions/setup-node@v4
        with:
          node-version: '20'

      - name: Install dependencies
        run: npm install

      - name: AI Label Issue
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          npm run ai:label ${{ github.repository_owner }} ${{ github.event.repository.name }} ${{ github.event.issue.number }}

2. Commit to Issue Automation

File: .github/workflows/commit-to-issue.yml

Automatically creates Issues from commit messages containing #auto.

Syntax

git commit -m "feat: Add dark mode toggle #auto"
# → Creates Issue: "Add dark mode toggle" with type:feature label

git commit -m "fix: Resolve login redirect loop #auto"
# → Creates Issue: "Resolve login redirect loop" with type:bug label

git commit -m "docs: Update API documentation #auto"
# → Creates Issue: "Update API documentation" with type:docs label

Auto-detected Types

• feat: → type:feature
• fix: → type:bug
• docs: → type:docs
• refactor: → type:refactor
• test: → type:test

Workflow Implementation

name: Commit to Issue

on:
  push:
    branches:
      - main
      - 'feat/**'
      - 'fix/**'
      - 'docs/**'

jobs:
  create-issue:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 2

      - name: Check for #auto tag
        id: check
        run: |
          COMMIT_MSG=$(git log -1 --pretty=%B)
          if echo "$COMMIT_MSG" | grep -q "#auto"; then
            echo "has_auto=true" >> $GITHUB_OUTPUT
            echo "commit_msg=$COMMIT_MSG" >> $GITHUB_OUTPUT
          else
            echo "has_auto=false" >> $GITHUB_OUTPUT
          fi

      - name: Create Issue
        if: steps.check.outputs.has_auto == 'true'
        uses: actions/github-script@v7
        with:
          script: |
            const commitMsg = '${{ steps.check.outputs.commit_msg }}';

            // Extract type and title
            const match = commitMsg.match(/^(\w+):\s*(.+?)\s*#auto/);
            if (!match) return;

            const [, type, title] = match;

            // Determine labels
            const typeMap = {
              feat: 'type:feature',
              fix: 'type:bug',
              docs: 'type:docs',
              refactor: 'type:refactor',
              test: 'type:test',
            };

            const labels = [typeMap[type] || 'type:feature'];

            // Create issue
            const { data: issue } = await github.rest.issues.create({
              ...context.repo,
              title,
              body: `
## Auto-created from commit

**Commit**: ${context.sha}
**Branch**: ${context.ref}
**Message**: ${commitMsg}

This issue was automatically created from a commit with the \`#auto\` tag.
              `,
              labels,
            });

            console.log(`Created Issue #${issue.number}`);

3. PR Comment Task Automation

File: .github/workflows/pr-comment-task.yml

Creates Issues from PR comments mentioning @agentic-os.

Syntax

@agentic-os fix the login bug
→ Creates Issue with bug label

@agentic-os test this component
→ Creates Issue with test label

@agentic-os document this API
→ Creates Issue with docs label

Supported Commands

• fix → Creates bug fix task
• test → Creates testing task
• document/doc → Creates documentation task
• refactor → Creates refactoring task
• coverage → Creates test coverage task
• Anything else → Creates generic feature task

Workflow Implementation

name: PR Comment Task

on:
  issue_comment:
    types: [created]

jobs:
  create-task:
    if: |
      github.event.issue.pull_request &&
      contains(github.event.comment.body, '@agentic-os')
    runs-on: ubuntu-latest
    steps:
      - uses: actions/github-script@v7
        with:
          script: |
            const comment = context.payload.comment.body;
            const match = comment.match(/@agentic-os\s+(.+)/);

            if (!match) return;

            const task = match[1].trim();

            // Determine type and labels
            let type = 'type:feature';
            if (task.includes('fix')) type = 'type:bug';
            else if (task.includes('test')) type = 'type:test';
            else if (task.includes('doc')) type = 'type:docs';
            else if (task.includes('refactor')) type = 'type:refactor';

            // Create issue
            const { data: issue } = await github.rest.issues.create({
              ...context.repo,
              title: task,
              body: `
## Task from PR Comment

**PR**: #${context.issue.number}
**Requested by**: @${context.payload.comment.user.login}
**Comment**: ${context.payload.comment.html_url}

Task description: ${task}
              `,
              labels: [type, 'priority:P2-Medium'],
            });

            // Reply to comment
            await github.rest.issues.createComment({
              ...context.repo,
              issue_number: context.issue.number,
              body: `✅ Created Issue #${issue.number} for this task.`,
            });

            console.log(`Created Issue #${issue.number} from PR comment`);

Completion Criteria and KPIs

Acceptance Criteria

Key Performance Indicators

Testing Methodology

Test AI Labeling

# Set up environment
export GITHUB_TOKEN=ghp_your_token
export ANTHROPIC_API_KEY=sk_your_key

# Test on Issue #19
npm run ai:label ShunsukeHayashi Autonomous-Operations 19

Expected Output:

🔍 Analyzing Issue #19...
📝 Title: Issue #19: Zero-Learning-Cost Framework
🤖 Consulting Claude AI...

📊 AI Suggestion:
  Type: type:feature
  Priority: priority:P1-High
  Phase: phase:planning
  Agent: agent:coordinator
  Special: special:security

💡 Reasoning: This is a major architectural feature...

✅ Applied 6 labels to Issue #19
✅ Added analysis comment to Issue #19

Test Commit → Issue

# Create test commit
git commit -m "feat: Add example feature #auto"
git push origin main

# Check GitHub Actions
# Should create Issue automatically

Test PR Comment → Task

# 1. Open any PR
# 2. Add comment:
@agentic-os test this new component

# 3. Check:
# - Issue created
# - Comment added to PR with Issue link

Troubleshooting Guide

Issue: AI Labeling Not Working

Symptom: Issues created but not labeled

Solutions:

1. Check ANTHROPIC_API_KEY in repository secrets
2. Verify workflow is enabled
3. Check GitHub Actions logs
4. Test locally: npm run ai:label ...

Issue: Commit #auto Not Creating Issues

Symptom: Commits with #auto pushed but no issues

Solutions:

1. Verify workflow triggers on your branch
2. Check commit message format
3. Review GitHub Actions logs
4. Ensure workflow file is correct

Issue: PR Comment Not Creating Tasks

Symptom: @agentic-os mentioned but no issue

Solutions:

1. Ensure comment is on a PR (not issue)
2. Check @agentic-os spelling
3. Verify workflow has issue:write permission
4. Review GitHub Actions logs

Configuration Reference

Environment Variables

# Required
GITHUB_TOKEN=ghp_xxxxx           # GitHub token
ANTHROPIC_API_KEY=sk-ant-xxxxx   # Claude API key

# Optional
AI_MODEL=claude-sonnet-4-20250514  # AI model to use
MAX_TOKENS=1024                    # Max AI response tokens

Setup Steps

# 1. Add ANTHROPIC_API_KEY to GitHub
# Repository → Settings → Secrets and variables → Actions
# → New repository secret
# Name: ANTHROPIC_API_KEY
# Value: sk-ant-your-key-here

# 2. Test AI labeling manually
npm run ai:label owner repo issue-number

# 3. Test commit automation
git commit -m "test: Automation test #auto"
git push

# 4. Test PR automation
# - Open any PR
# - Comment: @agentic-os test feature

Next Phase Transition

Impact on Development Workflow

Before Phase D:

• Users manually add labels
• Users manually create Issues for follow-up tasks
• Manual tracking needed

After Phase D:

• AI automatically labels new Issues
• Commits with #auto create Issues
• PR comments with @agentic-os create tasks
• Zero manual intervention needed

Integration with Phase A (Projects V2)

Auto-created issues automatically added to Projects:

# After issue creation in workflow
- name: Add to Project
  run: npx tsx scripts/add-to-project.ts ${{ steps.create.outputs.issue_number }}

References and Resources

Official Documentation

• Claude API Documentation
• GitHub Actions Documentation
• Octokit REST API

Internal Documentation

• Issue #19: Zero-Learning-Cost Framework
• Phase 1-3: CLI Package Foundation
• Phase 5: Testing & Validation

Credits

Implemented by: CodeGenAgent Issue: #19 Model: Claude Sonnet 4 Date: 2025-10-08 Duration: 4 hours

Status: ✅ Complete Next Phase: Phase E - Dashboard