Upload 3 files

AI_Task_Master.ipynb

@@ -0,0 +1,584 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# \"AI Task Master\" — Multi-Agent Productivity & Execution System\n",
+        "\n",
+        "# Upload a Goal / To-Do List / Project Idea → Agents break it down → Prioritize → Create action steps → Assign estimated time → Generate a Daily Execution Plan with smart suggestions & progress tracking logic."
+      ],
+      "metadata": {
+        "id": "hMAysKRQphEj"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# 🧱 Step 0: Colab Setup (Install & Imports)"
+      ],
+      "metadata": {
+        "id": "IRKP3gswqJSu"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#!pip install --quiet crewai langchain-openai gradio python-dotenv pydantic -q"
+      ],
+      "metadata": {
+        "id": "58wVUNhZnxQh"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [],
+      "metadata": {
+        "id": "sH9afYAjqdCa"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import os, json, textwrap, datetime as dt\n",
+        "from typing import Optional, List, Dict, Any\n",
+        "\n",
+        "from crewai import Agent, Task, Crew, Process\n",
+        "from langchain_openai import ChatOpenAI\n"
+      ],
+      "metadata": {
+        "id": "EwHFD9RSnsRg"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# 🔐 Step 1: Configure API Key (OpenAI)\n"
+      ],
+      "metadata": {
+        "id": "qiL6nGlGqe_w"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from google.colab import userdata\n",
+        "\n",
+        "# Retrieve the API key from Colab secrets\n",
+        "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY')\n",
+        "\n",
+        "# Model defaults (you can change)\n",
+        "MODEL_NAME = \"gpt-4o-mini\"   # fast & smart\n",
+        "TEMPERATURE = 0.2\n",
+        "llm = ChatOpenAI(model=MODEL_NAME, temperature=TEMPERATURE)"
+      ],
+      "metadata": {
+        "id": "3A7Xcn2Qn81O"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# 🧩 Step 2: Project Inputs Helper"
+      ],
+      "metadata": {
+        "id": "aFEecuUqqiiQ"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Light helper to bundle inputs\n",
+        "def default_inputs(\n",
+        "    goal: str,\n",
+        "    deadline_days: int = 14,\n",
+        "    hours_per_day: int = 2,\n",
+        "    start_date: Optional[str] = None,\n",
+        ") -> Dict[str, Any]:\n",
+        "    if not start_date:\n",
+        "        start_date = dt.date.today().isoformat()\n",
+        "    return {\n",
+        "        \"goal\": goal.strip(),\n",
+        "        \"deadline_days\": int(deadline_days),\n",
+        "        \"hours_per_day\": int(hours_per_day),\n",
+        "        \"start_date\": start_date,\n",
+        "    }\n"
+      ],
+      "metadata": {
+        "id": "RUHRmzmwoM6E"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# 🎭 Step 3: Define Agents (Roles + Personalities)\n"
+      ],
+      "metadata": {
+        "id": "mt9NZfhlqmEd"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Agent: Understand the user's goal & constraints\n",
+        "goal_understanding = Agent(\n",
+        "    role=\"Goal Understanding Agent\",\n",
+        "    backstory=(\n",
+        "        \"You are a thoughtful strategist. You clarify objectives, constraints, \"\n",
+        "        \"and success criteria. You avoid fluff and get to the essence.\"\n",
+        "    ),\n",
+        "    goal=(\n",
+        "        \"Rewrite the user's goal clearly and identify assumptions, scope, \"\n",
+        "        \"success criteria, hard constraints, and risks.\"\n",
+        "    ),\n",
+        "    allow_delegation=False,\n",
+        "    llm=llm,\n",
+        ")\n",
+        "\n",
+        "# Agent: Break the goal into milestones & tasks\n",
+        "task_breakdown = Agent(\n",
+        "    role=\"Task Breakdown Agent\",\n",
+        "    backstory=(\n",
+        "        \"You are a senior project planner. You decompose work into milestones \"\n",
+        "        \"and concrete tasks that are testable and deliver value.\"\n",
+        "    ),\n",
+        "    goal=(\n",
+        "        \"Produce milestones and detailed subtasks with crisp deliverables.\"\n",
+        "    ),\n",
+        "    allow_delegation=False,\n",
+        "    llm=llm,\n",
+        ")\n",
+        "\n",
+        "# Agent: Estimate effort & prioritize\n",
+        "effort_priority = Agent(\n",
+        "    role=\"Effort & Priority Agent\",\n",
+        "    backstory=(\n",
+        "        \"You are a pragmatic PM. You estimate realistic time and difficulty, \"\n",
+        "        \"sequence tasks, and surface dependencies.\"\n",
+        "    ),\n",
+        "    goal=(\n",
+        "        \"Estimate time per task, difficulty (1-5), dependencies, and propose a priority order.\"\n",
+        "    ),\n",
+        "    allow_delegation=False,\n",
+        "    llm=llm,\n",
+        ")\n",
+        "\n",
+        "# Agent: Build a calendar-style plan\n",
+        "scheduler = Agent(\n",
+        "    role=\"Schedule Maker Agent\",\n",
+        "    backstory=(\n",
+        "        \"You create practical schedules given time budgets per day and deadlines.\"\n",
+        "    ),\n",
+        "    goal=(\n",
+        "        \"Map tasks to days from start_date within deadline_days, respecting hours_per_day.\"\n",
+        "    ),\n",
+        "    allow_delegation=False,\n",
+        "    llm=llm,\n",
+        ")\n",
+        "\n",
+        "# Agent: Motivation & execution tips (optional spice)\n",
+        "motivator = Agent(\n",
+        "    role=\"Motivator Agent\",\n",
+        "    backstory=(\n",
+        "        \"You coach users with specific, actionable tips, accountability tactics, and small rewards.\"\n",
+        "    ),\n",
+        "    goal=\"Provide short, concrete advice to keep momentum high.\",\n",
+        "    allow_delegation=False,\n",
+        "    llm=llm,\n",
+        ")\n",
+        "\n",
+        "# Agent: Final synthesis for export\n",
+        "synthesizer = Agent(\n",
+        "    role=\"Synthesis Agent\",\n",
+        "    backstory=(\n",
+        "        \"You are a concise editor. You assemble a clean, professional plan for download and printing.\"\n",
+        "    ),\n",
+        "    goal=\"Create final Markdown + JSON outputs for the user.\",\n",
+        "    allow_delegation=False,\n",
+        "    llm=llm,\n",
+        ")\n"
+      ],
+      "metadata": {
+        "id": "U9Wvk1DqoYwx"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# 🧠 Step 4: Define Tasks (with JSON-first outputs\n"
+      ],
+      "metadata": {
+        "id": "_jgH0_8TqprY"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def make_tasks(inputs: Dict[str, Any]) -> List[Task]:\n",
+        "    common_vars = (\n",
+        "        f\"GOAL: {inputs['goal']}\\n\"\n",
+        "        f\"START_DATE: {inputs['start_date']}\\n\"\n",
+        "        f\"DEADLINE_DAYS: {inputs['deadline_days']}\\n\"\n",
+        "        f\"HOURS_PER_DAY: {inputs['hours_per_day']}\\n\"\n",
+        "    )\n",
+        "\n",
+        "    t1 = Task(\n",
+        "        description=textwrap.dedent(f\"\"\"\n",
+        "        Clarify the user's goal.\n",
+        "\n",
+        "        Context:\n",
+        "        {common_vars}\n",
+        "\n",
+        "        Return STRICT JSON with keys:\n",
+        "        {{\n",
+        "          \"clarified_goal\": \"...\",\n",
+        "          \"assumptions\": [\"...\"],\n",
+        "          \"scope\": [\"in-scope\", \"...\"],\n",
+        "          \"success_criteria\": [\"...\"],\n",
+        "          \"constraints\": [\"...\"],\n",
+        "          \"risks\": [\"...\"]\n",
+        "        }}\n",
+        "        \"\"\").strip(),\n",
+        "        agent=goal_understanding,\n",
+        "        expected_output=\"JSON only.\",\n",
+        "    )\n",
+        "\n",
+        "    t2 = Task(\n",
+        "        description=textwrap.dedent(f\"\"\"\n",
+        "        Break the clarified goal into milestones and granular tasks.\n",
+        "\n",
+        "        Input is the JSON from the previous step.\n",
+        "        Return STRICT JSON:\n",
+        "        {{\n",
+        "          \"milestones\": [\n",
+        "            {{\n",
+        "              \"name\": \"...\",\n",
+        "              \"description\": \"...\",\n",
+        "              \"tasks\": [\n",
+        "                {{\n",
+        "                  \"id\": \"T1\",\n",
+        "                  \"title\": \"...\",\n",
+        "                  \"definition_of_done\": \"...\",\n",
+        "                  \"dependencies\": [],\n",
+        "                  \"tags\": [\"...\"]\n",
+        "                }}\n",
+        "              ]\n",
+        "            }}\n",
+        "          ]\n",
+        "        }}\n",
+        "        \"\"\").strip(),\n",
+        "        agent=task_breakdown,\n",
+        "        expected_output=\"JSON only.\",\n",
+        "    )\n",
+        "\n",
+        "    t3 = Task(\n",
+        "        description=textwrap.dedent(f\"\"\"\n",
+        "        Estimate effort and priority for EACH task id from the previous output.\n",
+        "\n",
+        "        Respect HOURS_PER_DAY={inputs['hours_per_day']} and DEADLINE_DAYS={inputs['deadline_days']}.\n",
+        "        Return STRICT JSON:\n",
+        "        {{\n",
+        "          \"estimates\": [\n",
+        "            {{\n",
+        "              \"id\": \"T1\",\n",
+        "              \"hours\": 2.5,\n",
+        "              \"difficulty_1to5\": 3,\n",
+        "              \"priority_1to5\": 1\n",
+        "            }}\n",
+        "          ]\n",
+        "        }}\n",
+        "        \"\"\").strip(),\n",
+        "        agent=effort_priority,\n",
+        "        expected_output=\"JSON only.\",\n",
+        "    )\n",
+        "\n",
+        "    t4 = Task(\n",
+        "        description=textwrap.dedent(f\"\"\"\n",
+        "        Create a day-by-day schedule mapping tasks to calendar dates.\n",
+        "\n",
+        "        Use START_DATE and DEADLINE_DAYS. Do not exceed HOURS_PER_DAY per day.\n",
+        "        Return STRICT JSON:\n",
+        "        {{\n",
+        "          \"schedule\": [\n",
+        "            {{\n",
+        "              \"date\": \"YYYY-MM-DD\",\n",
+        "              \"allocated_hours\": 2,\n",
+        "              \"tasks\": [{{\"id\":\"T1\",\"title\":\"...\",\"hours\":1.5}}]\n",
+        "            }}\n",
+        "          ],\n",
+        "          \"summary\": {{\n",
+        "            \"total_hours\": 0,\n",
+        "            \"days_planned\": 0,\n",
+        "            \"buffer_hours\": 0\n",
+        "          }}\n",
+        "        }}\n",
+        "        \"\"\").strip(),\n",
+        "        agent=scheduler,\n",
+        "        expected_output=\"JSON only.\",\n",
+        "    )\n",
+        "\n",
+        "    t5 = Task(\n",
+        "        description=textwrap.dedent(f\"\"\"\n",
+        "        Provide 5 short motivation or execution tactics tailored to the plan.\n",
+        "\n",
+        "        Return STRICT JSON:\n",
+        "        {{\n",
+        "          \"tips\": [\n",
+        "            \"Keep daily sessions short & focused with a single visible deliverable.\",\n",
+        "            \"...\"\n",
+        "          ]\n",
+        "        }}\n",
+        "        \"\"\").strip(),\n",
+        "        agent=motivator,\n",
+        "        expected_output=\"JSON only.\",\n",
+        "    )\n",
+        "\n",
+        "    t6 = Task(\n",
+        "        description=textwrap.dedent(f\"\"\"\n",
+        "        Synthesize a final MARKDOWN report AND a JSON bundle.\n",
+        "\n",
+        "        Inputs are the JSONs from all prior tasks. Build:\n",
+        "        1) Markdown (for printing) with sections:\n",
+        "           - Goal Summary\n",
+        "           - Milestones & Tasks\n",
+        "           - Estimates & Priorities\n",
+        "           - Day-by-Day Plan (table)\n",
+        "           - Tips (bulleted)\n",
+        "        2) JSON bundle containing all prior JSON merged into one: keys:\n",
+        "           {{\n",
+        "             \"goal_context\": ...,\n",
+        "             \"work_breakdown\": ...,\n",
+        "             \"estimates\": ...,\n",
+        "             \"schedule\": ...,\n",
+        "             \"tips\": ...\n",
+        "           }}\n",
+        "\n",
+        "        Return STRICT JSON:\n",
+        "        {{\n",
+        "          \"markdown\": \"....\",\n",
+        "          \"bundle\": {{ /* merged JSON object */ }}\n",
+        "        }}\n",
+        "        \"\"\").strip(),\n",
+        "        agent=synthesizer,\n",
+        "        expected_output=\"JSON only.\",\n",
+        "    )\n",
+        "\n",
+        "    return [t1, t2, t3, t4, t5, t6]\n"
+      ],
+      "metadata": {
+        "id": "bULXBMGZoacv"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# 🏃‍♂️ Step 5: Run the Crew"
+      ],
+      "metadata": {
+        "id": "CBxM7WSqrFzR"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def run_planner(goal: str, deadline_days: int = 14, hours_per_day: int = 2, start_date: Optional[str] = None):\n",
+        "    inputs = default_inputs(goal, deadline_days, hours_per_day, start_date)\n",
+        "\n",
+        "    tasks = make_tasks(inputs)\n",
+        "    crew = Crew(\n",
+        "        agents=[goal_understanding, task_breakdown, effort_priority, scheduler, motivator, synthesizer],\n",
+        "        tasks=tasks,\n",
+        "        process=Process.sequential,  # run in order\n",
+        "        verbose=True,\n",
+        "        memory=True,\n",
+        "        cache=True,\n",
+        "    )\n",
+        "\n",
+        "    result = crew.kickoff(inputs=inputs)\n",
+        "\n",
+        "    # The final task returns JSON with 'markdown' and 'bundle'\n",
+        "    # crewai often returns extra text around json; ensure it's valid JSON:\n",
+        "    def coerce_json(text: str) -> Dict[str, Any]:\n",
+        "        try:\n",
+        "            return json.loads(text)\n",
+        "        except Exception:\n",
+        "            # Try to extract JSON block heuristically\n",
+        "            start = text.find(\"{\")\n",
+        "            end = text.rfind(\"}\")\n",
+        "            if start != -1 and end != -1:\n",
+        "                return json.loads(text[start:end+1])\n",
+        "            raise\n",
+        "\n",
+        "    final = coerce_json(str(result))\n",
+        "    md = final.get(\"markdown\", \"# Plan\\n\\n(No markdown received)\")\n",
+        "    bundle = final.get(\"bundle\", {})\n",
+        "\n",
+        "    # Save artifacts\n",
+        "    out_dir = \"/content/task_master_outputs\"\n",
+        "    os.makedirs(out_dir, exist_ok=True)\n",
+        "    stamp = dt.datetime.now().strftime(\"%Y%m%d_%H%M%S\")\n",
+        "\n",
+        "    md_path = os.path.join(out_dir, f\"plan_{stamp}.md\")\n",
+        "    json_path = os.path.join(out_dir, f\"plan_{stamp}.json\")\n",
+        "\n",
+        "    with open(md_path, \"w\", encoding=\"utf-8\") as f:\n",
+        "        f.write(md)\n",
+        "    with open(json_path, \"w\", encoding=\"utf-8\") as f:\n",
+        "        json.dump(bundle, f, indent=2, ensure_ascii=False)\n",
+        "\n",
+        "    return {\n",
+        "        \"markdown_path\": md_path,\n",
+        "        \"json_path\": json_path,\n",
+        "        \"markdown_preview\": md[:1500] + (\"\\n\\n...[truncated]...\" if len(md) > 1500 else \"\"),\n",
+        "    }\n"
+      ],
+      "metadata": {
+        "id": "wikuoefWoc0Z"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Step 6: Minimal Gradio UI"
+      ],
+      "metadata": {
+        "id": "bbs5keN2rOAh"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import gradio as gr\n",
+        "\n",
+        "def gradio_run(goal, deadline_days, hours_per_day, start_date):\n",
+        "    out = run_planner(goal, int(deadline_days), int(hours_per_day), start_date or None)\n",
+        "    md = \"\"\n",
+        "    with open(out[\"markdown_path\"], \"r\", encoding=\"utf-8\") as f:\n",
+        "        md = f.read()\n",
+        "    return md, out[\"markdown_path\"], out[\"json_path\"]\n",
+        "\n",
+        "with gr.Blocks(title=\"CrewAI Task Master\") as demo_ui:\n",
+        "    gr.Markdown(\"# 🧠 CrewAI Task Master\\nPlan any goal into a day-by-day schedule.\")\n",
+        "    with gr.Row():\n",
+        "        goal = gr.Textbox(label=\"Your Goal\", placeholder=\"e.g., Build an AI portfolio website in 10 days\", lines=3)\n",
+        "    with gr.Row():\n",
+        "        deadline = gr.Number(label=\"Deadline (days)\", value=14, precision=0)\n",
+        "        hours = gr.Number(label=\"Hours per day\", value=2, precision=0)\n",
+        "        start = gr.Textbox(label=\"Start Date (YYYY-MM-DD, optional)\", placeholder=\"Leave blank for today\")\n",
+        "    run_btn = gr.Button(\"Run Agents 🚀\")\n",
+        "\n",
+        "    md_out = gr.Markdown(label=\"Plan (Markdown)\")\n",
+        "    md_file = gr.File(label=\"Download Markdown\")\n",
+        "    json_file = gr.File(label=\"Download JSON\")\n",
+        "\n",
+        "    run_btn.click(\n",
+        "        gradio_run,\n",
+        "        inputs=[goal, deadline, hours, start],\n",
+        "        outputs=[md_out, md_file, json_file]\n",
+        "    )\n",
+        "\n",
+        "demo_ui.launch(share=False)\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 599
+        },
+        "id": "HDJKz5r4oisy",
+        "outputId": "1c91172e-6ac4-4d3e-8074-1ad8ced4fc9a"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Colab notebook detected. To show errors in colab notebook, set debug=True in launch()\n",
+            "Note: opening Chrome Inspector may crash demo inside Colab notebooks.\n",
+            "* To create a public link, set `share=True` in `launch()`.\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<IPython.core.display.Javascript object>"
+            ],
+            "application/javascript": [
+              "(async (port, path, width, height, cache, element) => {\n",
+              "                        if (!google.colab.kernel.accessAllowed && !cache) {\n",
+              "                            return;\n",
+              "                        }\n",
+              "                        element.appendChild(document.createTextNode(''));\n",
+              "                        const url = await google.colab.kernel.proxyPort(port, {cache});\n",
+              "\n",
+              "                        const external_link = document.createElement('div');\n",
+              "                        external_link.innerHTML = `\n",
+              "                            <div style=\"font-family: monospace; margin-bottom: 0.5rem\">\n",
+              "                                Running on <a href=${new URL(path, url).toString()} target=\"_blank\">\n",
+              "                                    https://localhost:${port}${path}\n",
+              "                                </a>\n",
+              "                            </div>\n",
+              "                        `;\n",
+              "                        element.appendChild(external_link);\n",
+              "\n",
+              "                        const iframe = document.createElement('iframe');\n",
+              "                        iframe.src = new URL(path, url).toString();\n",
+              "                        iframe.height = height;\n",
+              "                        iframe.allow = \"autoplay; camera; microphone; clipboard-read; clipboard-write;\"\n",
+              "                        iframe.width = width;\n",
+              "                        iframe.style.border = 0;\n",
+              "                        element.appendChild(iframe);\n",
+              "                    })(7860, \"/\", \"100%\", 500, false, window.element)"
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": []
+          },
+          "metadata": {},
+          "execution_count": 11
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [],
+      "metadata": {
+        "id": "YC9b0G8romnv"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}

