Skip to content

struktur-baru.md

Latest commit

 

History

History
412 lines (327 loc) · 16.4 KB

struktur-baru.md

File metadata and controls

412 lines (327 loc) · 16.4 KB
Raw

SEED Agent Company — Full Vibe Coding Prompt

Paste prompt ini langsung ke AI coding tool (Cursor, Windsurf, Claude, dll). Ini adalah one-shot prompt untuk generate seluruh sistem dari nol.

PROMPT

Buatkan saya sistem SEED Agent Company — sebuah autonomous AI company yang terdiri dari agent-agent Python yang bekerja secara pipeline untuk membangun software secara otomatis.

STRUKTUR FOLDER YANG HARUS DIBUAT

seed-agent-company/
├── brain/
│   ├── __init__.py
│   ├── llm_client.py
│   └── company/
│       ├── __init__.py
│       ├── agent_registry.py
│       ├── ceo.py
│       ├── reviewer.py
│       ├── researcher.py
│       ├── planner.py
│       ├── qa_tester.py
│       └── devops.py
├── memory/
│   └── .gitkeep
├── main.py
├── requirements.txt
└── README.md

FILE 1: brain/llm_client.py

Buat wrapper LLM client yang:

  • Punya class LLMClient dengan method completion(messages: list, request_type: str = "general") -> str
  • Support environment variable LLM_PROVIDER dengan nilai "openai" atau "groq" (default: "openai")
  • Support env var LLM_API_KEY dan LLM_MODEL (default model openai: gpt-4o-mini, groq: llama-3.3-70b-versatile)
  • Gunakan openai Python SDK untuk keduanya (Groq compatible dengan base_url https://api.groq.com/openai/v1)
  • Error handling dengan retry 1x jika timeout
  • Log setiap request: [LLM][{request_type}] Sending request...
  • Singleton instance llm = LLMClient() di akhir file

FILE 2: brain/company/agent_registry.py

Buat sistem registry terpusat dengan spesifikasi berikut:

Konstanta PRESET_AGENTS — dict berisi 6 preset agent:

{
    "researcher":  { pipeline_order: 1, trigger: "always",      module: "brain.company.researcher", class: "ResearcherAgent", instance: "researcher" },
    "planner":     { pipeline_order: 2, trigger: "always",      module: "brain.company.planner",    class: "PlannerAgent",    instance: "planner"    },
    "coder":       { pipeline_order: 3, trigger: "always",      module: None  # built-in di CEO                                                      },
    "reviewer":    { pipeline_order: 4, trigger: "always",      module: "brain.company.reviewer",   class: "ReviewerAgent",   instance: "reviewer"   },
    "qa_tester":   { pipeline_order: 5, trigger: "on_approval", module: "brain.company.qa_tester",  class: "QATesterAgent",   instance: "qa_tester"  },
    "devops":      { pipeline_order: 6, trigger: "on_qa_pass",  module: "brain.company.devops",     class: "DevOpsAgent",     instance: "devops"     },
}

Class AgentRegistry dengan methods:

  • __init__(registry_file="memory/agent_registry.json") — load dari disk atau init dengan semua preset agents langsung aktif
  • _load_registry() — jika file belum ada, buat fresh dengan semua preset aktif dan simpan ke disk
  • _save_registry() — simpan ke disk dengan update last_updated
  • get_active_agents() -> list[str] — return nama agen yang status == "active"
  • get_pipeline() -> list[dict] — return agen aktif sorted by pipeline_order
  • agent_exists(name) -> bool
  • activate_preset(name) -> bool — aktifkan preset dari PRESET_AGENTS
  • register_custom_agent(name, description, file_path, class_name, pipeline_order=99, trigger="always") -> bool
  • deactivate_agent(name) -> bool
  • increment_task_count(agent_name) — tambah counter tasks_completed
  • load_agent_instance(agent_name) — dynamic import:
    • Jika type == "preset" dan ada module: importlib.import_module(module) lalu getattr(module, instance_name)
    • Jika type == "custom" dan ada file_path: importlib.util.spec_from_file_location → load → instantiate class
    • Jika module is None dan file_path is None: return None (built-in, handled CEO)
  • print_roster() — print tabel semua agen dengan status, order, type, description

Singleton: agent_registry = AgentRegistry() di akhir file

FILE 3: brain/company/researcher.py

Class ResearcherAgent dengan:

  • research(project_name: str, task: dict) -> dict
  • Kirim prompt ke LLM meminta analisis teknikal task
  • Return JSON: { summary, approach, key_libraries: [], potential_risks: [], estimated_complexity: "low/medium/high" }
  • Jika LLM response gagal di-parse sebagai JSON, return fallback dict
  • Print: 🔬 Researcher: Meneliti task '{task["title"]}'...
  • Print hasil: 🔬 Researcher: Riset selesai. Kompleksitas: {estimated_complexity}

Singleton: researcher = ResearcherAgent()

FILE 4: brain/company/planner.py

Class PlannerAgent dengan:

  • plan(project_name: str, task: dict, research_context: dict = None) -> dict
  • Terima output researcher sebagai research_context, masukkan ke prompt jika ada
  • Return JSON: { architecture_overview, implementation_steps: [], file_structure: {}, key_interfaces: [], coding_guidelines: [] }
  • Print: 📐 Planner: Merancang arsitektur untuk '{task["title"]}'...
  • Print hasil: 📐 Planner: Blueprint selesai. {N} langkah implementasi.

Singleton: planner = PlannerAgent()

FILE 5: brain/company/reviewer.py

Class ReviewerAgent dengan:

  • review_code(task_description: str, code: str) -> dict
  • Kirim prompt ke LLM untuk review kode
  • Return JSON: { approved: bool, feedback: str, issues: [], suggestions: [] }
  • approved = True jika kode memenuhi standar production (error handling, docstrings, type hints, security)
  • Print: 🔍 Reviewer: Mereview kode...
  • Print hasil: 🔍 Reviewer: ✅ APPROVED atau 🔍 Reviewer: ❌ REJECTED — {feedback}

Singleton: reviewer = ReviewerAgent()

FILE 6: brain/company/qa_tester.py

Class QATesterAgent dengan:

  • test(task: dict, code: str, review_feedback: dict = None) -> dict
  • Generate test cases dan evaluasi kualitas kode
  • Return JSON: { passed: bool, quality_score: 0-100, test_cases: [{name, description, expected, status}], issues_found: [], recommendations: [], coverage_areas: [] }
  • passed = True jika quality_score >= 70 dan tidak ada critical issue
  • Print: 🧪 QA Tester: Menguji kode untuk '{task["title"]}'...
  • Print hasil: 🧪 QA Tester: ✅ LULUS atau ❌ GAGAL — Quality Score: {score}/100

Singleton: qa_tester = QATesterAgent()

FILE 7: brain/company/devops.py

Class DevOpsAgent dengan:

  • deploy(project_name: str, task: dict, code: str, qa_report: dict = None) -> dict
  • Generate deployment artifacts berdasarkan kode yang sudah lulus QA
  • Return JSON: { deployment_ready: bool, dockerfile_content: str, docker_compose_snippet: str, ci_cd_steps: [], environment_variables: {}, deployment_checklist: [{item, status}], rollback_strategy: str }
  • Simpan artifacts ke disk: memory/deployments/{project_name}/Dockerfile.{task_slug} dan deploy_summary_{task_slug}.json
  • Print: 🚀 DevOps: Mempersiapkan deployment untuk '{task["title"]}'...
  • Print hasil: 🚀 DevOps: ✅ SIAP DEPLOY atau ⚠️ BUTUH PERSIAPAN TAMBAHAN

Singleton: devops = DevOpsAgent()

FILE 8: brain/company/ceo.py — FILE TERPENTING

Class CEOAgent sebagai orchestrator utama. Ini detail lengkapnya:

__init__(project_file="memory/active_project.json")

  • Simpan self.project_file = Path(project_file)
  • self.registry = agent_registry (import dari agent_registry)

run_company() — Main loop

1. Print header "👔 CEO: Memulai siklus operasional SEED Agent Company"
2. Panggil self._reflect_and_recruit()
3. Panggil self.registry.print_roster()
4. Load active_project.json — jika tidak ada, print "Tidak ada proyek aktif" dan return
5. Jika status == "completed", print selesai dan return
6. Ambil task ke-idx dari tasks[]
7. Panggil self._run_pipeline(project_name, current_task)
8. Jika success: increment current_task_index, tandai task completed, save state
9. Jika gagal: simpan last_attempt timestamp, jangan advance index

_run_pipeline(project_name, task) -> bool

Pipeline dinamis — iterasi semua agen dari registry.get_pipeline():

Untuk setiap agent_info di pipeline:
  - Cek trigger:
    * "on_approval" → skip jika review_result belum approved
    * "on_qa_pass"  → skip jika context["qa_tester"].passed belum True
  - Panggil _execute_agent(agent_name, ...)
  - Simpan result ke context[agent_name]
  - Increment task count di registry
  
  Khusus agent "coder":
    - Simpan result ke variabel `code`
  
  Khusus agent "reviewer":
    - Jika REJECTED:
      1. Print feedback
      2. Re-run coder dengan task + reviewer_feedback di field tambahan
      3. Re-run reviewer dengan kode baru
      4. Jika masih rejected → return False
      
Return True jika seluruh pipeline selesai

_execute_agent(agent_name, agent_info, project_name, task, context, code) — Router

if agent_name == "coder":
    return self._execute_coder(project_name, task, context)
elif agent_name == "reviewer":
    return self._execute_reviewer(task, code)
elif agent_name == "researcher":
    instance = registry.load_agent_instance("researcher")
    return instance.research(project_name, task)
elif agent_name == "planner":
    instance = registry.load_agent_instance("planner")
    return instance.plan(project_name, task, context.get("researcher"))
elif agent_name == "qa_tester":
    instance = registry.load_agent_instance("qa_tester")
    return instance.test(task, code, context.get("reviewer"))
elif agent_name == "devops":
    instance = registry.load_agent_instance("devops")
    return instance.deploy(project_name, task, code, context.get("qa_tester"))
else:
    # Custom agent — panggil instance.run(project_name, task, context)
    # atau instance.execute(...) jika run tidak ada

_execute_coder(project_name, task, context) -> str

  • Build prompt yang menyertakan:
    • Output researcher (approach, key_libraries, potential_risks) jika ada di context
    • Output planner (architecture_overview, implementation_steps, coding_guidelines) jika ada di context
    • Field task["reviewer_feedback"] jika ada (untuk retry)
  • Requirements wajib di prompt: error handling, docstrings, type hints, modular, validasi input
  • Return raw string kode Python

_execute_reviewer(task, code) -> dict

  • Import reviewer dari brain.company.reviewer
  • Return reviewer.review_code(task["description"], code)
  • Jika error, return {"approved": False, "feedback": str(e)}

_reflect_and_recruit() — CEO evaluasi tim

Kirim prompt ke LLM dengan info:

  • List agen aktif saat ini
  • List preset agen yang belum aktif

LLM diminta return JSON:

{
  "evaluation": "Analisis singkat kondisi tim",
  "activate_presets": ["nama_preset_jika_perlu_diaktifkan"],
  "needs_custom_agent": true/false,
  "custom_agent_proposal": {
    "name": "snake_case_name",
    "description": "Fungsi agen",
    "pipeline_order": 7,
    "trigger": "always/on_approval/on_qa_pass",
    "class_name": "NamaClass",
    "capabilities": ["cap1", "cap2"]
  }
}
  • Jika activate_presets berisi nama → panggil registry.activate_preset(nama)
  • Jika needs_custom_agent == true → panggil _generate_custom_agent(proposal)

_generate_custom_agent(proposal: dict)

  1. Ekstrak: name, class_name, description, capabilities, pipeline_order, trigger
  2. Cek registry.agent_exists(name) — skip jika sudah ada
  3. Kirim prompt ke LLM untuk generate kode Python agent baru dengan contract:
    • Class bernama {class_name}
    • Method run(self, project_name: str, task: dict, context: dict) -> dict
    • Return minimal: {"success": bool, "output": any, "summary": str}
    • Import from brain.llm_client import llm
    • Production-ready: docstrings, error handling, type hints
    • Singleton di akhir: {name} = {class_name}()
  4. Sanitasi response: hapus markdown fence ```python dan ```
  5. Simpan ke brain/company/{name}.py
  6. Panggil registry.register_custom_agent(name, description, file_path, class_name, pipeline_order, trigger)

_save_state(state: dict) — Simpan JSON ke disk

get_company_status() -> dict — Return status perusahaan:

{
    "active_project": "nama — Task X/Y (status)",
    "total_agents": N,
    "pipeline": ["[01] researcher", "[02] planner", ...],
    "last_updated": "..."
}

Singleton: ceo = CEOAgent()

FILE 9: main.py

from brain.company.ceo import ceo
import json
from pathlib import Path

def create_sample_project():
    """Buat sample active_project.json jika belum ada."""
    project_file = Path("memory/active_project.json")
    if project_file.exists():
        return
    
    project = {
        "name": "TodoAPI",
        "description": "REST API sederhana untuk manajemen todo list",
        "status": "in_progress",
        "current_task_index": 0,
        "tasks": [
            {
                "title": "Setup project structure dan konfigurasi",
                "description": "Buat struktur folder FastAPI project, setup requirements.txt, konfigurasi environment variables, dan buat main.py entry point dengan health check endpoint.",
                "status": "pending"
            },
            {
                "title": "Buat database models dan connection",
                "description": "Setup SQLAlchemy dengan SQLite, buat model Todo (id, title, description, completed, created_at), dan fungsi get_db untuk dependency injection.",
                "status": "pending"
            },
            {
                "title": "Implementasi CRUD endpoints",
                "description": "Buat router todos dengan endpoints: GET /todos (list semua), POST /todos (create), GET /todos/{id}, PUT /todos/{id} (update), DELETE /todos/{id}. Gunakan Pydantic schemas untuk request/response validation.",
                "status": "pending"
            }
        ]
    }
    
    project_file.parent.mkdir(parents=True, exist_ok=True)
    with open(project_file, "w") as f:
        json.dump(project, f, indent=2)
    print("📁 Sample project 'TodoAPI' dibuat di memory/active_project.json")

if __name__ == "__main__":
    create_sample_project()
    ceo.run_company()
    
    # Print status perusahaan setelah run
    print("\n" + "="*60)
    status = ceo.get_company_status()
    print(f"📊 COMPANY STATUS")
    print(f"   Project  : {status['active_project']}")
    print(f"   Agents   : {status['total_agents']} aktif")
    print(f"   Pipeline : {' → '.join(a.split('] ')[1] for a in status['pipeline'])}")
    print("="*60)

FILE 10: requirements.txt

openai>=1.0.0
python-dotenv>=1.0.0

FILE 11: .env.example

LLM_PROVIDER=openai
LLM_API_KEY=your_api_key_here
LLM_MODEL=gpt-4o-mini

# Untuk Groq (gratis):
# LLM_PROVIDER=groq
# LLM_API_KEY=your_groq_key
# LLM_MODEL=llama-3.3-70b-versatile

FILE 12: README.md

Buat README yang menjelaskan:

  • Apa itu SEED Agent Company
  • Diagram pipeline: Researcher → Planner → Coder → Reviewer → QA Tester → DevOps
  • Cara setup (clone, pip install, copy .env.example, isi API key)
  • Cara run: python main.py
  • Cara menambah project baru: edit memory/active_project.json
  • Penjelasan singkat setiap agent
  • Cara CEO generate custom agent baru secara otomatis

ATURAN GLOBAL (WAJIB DIIKUTI)

  1. Semua file Python harus punya: docstring di level module, docstring di setiap class dan method, type hints di semua parameter dan return value, try-except di semua LLM calls

  2. Semua agent files wajib: import from brain.llm_client import llm, punya singleton instance di baris terakhir, JSON fallback jika LLM response tidak bisa di-parse

  3. brain/llm_client.py harus load .env via python-dotenv di __init__

  4. JSON parsing di semua agen: gunakan json.loads() dengan try-except, strip markdown fence sebelum parse: re.sub(r'```json\n?|```python\n?|```\n?', '', response).strip()

  5. Memory directory: semua file state disimpan di folder memory/, buat folder jika belum ada dengan Path.mkdir(parents=True, exist_ok=True)

  6. Custom agent interface: semua custom agent yang di-generate CEO harus punya method run(self, project_name: str, task: dict, context: dict) -> dict dengan return minimal {"success": bool, "output": any, "summary": str}

  7. Pipeline trigger logic:

    • "always" → selalu dieksekusi
    • "on_approval" → hanya jika context["reviewer"]["approved"] == True
    • "on_qa_pass" → hanya jika context["qa_tester"]["passed"] == True

  8. Jangan generate file test atau file tambahan yang tidak ada di struktur di atas

Generate semua file sekarang, lengkap dan production-ready.