LLMs - Configuration Management System

Centralized LLM configuration and documentation management system. Tools for building skills, commands, agents, prompts, and managing MCP servers. Multi-LLM support (Claude Code, Codex, OpenCode).

---

🎯 Vision

Build a unified system for managing LLM configurations, documentation, and tooling across multiple LLM providers (Claude Code, Codex, OpenCode, etc.). Enable developers to:

• Fetch and maintain up-to-date documentation from LLM providers
• Build and manage skills, commands, agents, and prompts
• Package and distribute plugins for team sharing
• Manage MCPs (Model Context Protocol servers)
• Work across LLMs with a single toolset

---

✨ Features

Current (Sprint 1-4: Claude Code Focus)

• ✅ Documentation Fetcher: Automatically fetch and update docs from Anthropic, OpenAI, etc.
• ✅ Scope Intelligence: Auto-detect global/project/local configurations
• ✅ Skill Builder: Generate Claude Code skills with templates
• ✅ Command Builder: Create slash commands for automation
• ✅ Agent Builder: Build sub-agents for specialized tasks
• ✅ Prompt Builder: Generate and validate master prompts
• ✅ Plugin Builder: Package skills/commands/agents for distribution
• ✅ MCP Manager: Manage Model Context Protocol servers
• ✅ Hook Builder: Create hook configurations

Future (Sprint 5+: Multi-LLM)

• 🔮 Codex Support: Adapt tools for OpenAI Codex
• 🔮 OpenCode Support: Extend to OpenCode
• 🔮 Universal Format: LLM-agnostic configuration format
• 🔮 RAG Integration: Personal documentation knowledge base

---

🤖 Feature-Implementer v2 Architecture

Status: ✅ Production Ready (v1.0.0)

The Feature-Implementer v2 is a sophisticated multi-agent system that orchestrates the complete software development lifecycle from requirements analysis to deployment. Built with 14 specialized agents, 37 production skills, and intelligent hooks, it provides a structured, automated approach to implementing features from GitHub issues.

Architecture Overview

┌─────────────────────────────────────────────────────────────┐
│              FEATURE-IMPLEMENTER (Main Agent)               │
│                  6-Phase Orchestration                      │
└─────────────────────────────────────────────────────────────┘
           │                                       │
    ┌──────┴──────┐                        ┌──────┴──────┐
    │   PHASE 1   │                        │   PHASE 2   │
    │  ANALYSIS   │                        │   DESIGN    │
    └──────┬──────┘                        └──────┬──────┘
           │                                       │
    @analysis-specialist               @design-orchestrator
    ├─ requirements-extractor           ├─ @architecture-designer
    ├─ security-assessor                │  ├─ architecture-planner
    └─ tech-stack-evaluator             │  ├─ data-modeler
                                         │  └─ api-designer
                                         ├─ @documentation-researcher
                                         │  ├─ doc-fetcher
                                         │  └─ doc-analyzer
                                         └─ @dependency-manager
                                            ├─ dependency-analyzer
                                            └─ version-checker

    ┌──────┬──────┐    ┌──────────┬─────────┐    ┌──────┬──────┐
    │ PHASE 3-4   │    │  PHASE 5         │    │  PHASE 6    │
    │ APPROVAL &  │    │  VALIDATION      │    │  DEPLOYMENT │
    │ IMPLEMENT   │    └──────────┬───────┘    └──────┬──────┘
    └─────────────┘               │                    │
    feature-implementer    @validation-orchestrator    @deployment-specialist
    ├─ analysis-skill     ├─ @unit-test-specialist    ├─ documentation-updater
    ├─ design-skill       ├─ @integration-test        ├─ changelog-generator
    └─ implementation     ├─ @test-runner             └─ pr-creator
       - TDD approach     ├─ @code-quality
       - Code review      ├─ @security-specialist
       - Best practices   └─ @e2e-accessibility (frontend)

Six-Phase Workflow

1. Phase 1: Requirements Analysis (@analysis-specialist)

   • Extract requirements from GitHub issues
   • Security assessment (OWASP, data privacy)
   • Tech stack evaluation
   • Output: docs/implementation/analysis/analysis.md

2. Phase 2: Architecture & Design (@design-orchestrator)

   • Parallel sub-agents:
     • Architecture design (components, data models, APIs)
     • Documentation research (fetch latest library docs)
     • Dependency management (compatibility, versions)
   • Design synthesis and validation
   • Output: docs/implementation/prp/prp.md (Problem-Requirements-Plan)

3. Phase 3: User Approval

   • Present analysis and design to user
   • Gather feedback and approval
   • Iterate if needed

