PLANNING & TASK DECOMPOSITION:
COMPLEX TASKS KO SIMPLE STEPS MEIN TODNA.

# Task decomposition
class Planner:
 def __init__(self):
 self.tasks = []
 
 def decompose(self, main_task):
 # Simple decomposition
 subtasks = [
 {"step": 1, "task": f"Analyze: {main_task}", "status": "pending"},
 {"step": 2, "task": "Gather information", "status": "pending"},
 {"step": 3, "task": "Execute plan", "status": "pending"},
 {"step": 4, "task": "Verify results", "status": "pending"}
 ]
 self.tasks = subtasks
 return subtasks
 
 def execute_next(self):
 for task in self.tasks:
 if task["status"] == "pending":
 task["status"] = "done"
 return task
 return None
 
 def get_progress(self):
 done = sum(1 for t in self.tasks if t["status"] == "done")
 return f"{done}/{len(self.tasks)} tasks complete"

planner = Planner()
print(planner.decompose("Build a chatbot"))
print(planner.execute_next())
print(planner.get_progress())

# Chain of Thought reasoning
class ChainOfThought:
 def __init__(self):
 self.steps = []
 
 def think(self, problem):
 # Break problem into reasoning steps
 self.steps = [
 f"Problem: {problem}",
 "Step 1: What do we know?",
 "Step 2: What do we need to find?",
 "Step 3: Apply relevant concepts",
 "Step 4: Calculate/derive answer",
 "Step 5: Verify the answer"
 ]
 return self.steps
 
 def show_reasoning(self):
 print("=== Chain of Thought ===")
 for i, step in enumerate(self.steps):
 print(f" {i+1}. {step}")

# Usage
cot = ChainOfThought()
print(cot.think("Calculate 15% tip on $80 bill"))
cot.show_reasoning()

# Tree of Thoughts - Multiple paths
class TreeOfThoughts:
 def __init__(self):
 self.paths = []
 
 def explore(self, problem):
 # Generate multiple thought paths
 self.paths = [
 {"path": "A", "thought": f"Direct approach for: {problem}", "score": 0.7},
 {"path": "B", "thought": f"Alternative approach for: {problem}", "score": 0.9},
 {"path": "C", "thought": f"Creative approach for: {problem}", "score": 0.6}
 ]
 return self.paths
 
 def evaluate(self):
 # Score each path and pick best
 best = max(self.paths, key=lambda x: x["score"])
 return best
 
 def show_tree(self):
 print("=== Thought Tree ===")
 for p in self.paths:
 marker = "?" if p == self.evaluate() else " "
 print(f" {marker} Path {p['path']}: {p['thought']} (score: {p['score']})")

# Usage
tot = TreeOfThoughts()
print(tot.explore("How to improve code quality"))
tot.show_tree()
print(f"\nBest path: {tot.evaluate()['path']}")

# Self-critique pattern
class SelfCritic:
 def __init__(self):
 self.criteria = []
 
 def set_criteria(self, criteria_list):
 self.criteria = criteria_list
 
 def critique(self, work):
 # Evaluate work against criteria
 results = []
 for criterion in self.criteria:
 score = self._evaluate(work, criterion)
 results.append({
 "criterion": criterion,
 "score": score,
 "feedback": self._get_feedback(score)
 })
 return results
 
 def _evaluate(self, work, criterion):
 # Simple scoring (in real use, LLM would evaluate)
 import random
 return random.uniform(0.5, 1.0)
 
 def _get_feedback(self, score):
 if score > 0.8: return "Excellent"
 elif score > 0.6: return "Good, but room for improvement"
 else: return "Needs significant work"
 
 def summary(self, results):
 avg_score = sum(r["score"] for r in results) / len(results)
 return f"Average quality: {avg_score:.2f}/1.0"

# Usage
critic = SelfCritic()
critic.set_criteria(["Clarity", "Completeness", "Correctness"])
work = "My code solution for the problem"
results = critic.critique(work)
for r in results:
 print(f" {r['criterion']}: {r['score']:.2f} - {r['feedback']}")
print(critic.summary(results))

# Complete planning agent
class PlanningAgent:
 def __init__(self):
 self.planner = Planner()
 self.critic = SelfCritic()
 
 def solve(self, task):
 print(f"Task: {task}")
 
 # Step 1: Decompose
 print("\n1. Decomposing task...")
 subtasks = self.planner.decompose(task)
 for t in subtasks:
 print(f" - {t['task']}")
 
 # Step 2: Execute each step
 print("\n2. Executing steps...")
 while True:
 next_task = self.planner.execute_next()
 if not next_task:
 break
 print(f" Done: {next_task['task']}")
 
 # Step 3: Self-critique
 print("\n3. Self-evaluation...")
 self.critic.set_criteria(["Completeness", "Quality", "Efficiency"])
 results = self.critic.critique("completed task")
 for r in results:
 print(f" {r['criterion']}: {r['score']:.2f}")
 
 # Progress
 print(f"\nProgress: {self.planner.get_progress()}")
 return "Task completed successfully!"

# Use it
agent = PlanningAgent()
agent.solve("Build a recommendation system")