app.py

@@ -0,0 +1,378 @@
+# -*- coding: utf-8 -*-
+"""AI Task Master.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1k8oLpD1BlJjWEOTZ0UoJQCVyfl9883bE
+
+# "AI Task Master" — Multi-Agent Productivity & Execution System
+
+# Upload a Goal / To-Do List / Project Idea → Agents break it down → Prioritize → Create action steps → Assign estimated time → Generate a Daily Execution Plan with smart suggestions & progress tracking logic.
+
+# 🧱 Step 0: Colab Setup (Install & Imports)
+"""
+
+#!pip install --quiet crewai langchain-openai gradio python-dotenv pydantic -q
+
+import os, json, textwrap, datetime as dt
+from typing import Optional, List, Dict, Any
+
+from crewai import Agent, Task, Crew, Process
+from langchain_openai import ChatOpenAI
+
+"""# 🔐 Step 1: Configure API Key (OpenAI)
+
+"""
+
+import os
+
+# Hugging Face Spaces will allow access to secrets like this:
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+
+# Model defaults (you can change)
+MODEL_NAME = "gpt-4o-mini"   # fast & smart
+TEMPERATURE = 0.2
+llm = ChatOpenAI(model=MODEL_NAME, temperature=TEMPERATURE)
+
+"""# 🧩 Step 2: Project Inputs Helper"""
+
+# Light helper to bundle inputs
+def default_inputs(
+    goal: str,
+    deadline_days: int = 14,
+    hours_per_day: int = 2,
+    start_date: Optional[str] = None,
+) -> Dict[str, Any]:
+    if not start_date:
+        start_date = dt.date.today().isoformat()
+    return {
+        "goal": goal.strip(),
+        "deadline_days": int(deadline_days),
+        "hours_per_day": int(hours_per_day),
+        "start_date": start_date,
+    }
+
+"""# 🎭 Step 3: Define Agents (Roles + Personalities)
+
+"""
+
+# Agent: Understand the user's goal & constraints
+goal_understanding = Agent(
+    role="Goal Understanding Agent",
+    backstory=(
+        "You are a thoughtful strategist. You clarify objectives, constraints, "
+        "and success criteria. You avoid fluff and get to the essence."
+    ),
+    goal=(
+        "Rewrite the user's goal clearly and identify assumptions, scope, "
+        "success criteria, hard constraints, and risks."
+    ),
+    allow_delegation=False,
+    llm=llm,
+)
+
+# Agent: Break the goal into milestones & tasks
+task_breakdown = Agent(
+    role="Task Breakdown Agent",
+    backstory=(
+        "You are a senior project planner. You decompose work into milestones "
+        "and concrete tasks that are testable and deliver value."
+    ),
+    goal=(
+        "Produce milestones and detailed subtasks with crisp deliverables."
+    ),
+    allow_delegation=False,
+    llm=llm,
+)
+
+# Agent: Estimate effort & prioritize
+effort_priority = Agent(
+    role="Effort & Priority Agent",
+    backstory=(
+        "You are a pragmatic PM. You estimate realistic time and difficulty, "
+        "sequence tasks, and surface dependencies."
+    ),
+    goal=(
+        "Estimate time per task, difficulty (1-5), dependencies, and propose a priority order."
+    ),
+    allow_delegation=False,
+    llm=llm,
+)
+
+# Agent: Build a calendar-style plan
+scheduler = Agent(
+    role="Schedule Maker Agent",
+    backstory=(
+        "You create practical schedules given time budgets per day and deadlines."
+    ),
+    goal=(
+        "Map tasks to days from start_date within deadline_days, respecting hours_per_day."
+    ),
+    allow_delegation=False,
+    llm=llm,
+)
+
+# Agent: Motivation & execution tips (optional spice)
+motivator = Agent(
+    role="Motivator Agent",
+    backstory=(
+        "You coach users with specific, actionable tips, accountability tactics, and small rewards."
+    ),
+    goal="Provide short, concrete advice to keep momentum high.",
+    allow_delegation=False,
+    llm=llm,
+)
+
+# Agent: Final synthesis for export
+synthesizer = Agent(
+    role="Synthesis Agent",
+    backstory=(
+        "You are a concise editor. You assemble a clean, professional plan for download and printing."
+    ),
+    goal="Create final Markdown + JSON outputs for the user.",
+    allow_delegation=False,
+    llm=llm,
+)
+
+"""# 🧠 Step 4: Define Tasks (with JSON-first outputs
+
+"""
+
+def make_tasks(inputs: Dict[str, Any]) -> List[Task]:
+    common_vars = (
+        f"GOAL: {inputs['goal']}\n"
+        f"START_DATE: {inputs['start_date']}\n"
+        f"DEADLINE_DAYS: {inputs['deadline_days']}\n"
+        f"HOURS_PER_DAY: {inputs['hours_per_day']}\n"
+    )
+
+    t1 = Task(
+        description=textwrap.dedent(f"""
+        Clarify the user's goal.
+
+        Context:
+        {common_vars}
+
+        Return STRICT JSON with keys:
+        {{
+          "clarified_goal": "...",
+          "assumptions": ["..."],
+          "scope": ["in-scope", "..."],
+          "success_criteria": ["..."],
+          "constraints": ["..."],
+          "risks": ["..."]
+        }}
+        """).strip(),
+        agent=goal_understanding,
+        expected_output="JSON only.",
+    )
+
+    t2 = Task(
+        description=textwrap.dedent(f"""
+        Break the clarified goal into milestones and granular tasks.
+
+        Input is the JSON from the previous step.
+        Return STRICT JSON:
+        {{
+          "milestones": [
+            {{
+              "name": "...",
+              "description": "...",
+              "tasks": [
+                {{
+                  "id": "T1",
+                  "title": "...",
+                  "definition_of_done": "...",
+                  "dependencies": [],
+                  "tags": ["..."]
+                }}
+              ]
+            }}
+          ]
+        }}
+        """).strip(),
+        agent=task_breakdown,
+        expected_output="JSON only.",
+    )
+
+    t3 = Task(
+        description=textwrap.dedent(f"""
+        Estimate effort and priority for EACH task id from the previous output.
+
+        Respect HOURS_PER_DAY={inputs['hours_per_day']} and DEADLINE_DAYS={inputs['deadline_days']}.
+        Return STRICT JSON:
+        {{
+          "estimates": [
+            {{
+              "id": "T1",
+              "hours": 2.5,
+              "difficulty_1to5": 3,
+              "priority_1to5": 1
+            }}
+          ]
+        }}
+        """).strip(),
+        agent=effort_priority,
+        expected_output="JSON only.",
+    )
+
+    t4 = Task(
+        description=textwrap.dedent(f"""
+        Create a day-by-day schedule mapping tasks to calendar dates.
+
+        Use START_DATE and DEADLINE_DAYS. Do not exceed HOURS_PER_DAY per day.
+        Return STRICT JSON:
+        {{
+          "schedule": [
+            {{
+              "date": "YYYY-MM-DD",
+              "allocated_hours": 2,
+              "tasks": [{{"id":"T1","title":"...","hours":1.5}}]
+            }}
+          ],
+          "summary": {{
+            "total_hours": 0,
+            "days_planned": 0,
+            "buffer_hours": 0
+          }}
+        }}
+        """).strip(),
+        agent=scheduler,
+        expected_output="JSON only.",
+    )
+
+    t5 = Task(
+        description=textwrap.dedent(f"""
+        Provide 5 short motivation or execution tactics tailored to the plan.
+
+        Return STRICT JSON:
+        {{
+          "tips": [
+            "Keep daily sessions short & focused with a single visible deliverable.",
+            "..."
+          ]
+        }}
+        """).strip(),
+        agent=motivator,
+        expected_output="JSON only.",
+    )
+
+    t6 = Task(
+        description=textwrap.dedent(f"""
+        Synthesize a final MARKDOWN report AND a JSON bundle.
+
+        Inputs are the JSONs from all prior tasks. Build:
+        1) Markdown (for printing) with sections:
+           - Goal Summary
+           - Milestones & Tasks
+           - Estimates & Priorities
+           - Day-by-Day Plan (table)
+           - Tips (bulleted)
+        2) JSON bundle containing all prior JSON merged into one: keys:
+           {{
+             "goal_context": ...,
+             "work_breakdown": ...,
+             "estimates": ...,
+             "schedule": ...,
+             "tips": ...
+           }}
+
+        Return STRICT JSON:
+        {{
+          "markdown": "....",
+          "bundle": {{ /* merged JSON object */ }}
+        }}
+        """).strip(),
+        agent=synthesizer,
+        expected_output="JSON only.",
+    )
+
+    return [t1, t2, t3, t4, t5, t6]
+
+"""# 🏃‍♂️ Step 5: Run the Crew"""
+
+def run_planner(goal: str, deadline_days: int = 14, hours_per_day: int = 2, start_date: Optional[str] = None):
+    inputs = default_inputs(goal, deadline_days, hours_per_day, start_date)
+
+    tasks = make_tasks(inputs)
+    crew = Crew(
+        agents=[goal_understanding, task_breakdown, effort_priority, scheduler, motivator, synthesizer],
+        tasks=tasks,
+        process=Process.sequential,  # run in order
+        verbose=True,
+        memory=True,
+        cache=True,
+    )
+
+    result = crew.kickoff(inputs=inputs)
+
+    # The final task returns JSON with 'markdown' and 'bundle'
+    # crewai often returns text; ensure it's valid JSON:
+    def coerce_json(text: str) -> Dict[str, Any]:
+        try:
+            return json.loads(text)
+        except Exception:
+            # Try to extract JSON block heuristically
+            start = text.find("{")
+            end = text.rfind("}")
+            if start != -1 and end != -1:
+                return json.loads(text[start:end+1])
+            raise
+
+    final = coerce_json(str(result))
+    md = final.get("markdown", "# Plan\n\n(No markdown received)")
+    bundle = final.get("bundle", {})
+
+    # Save artifacts
+    out_dir = "task_master_outputs"
+    os.makedirs(out_dir, exist_ok=True)
+    stamp = dt.datetime.now().strftime("%Y%m%d_%H%M%S")
+
+    md_path = os.path.join(out_dir, f"plan_{stamp}.md")
+    json_path = os.path.join(out_dir, f"plan_{stamp}.json")
+
+    with open(md_path, "w", encoding="utf-8") as f:
+        f.write(md)
+    with open(json_path, "w", encoding="utf-8") as f:
+        json.dump(bundle, f, indent=2, ensure_ascii=False)
+
+    return {
+        "markdown_path": md_path,
+        "json_path": json_path,
+        "markdown_preview": md[:1500] + ("\n\n...[truncated]..." if len(md) > 1500 else ""),
+    }
+
+"""# Step 6: Minimal Gradio UI"""
+
+import gradio as gr
+
+def gradio_run(goal, deadline_days, hours_per_day, start_date):
+    out = run_planner(goal, int(deadline_days), int(hours_per_day), start_date or None)
+    md = ""
+    with open(out["markdown_path"], "r", encoding="utf-8") as f:
+        md = f.read()
+    return md, out["markdown_path"], out["json_path"]
+
+with gr.Blocks(title="CrewAI Task Master") as demo_ui:
+    gr.Markdown("# 🧠 CrewAI Task Master\nPlan any goal into a day-by-day schedule.")
+    with gr.Row():
+        goal = gr.Textbox(label="Your Goal", placeholder="e.g., Build an AI portfolio website in 10 days", lines=3)
+    with gr.Row():
+        deadline = gr.Number(label="Deadline (days)", value=14, precision=0)
+        hours = gr.Number(label="Hours per day", value=2, precision=0)
+        start = gr.Textbox(label="Start Date (YYYY-MM-DD, optional)", placeholder="Leave blank for today")
+    run_btn = gr.Button("Run Agents 🚀")
+
+    md_out = gr.Markdown(label="Plan (Markdown)")
+    md_file = gr.File(label="Download Markdown")
+    json_file = gr.File(label="Download JSON")
+
+    run_btn.click(
+        gradio_run,
+        inputs=[goal, deadline, hours, start],
+        outputs=[md_out, md_file, json_file]
+    )
+
+demo_ui.launch(share=False)
+

requirements.txt

@@ -0,0 +1,5 @@
+crewai 
+langchain-openai 
+gradio 
+python-dotenv 
+pydantic