4. Phase 4: Implementation (Main agent)

   • Test-Driven Development (TDD)
   • Code according to project standards
   • Follow best practices and patterns
   • Maintain ≤500 lines per file
   • Output: Working code with initial tests

5. Phase 5: Validation (@validation-orchestrator)

   • Sequential specialists (with recursive communication):
     • Unit tests (@unit-test-specialist)
     • Integration tests (@integration-test-specialist)
     • Test execution & coverage (@test-runner-specialist)
     • Code quality checks (@code-quality-specialist)
     • Security scanning (@security-specialist)
     • E2E & accessibility testing (@e2e-accessibility-specialist, frontend only)
   • Recursive loop if validation fails
   • Output: Validation reports, test results, security scan

6. Phase 6: Deployment (@deployment-specialist)

   • Update documentation (README, guides, API docs)
   • Generate CHANGELOG entry
   • Create pull request
   • Output: PR ready for review

All 14 Agents

Agent	Role	Model	Auto-Activated Skills
feature-implementer	Main orchestrator	Sonnet	analysis, design, implementation, validation
analysis-specialist	Requirements analysis	Haiku	requirements-extractor, security-assessor, tech-stack-evaluator
design-orchestrator	Design coordination	Sonnet	design-synthesizer, prp-generator
architecture-designer	Component architecture	Opus + ultrathink	architecture-planner, data-modeler, api-designer
documentation-researcher	Library docs	Haiku + context7	doc-fetcher, doc-analyzer
dependency-manager	Dependency analysis	Haiku	dependency-analyzer, version-checker
validation-orchestrator	Validation coordination	Sonnet	validation-coordinator, recursive-communicator
unit-test-specialist	Unit testing	Haiku	unit-test-writer, pytest-generator, jest-generator
integration-test-specialist	Integration testing	Haiku	integration-test-writer, api-test-generator
test-runner-specialist	Test execution	Haiku	test-executor, coverage-analyzer
code-quality-specialist	Linting & formatting	Haiku	python-quality-checker, typescript-quality-checker, rust-quality-checker
security-specialist	Security scanning	Sonnet	security-scanner, vulnerability-assessor, owasp-checker
e2e-accessibility-specialist	E2E & WCAG 2.1 AA	Sonnet + playwright	e2e-test-writer, accessibility-checker
deployment-specialist	Documentation & PR	Haiku	documentation-updater, changelog-generator, pr-creator

Production Skills (37)

Core Workflow Skills (4):

• analysis/ - Requirements analysis guidance
• design/ - Architecture and API design
• implementation/ - TDD implementation with code standards
• validation/ - Quality validation workflow

Specialized Skills (33) mapped to agents:

• Analysis: requirements-extractor, security-assessor, tech-stack-evaluator
• Design: design-synthesizer, prp-generator, architecture-planner, data-modeler, api-designer
• Documentation: doc-fetcher, doc-analyzer
• Dependencies: dependency-analyzer, version-checker
• Validation: validation-coordinator, recursive-communicator
• Testing: unit-test-writer, pytest-generator, jest-generator, integration-test-writer, api-test-generator, test-executor, coverage-analyzer
• Quality: python-quality-checker, typescript-quality-checker, rust-quality-checker
• Security: security-scanner, vulnerability-assessor, owasp-checker
• E2E: e2e-test-writer, accessibility-checker
• Deployment: documentation-updater, changelog-generator, pr-creator
• On-demand: code-reviewer, test-generator

Hooks Configuration

Pre-commit Hook (.claude/hooks/pre-commit.py):

• Triggers on git commit commands
• Runs: Black → Flake8 → Mypy → Pytest
• Blocking: Exit code 2 prevents commits if checks fail
• 180-second timeout

Post-implementation Hook (.claude/hooks/post-implementation.py):

• Triggers on implementation phase completion
• Detects completion markers in transcript
• Auto-triggers validation workflow
• Non-blocking: Continues normal conversation flow
• 60-second timeout

Usage

# Implement a feature from GitHub issue
@feature-implementer implement issue #123

# The agent will:
# 1. Analyze requirements (Phase 1)
# 2. Design architecture (Phase 2)
# 3. Present design for approval (Phase 3)
# 4. Implement with TDD (Phase 4)
# 5. Validate with specialists (Phase 5)
# 6. Create PR and update docs (Phase 6)

Quality Standards

• Test Coverage: ≥80% required
• Code Quality: Black, Flake8, Mypy must pass
• Security: OWASP Top 10 compliance
• File Size: ≤500 lines per file
• Accessibility: WCAG 2.1 AA (f