# GEMINI.md

You are operating in Plan Mode. Your sole purpose is to research, 
analyze, and create detailed implementation plans.

## Core Principles
- Strictly Read-Only: Inspect files, navigate code, search the web
- No Modifications: Do not edit, create, or delete files
- No Commands: Do not run shell commands that make changes

## Steps
1. Acknowledge and analyze the user's request
2. Output your reasoning before the plan
3. Create a detailed, step-by-step implementation plan
4. Present for approval before any execution

# Resume most recent session
codex resume --last

# Resume specific session
codex resume <SESSION_ID>

# Resume with new instructions
codex exec resume --last "Implement the plan"

from praisonaiagents import Agent

def search_web(query: str) -> str:
    return f"Search results for: {query}"

agent = Agent(
    name="AI Assistant",
    instructions="Research and write about topics",
    planning=True,              # Enable planning mode
    planning_tools=[search_web], # Tools for planning research
    planning_reasoning=True      # Chain-of-thought reasoning
)

result = agent.start("Research AI trends in 2025 and write a summary")

from praisonaiagents import Agent, Task, PraisonAIAgents

researcher = Agent(name="Researcher", role="Research Analyst")
writer = Agent(name="Writer", role="Content Writer")

research_task = Task(description="Research AI benefits", agent=researcher)
write_task = Task(description="Write summary", agent=writer)

# Enable planning mode
agents = PraisonAIAgents(
    agents=[researcher, writer],
    tasks=[research_task, write_task],
    planning=True,              # Enable planning
    planning_tools=[search_web], # Tools for planning research
    planning_reasoning=True,     # Chain-of-thought reasoning
    auto_approve_plan=True       # Auto-approve plans
)

result = agents.start()

from praisonaiagents import Agent
from praisonaiagents.planning import PlanningAgent, Plan, PlanStep, TodoList

# Create a planning agent
planner = PlanningAgent(
    llm="gpt-4o-mini",
    read_only=True,  # Only read-only tools allowed
    verbose=1
)

# Create agents
researcher = Agent(name="Researcher", role="Research Analyst")
writer = Agent(name="Writer", role="Content Writer")

# Create a plan
plan = planner.create_plan_sync(
    request="Write an article about meditation benefits",
    agents=[researcher, writer],
    context="Keep it concise"
)

# Display the plan
print(plan.to_markdown())

# Create todo list from plan
todo_list = TodoList.from_plan(plan)
print(todo_list.to_markdown())

# Execute each todo item
for item in todo_list.items:
    todo_list.start(item.id)
    
    # Get appropriate agent
    agent = researcher if item.agent == "Researcher" else writer
    result = agent.chat(item.description)
    
    todo_list.complete(item.id)
    print(f"Progress: {todo_list.progress * 100:.0f}%")

from praisonaiagents import Agent

# Agent in plan_mode can only use read-only tools
agent = Agent(
    name="Researcher",
    role="Research Analyst",
    plan_mode=True  # Restricts to read-only tools
)

# Only safe tools available: read_file, list_directory, search, etc.
# Blocked: write_file, execute_command, delete_file, etc.

from praisonaiagents.planning import PlanStorage, Plan, PlanStep

storage = PlanStorage()  # Uses .praison/ by default

# Save a plan
plan = Plan(
    name="Feature Implementation",
    description="Add user authentication",
    steps=[
        PlanStep(description="Research auth patterns", agent="Researcher"),
        PlanStep(description="Implement auth", agent="Developer", dependencies=["step_0"]),
        PlanStep(description="Write tests", agent="Tester", dependencies=["step_1"])
    ]
)
storage.save_plan(plan)

# Load a plan
loaded = storage.load_plan(plan.id)

# List all plans
plans = storage.list_plans()

---
id: abc123
name: Feature Implementation
status: approved
created_at: '2024-01-15T10:00:00Z'
approved_at: '2024-01-15T10:05:00Z'
---

# Feature Implementation

Add user authentication to the application.

## Steps

1. ⬜ Research existing auth patterns
   - Agent: Researcher
   - Tools: read_file, search_codebase

2. ⬜ Implement authentication
   - Agent: Developer
   - Depends on: step_0

3. ⬜ Write comprehensive tests
   - Agent: Tester
   - Depends on: step_1

from praisonaiagents.planning import ApprovalCallback, Plan

# Auto-approve all plans
callback = ApprovalCallback(auto_approve=True)

# Custom approval logic
def my_approval(plan):
    # Only approve plans with less than 5 steps
    return len(plan.steps) <= 5

callback = ApprovalCallback(approve_fn=my_approval)

# Interactive console approval
callback = ApprovalCallback(approve_fn=ApprovalCallback.console_approval)

from praisonaiagents import Agent, Task
from praisonaiagents.planning import PlanningAgent, TodoList

def main():
    # Create agents
    researcher = Agent(name="Researcher", role="Research Analyst", verbose=True)
    writer = Agent(name="Writer", role="Content Writer", verbose=True)
    
    # Create plan
    planner = PlanningAgent(llm="gpt-4o-mini")
    plan = planner.create_plan_sync(
        request="Write about AI in healthcare",
        agents=[researcher, writer]
    )
    
    print("📋 Plan Created:")
    print(plan.to_markdown())
    
    # Create todo list
    todo = TodoList.from_plan(plan)
    
    # Execute each item
    agent_map = {"Researcher": researcher, "Writer": writer}
    
    for item in todo.items:
        print(f"\n⏳ Executing: {item.description}")
        todo.start(item.id)
        
        agent = agent_map.get(item.agent, researcher)
        result = agent.chat(item.description)
        
        todo.complete(item.id)
        print(f"✅ Done! Progress: {todo.progress * 100:.0f}%")
    
    print("\n🎉 All tasks completed!")

if __name__ == "__main__":
    main()