Update core/planner.py

core/planner.py

@@ -1,70 +1,58 @@
+import os
+import re
 import json
 import logging
-import re
-from dataclasses import dataclass, field
-from typing import Optional
+from typing import List, Dict, Any
 from models.router import ModelRouter
 
-log = logging.getLogger("planner")
-
-PLAN_SYSTEM = """You are an expert software architect. Break down a coding task into concrete steps.
-Output ONLY a JSON array of steps. Each step object must have:
-- "id": number (1, 2, 3...)
-- "title": short title (max 8 words)
-- "type": one of: plan, code, test, debug, fix, review, shell
-- "description": clear explanation of what to do
-- "files": list of files to create/modify
-- "needs_input": true if you need info from owner
-- "input_question": question string if needs_input is true
-
-Output ONLY the JSON array. No markdown, no explanations."""
-
-
-@dataclass
-class TaskStep:
-    id: int
-    title: str
-    type: str
-    description: str
-    files: list[str] = field(default_factory=list)
-    needs_input: bool = False
-    input_question: Optional[str] = None
-    status: str = "pending"
-    result: Optional[str] = None
-    error: Optional[str] = None
-
-
-@dataclass
-class TaskPlan:
-    task: str
-    steps: list[TaskStep]
-    project_dir: str
-
+log = logging.getLogger("core")
 
 class TaskPlanner:
-    def __init__(self, model_router: ModelRouter):
-        self.router = model_router
-
-    async def create_plan(self, task: str, project_dir: str) -> TaskPlan:
-        log.info(f"Creating plan for: {task[:80]}")
-        prompt = f"Task: {task}\nProject Directory: {project_dir}"
-
-        raw = await self.router.call(
-            prompt=prompt, task_type="plan", system=PLAN_SYSTEM, estimated_tokens=1200
+    def __init__(self, router: ModelRouter):
+        self.router = router
+
+    async def generate_plan(self, task_description: str) -> List[Dict[str, Any]]:
+        system_prompt = (
+            "You are an expert software architect. Break down the user request into a strict sequential "
+            "execution plan. Respond ONLY with a valid JSON array of step objects. Do not wrap in markdown tags.\n"
+            "Each step object must have:\n"
+            "- step_id: integer\n"
+            "- task_type: text (one of: 'code', 'debug', 'review', 'explain', 'fix', 'test', 'generic')\n"
+            "- target_file: text (the path to the file being touched)\n"
+            "- instruction: text (detailed objective for this step)\n"
+            "Example format:\n"
+            '[{"step_id": 1, "task_type": "code", "target_file": "math.py", "instruction": "Write sum function"}]'
         )
 
-        steps = self._parse_steps(raw)
-        return TaskPlan(task=task, steps=steps, project_dir=project_dir)
-
-    def _parse_steps(self, raw: str) -> list[TaskStep]:
-        clean = re.sub(r"
-http://googleusercontent.com/immersive_entry_chip/0
-
----
+        user_prompt = f"Task Description: {task_description}"
+        
+        raw_response = await self.router.call(
+            prompt=user_prompt,
+            task_type="plan",
+            system=system_prompt,
+            estimated_tokens=1000
+        )
 
-## 🛠️ Execution Checklist
-1. Save and update these configuration values inside your Hugging Face Space **Variables and Secrets** settings panel:
-   * `TELEGRAM_BOT_TOKEN`, `TELEGRAM_OWNER_ID`
-   * `GROQ_API_KEY`, `GEMINI_API_KEY`
-   * `GITHUB_TOKEN`, `GITHUB_REPO`
-2. Save and commit your files. Hugging Face will automatically boot your Docker container, open the required listening port, and connect straight to Telegram!
+        return self._parse_json_plan(raw_response)
+
+    def _parse_json_plan(self, text: str) -> List[Dict[str, Any]]:
+        # TO'G'RILANDI: regex qatorlari yopildi va xatolik bartaraf etildi
+        clean = re.sub(r"```json\s*", "", text, flags=re.IGNORECASE)
+        clean = re.sub(r"```\s*$", "", clean, flags=re.IGNORECASE)
+        clean = clean.strip()
+
+        try:
+            plan = json.loads(clean)
+            if isinstance(plan, list):
+                return plan
+            elif isinstance(plan, dict) and "steps" in plan:
+                return plan["steps"]
+            raise ValueError("JSON is not a list structure.")
+        except Exception as e:
+            log.error(f"Failed to parse plan JSON. Raw output: {text}. Error: {e}")
+            return [{
+                "step_id": 1,
+                "task_type": "generic",
+                "target_file": "unknown_file.py",
+                "instruction": f"Execute raw request due to planner parsing error. Task: {text}"
+            }]