nigg

.python-version

@@ -1 +1 @@
-3.13
+3.11

Dockerfile

@@ -1,4 +1,4 @@
-FROM python:3.12-slim
+FROM python:3.11-slim
 
 # Install dependencies
 RUN apt-get update && apt-get install -y wget curl && \

README.md

@@ -1,6 +1,10 @@
 ---
 title: Mann
+emoji: 🌍
+colorFrom: blue
+colorTo: yellow
 sdk: docker
+pinned: false
 ---
 
 # Mann - Terminal Loading Animation

jira_mcp_server.py

@@ -0,0 +1,141 @@
+"""
+Jira MCP Server
+================
+Exposes all Jira Sprint API endpoints as MCP tools.
+The agent calls these tools natively — no JSON action routing needed.
+
+Run this first:
+  python jira_mcp_server.py
+
+Then in another terminal run the agent:
+  python jira_agent_mcp.py
+"""
+
+import os
+import requests
+from mcp.server.fastmcp import FastMCP
+from dotenv import load_dotenv
+
+load_dotenv()
+
+JIRA_API_URL = os.environ.get("JIRA_API_URL", "http://0.0.0.0:8001")
+
+mcp = FastMCP("Jira Sprint Manager")
+
+
+def call(method: str, path: str, payload: dict = None) -> dict:
+    url = f"{JIRA_API_URL}{path}"
+    try:
+        if method == "GET":
+            r = requests.get(url, headers={"accept": "application/json"}, timeout=10)
+        else:
+            r = requests.request(
+                method, url,
+                headers={"Content-Type": "application/json", "accept": "application/json"},
+                json=payload or {},
+                timeout=10,
+            )
+        r.raise_for_status()
+        return r.json()
+    except requests.RequestException as e:
+        return {"success": False, "error": str(e)}
+
+
+# ── MCP tools — one per Jira endpoint ────────────────────────────────────────
+
+@mcp.tool()
+def health_check() -> dict:
+    """Check if the Jira API server is running and healthy."""
+    return call("GET", "/")
+
+
+@mcp.tool()
+def get_backlog() -> dict:
+    """
+    Get all backlog issues — stories and tasks not assigned to any sprint.
+    Use this when the user asks about unassigned work, backlog items, or pending stories.
+    """
+    return call("GET", "/api/backlog")
+
+
+@mcp.tool()
+def create_story(name: str, description: str) -> dict:
+    """
+    Create a new story/task/issue in Jira.
+
+    Args:
+        name: Short title of the story (e.g. 'Implement login API')
+        description: Detailed description of what needs to be done
+    """
+    return call("POST", "/api/story", {"name": name, "description": description})
+
+
+@mcp.tool()
+def get_active_sprint() -> dict:
+    """
+    Get the current active sprint with all its issues and their statuses.
+    Use this when the user asks about sprint progress, current work, or what is in the sprint.
+    """
+    return call("GET", "/api/sprint/active")
+
+
+@mcp.tool()
+def add_issues_to_sprint(sprint_id: int, issue_keys: list[str]) -> dict:
+    """
+    Add one or more backlog issues into an active sprint.
+
+    Args:
+        sprint_id: The numeric ID of the sprint (e.g. 9)
+        issue_keys: List of Jira issue keys to add (e.g. ['SCRUM-17', 'SCRUM-19'])
+    """
+    return call("POST", f"/api/sprint/{sprint_id}/add-issues", {"issue_keys": issue_keys})
+
+
+@mcp.tool()
+def transition_issue(issue_key: str, status_code: str, comment: str = "") -> dict:
+    """
+    Update the status of a Jira issue. Optionally add a comment explaining the change.
+
+    Status codes:
+        "1" = To Do
+        "2" = In Progress
+        "3" = Testing
+        "4" = Done
+
+    Args:
+        issue_key: The Jira issue key (e.g. 'SCRUM-17')
+        status_code: One of "1", "2", "3", "4"
+        comment: Optional comment to add to the issue (e.g. 'All tests passed')
+    """
+    payload = {"status": status_code}
+    if comment:
+        payload["comment"] = comment
+    return call("POST", f"/api/issue/{issue_key}/transition", payload)
+
+
+@mcp.tool()
+def sprint_rollover(new_sprint_name: str, add_backlog_to_new_sprint: bool = False) -> dict:
+    """
+    Close the current active sprint and start a new one.
+    Unfinished issues are automatically carried forward to the new sprint.
+
+    Args:
+        new_sprint_name: Name for the new sprint (e.g. 'Sprint 2')
+        add_backlog_to_new_sprint: If True, also pull all backlog items into the new sprint
+    """
+    return call("POST", "/api/sprint/rollover", {
+        "new_sprint_name": new_sprint_name,
+        "add_backlog_to_new_sprint": add_backlog_to_new_sprint,
+    })
+
+
+# ── run ───────────────────────────────────────────────────────────────────────
+if __name__ == "__main__":
+    print("=" * 50)
+    print("  Jira MCP Server starting...")
+    print(f"  Jira API : {JIRA_API_URL}")
+    print("  Tools    : health_check, get_backlog, create_story,")
+    print("             get_active_sprint, add_issues_to_sprint,")
+    print("             transition_issue, sprint_rollover")
+    print("=" * 50 + "\n")
+    mcp.run(transport="stdio")

main.py

@@ -1,13 +1,48 @@
 import time
+import threading
+import os
 from tqdm import tqdm
+from fastapi import FastAPI
+import uvicorn
 
-def main():
-    # Infinite loading animation
+app = FastAPI()
+
+def loading_animation():
+    """Infinite loading animation running in background."""
     try:
         for i in tqdm(range(1000000), desc="Loading NINININININININ", unit="%", bar_format="{l_bar}{bar}| {n_fmt}/{total_fmt}"):
             time.sleep(0.01)
     except KeyboardInterrupt:
         print("\nLoading interrupted!")
 
+@app.get("/health")
+def health():
+    return {"status": "ok", "message": "Server is running"}
+
+
+@app.get("/healthz")
+def healthz():
+    return {"status": "ok"}
+
+@app.get("/")
+def root():
+    return {
+        "message": "Mann API",
+        "endpoints": {
+            "/health": "Health check",
+            "/healthz": "Lightweight health check",
+        },
+    }
+
+def main():
+    port = int(os.environ.get("PORT", "7860"))
+
+    # Start loading animation in background thread
+    loading_thread = threading.Thread(target=loading_animation, daemon=True)
+    loading_thread.start()
+
+    # Start FastAPI server
+    uvicorn.run(app, host="0.0.0.0", port=port)
+
 if __name__ == "__main__":
     main()

pyproject.toml

@@ -3,7 +3,22 @@ name = "mann"
 version = "0.1.0"
 description = "Add your description here"
 readme = "README.md"
-requires-python = ">=3.13"
+requires-python = ">=3.11"
 dependencies = [
+    "accelerate>=0.30.0",
+    "bitsandbytes>=0.43.0",
+    "fastapi>=0.115.0",
+    "huggingface-hub>=1.10.1",
+    "mcp>=1.27.0",
+    "pinecone>=8.1.2",
+    "python-dotenv>=1.1.1",
+    "pydantic>=2.0.0",
+    "pytelegrambotapi>=4.33.0",
+    "requests>=2.33.1",
+    "sentence-transformers>=5.4.0",
+    "torch>=2.3.0",
+    "transformers>=4.45.0",
+    "uvicorn>=0.30.0",
     "tqdm>=4.67.3",
+    "llama-cpp-python>=0.3.20",
 ]

server.py

@@ -0,0 +1,474 @@
+"""
+Jira Sprint Management REST API
+Built with FastAPI - allows other applications to interact with Jira programmatically
+"""
+
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel, Field
+from typing import Optional
+from datetime import datetime, timedelta, timezone
+import requests
+from requests.auth import HTTPBasicAuth
+import json
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# ================= CONFIG =================
+BASE_URL = os.environ.get("JIRA_BASE_URL", "")
+EMAIL = os.environ.get("JIRA_EMAIL", "")
+API_TOKEN = os.environ.get("JIRA_API_TOKEN", "")
+
+PROJECT_KEY = os.environ.get("JIRA_PROJECT_KEY", "SCRUM")
+BOARD_ID = int(os.environ.get("JIRA_BOARD_ID", "1"))
+
+if not BASE_URL:
+    raise ValueError("Missing required environment variable: JIRA_BASE_URL")
+if not EMAIL:
+    raise ValueError("Missing required environment variable: JIRA_EMAIL")
+if not API_TOKEN:
+    raise ValueError("Missing required environment variable: JIRA_API_TOKEN")
+
+auth = HTTPBasicAuth(EMAIL, API_TOKEN)
+headers = {
+    "Accept": "application/json",
+    "Content-Type": "application/json"
+}
+
+# ================= FASTAPI APP =================
+app = FastAPI(
+    title="Jira Sprint Management API",
+    description="REST API for managing Jira sprints, stories, and issues",
+    version="1.0.0"
+)
+
+
+# ================= REQUEST/RESPONSE MODELS =================
+class StoryCreate(BaseModel):
+    name: str = Field(..., description="Story name/summary")
+    description: Optional[str] = Field("", description="Story description")
+
+
+class SprintAddIssues(BaseModel):
+    issue_keys: list[str] = Field(..., description="List of issue keys to add to sprint")
+
+
+class IssueTransition(BaseModel):
+    status: str = Field(..., description="Status: '1'=To Do, '2'=In Progress, '3'=Testing, '4'=Done")
+    comment: Optional[str] = Field("", description="Reason/comment for the status change")
+
+
+class SprintRollover(BaseModel):
+    new_sprint_name: str = Field(..., description="Name for the new sprint")
+    add_backlog_to_new_sprint: bool = Field(
+        False,
+        description="Whether to add remaining backlog items to the new sprint"
+    )
+
+
+# ================= HELPER FUNCTIONS =================
+
+# Map simple status codes to Jira transition IDs
+STATUS_MAP = {
+    "1": {"id": "11", "name": "To Do"},
+    "2": {"id": "21", "name": "In Progress"},
+    "3": {"id": "31", "name": "Testing"},
+    "4": {"id": "41", "name": "Done"}
+}
+
+def get_transition_id(status_code):
+    """Convert simple status code (1,2,3,4) to Jira transition ID"""
+    if status_code not in STATUS_MAP:
+        raise ValueError(f"Invalid status code: {status_code}. Use 1=To Do, 2=In Progress, 3=Testing, 4=Done")
+    return STATUS_MAP[status_code]
+
+
+def get_next_saturday_friday():
+    today = datetime.now(timezone.utc)
+    days_until_sat = (5 - today.weekday()) % 7
+    if days_until_sat == 0:
+        days_until_sat = 7
+    start = today + timedelta(days=days_until_sat)
+    end = start + timedelta(days=6)
+    return (
+        start.strftime("%Y-%m-%dT%H:%M:%S.000+0000"),
+        end.strftime("%Y-%m-%dT%H:%M:%S.000+0000")
+    )
+
+
+def parse_description(desc_data):
+    """Parse Jira description JSON to plain text"""
+    if not desc_data or "content" not in desc_data:
+        return ""
+    text = ""
+    for block in desc_data.get("content", []):
+        if "content" in block:
+            for item in block["content"]:
+                if "text" in item:
+                    text += item["text"]
+    return text
+
+
+# ================= API ENDPOINTS =================
+
+@app.get("/")
+def root():
+    """API health check"""
+    return {
+        "status": "ok",
+        "message": "Jira Sprint Management API is running",
+        "version": "1.0.0"
+    }
+
+
+@app.get("/api/backlog")
+def get_backlog():
+    """
+    Get all backlog issues (issues not in any sprint and not done)
+    Returns: List of issues with id, name, description, status
+    """
+    try:
+        jql = f'project={PROJECT_KEY} AND sprint IS EMPTY AND statusCategory != Done'
+        url = f"{BASE_URL}/rest/api/3/search/jql"
+        params = {
+            "jql": jql,
+            "fields": "summary,status,description",
+            "maxResults": 100
+        }
+        res = requests.get(url, headers=headers, auth=auth, params=params)
+        res.raise_for_status()
+        issues = res.json()["issues"]
+
+        return {
+            "success": True,
+            "count": len(issues),
+            "issues": [
+                {
+                    "id": issue["key"],
+                    "name": issue["fields"]["summary"],
+                    "description": parse_description(issue["fields"].get("description")),
+                    "status": issue["fields"]["status"]["name"]
+                }
+                for issue in issues
+            ]
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to fetch backlog: {str(e)}")
+
+
+@app.post("/api/story")
+def create_story(story: StoryCreate):
+    """
+    Create a new story in Jira
+    Returns: Created issue details with id and key
+    """
+    try:
+        url = f"{BASE_URL}/rest/api/3/issue"
+        payload = {
+            "fields": {
+                "project": {"key": PROJECT_KEY},
+                "summary": story.name,
+                "issuetype": {"name": "Story"},
+                "description": {
+                    "type": "doc",
+                    "version": 1,
+                    "content": [
+                        {
+                            "type": "paragraph",
+                            "content": [
+                                {
+                                    "type": "text",
+                                    "text": story.description if story.description else "No description provided"
+                                }
+                            ]
+                        }
+                    ]
+                }
+            }
+        }
+        res = requests.post(url, headers=headers, auth=auth, data=json.dumps(payload))
+        res.raise_for_status()
+        data = res.json()
+
+        return {
+            "success": True,
+            "message": "Story created successfully",
+            "issue": {
+                "id": data["id"],
+                "key": data["key"],
+                "name": story.name,
+                "description": story.description
+            }
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to create story: {str(e)}")
+
+
+@app.get("/api/sprint/active")
+def get_active_sprint():
+    """
+    Get the current active sprint and its issues
+    Returns: Sprint details with all issues and their statuses
+    """
+    try:
+        url = f"{BASE_URL}/rest/agile/1.0/board/{BOARD_ID}/sprint?state=active"
+        res = requests.get(url, headers=headers, auth=auth)
+        res.raise_for_status()
+        sprints = res.json()["values"]
+
+        if not sprints:
+            return {
+                "success": True,
+                "active_sprint": None,
+                "message": "No active sprint found"
+            }
+
+        sprint = sprints[0]
+        sprint_id = sprint["id"]
+
+        # Get sprint issues
+        issues_url = f"{BASE_URL}/rest/agile/1.0/sprint/{sprint_id}/issue"
+        issues_res = requests.get(issues_url, headers=headers, auth=auth)
+        issues_res.raise_for_status()
+        issues = issues_res.json()["issues"]
+
+        return {
+            "success": True,
+            "active_sprint": {
+                "id": sprint["id"],
+                "name": sprint["name"],
+                "state": sprint["state"],
+                "start_date": sprint["startDate"],
+                "end_date": sprint["endDate"],
+                "issues": [
+                    {
+                        "id": issue["key"],
+                        "name": issue["fields"]["summary"],
+                        "status": issue["fields"]["status"]["name"],
+                        "status_category": issue["fields"]["status"]["statusCategory"]["name"]
+                    }
+                    for issue in issues
+                ],
+                "issue_count": len(issues)
+            }
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to fetch active sprint: {str(e)}")
+
+
+@app.post("/api/sprint/{sprint_id}/add-issues")
+def add_issues_to_sprint(sprint_id: int, body: SprintAddIssues):
+    """
+    Add issues to a sprint
+    Returns: Success message with count of added issues
+    """
+    try:
+        url = f"{BASE_URL}/rest/agile/1.0/sprint/{sprint_id}/issue"
+        payload = {"issues": body.issue_keys}
+        res = requests.post(url, headers=headers, auth=auth, data=json.dumps(payload))
+        res.raise_for_status()
+
+        return {
+            "success": True,
+            "message": f"Added {len(body.issue_keys)} issues to sprint",
+            "added_issues": body.issue_keys,
+            "sprint_id": sprint_id
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to add issues to sprint: {str(e)}")
+
+
+@app.post("/api/issue/{issue_key}/transition")
+def transition_issue(issue_key: str, body: IssueTransition):
+    """
+    Transition an issue to a new status with an optional comment/reason
+    Status codes: 1=To Do, 2=In Progress, 3=Testing, 4=Done
+    Returns: Success message
+    """
+    try:
+        # Get the Jira transition ID from simple status code
+        transition = get_transition_id(body.status)
+        transition_id = transition["id"]
+        status_name = transition["name"]
+
+        # Step 1: Perform the transition
+        url = f"{BASE_URL}/rest/api/3/issue/{issue_key}/transitions"
+        payload = {"transition": {"id": transition_id}}
+
+        res = requests.post(url, headers=headers, auth=auth, data=json.dumps(payload))
+
+        if res.status_code != 204:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Transition failed: {res.text}"
+            )
+
+        # Step 2: Add comment separately (if provided)
+        comment_added = None
+        if body.comment:
+            comment_url = f"{BASE_URL}/rest/api/3/issue/{issue_key}/comment"
+            comment_payload = {
+                "body": {
+                    "type": "doc",
+                    "version": 1,
+                    "content": [
+                        {
+                            "type": "paragraph",
+                            "content": [
+                                {"type": "text", "text": body.comment}
+                            ]
+                        }
+                    ]
+                }
+            }
+            comment_res = requests.post(comment_url, headers=headers, auth=auth, data=json.dumps(comment_payload))
+            if comment_res.status_code == 201:
+                comment_added = body.comment
+            else:
+                # Log but don't fail - transition already succeeded
+                print(f"Warning: Comment not added for {issue_key}: {comment_res.text}")
+
+        return {
+            "success": True,
+            "message": f"Issue {issue_key} moved to {status_name}",
+            "issue_key": issue_key,
+            "status": status_name,
+            "status_code": body.status,
+            "comment_added": comment_added
+        }
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to transition issue: {str(e)}")
+
+
+@app.post("/api/sprint/rollover")
+def sprint_rollover(body: SprintRollover):
+    """
+    End current sprint and start a new one
+    - Closes current sprint
+    - Carries forward unfinished issues
+    - Creates and starts new sprint
+    - Optionally adds backlog items to new sprint
+    
+    Returns: Details of the new sprint and carried forward issues
+    """
+    try:
+        # Get active sprint
+        url = f"{BASE_URL}/rest/agile/1.0/board/{BOARD_ID}/sprint?state=active"
+        res = requests.get(url, headers=headers, auth=auth)
+        res.raise_for_status()
+        sprints = res.json()["values"]
+
+        if not sprints:
+            raise HTTPException(status_code=400, detail="No active sprint to close")
+
+        active_sprint = sprints[0]
+
+        # Get sprint issues to find unfinished ones
+        issues_url = f"{BASE_URL}/rest/agile/1.0/sprint/{active_sprint['id']}/issue"
+        issues_res = requests.get(issues_url, headers=headers, auth=auth)
+        issues_res.raise_for_status()
+        sprint_issues = issues_res.json()["issues"]
+
+        # Find unfinished issues
+        unfinished = [
+            issue["key"]
+            for issue in sprint_issues
+            if issue["fields"]["status"]["statusCategory"]["name"] != "Done"
+        ]
+
+        # Close current sprint
+        close_url = f"{BASE_URL}/rest/agile/1.0/sprint/{active_sprint['id']}"
+        close_payload = {
+            "state": "closed",
+            "name": active_sprint["name"],
+            "startDate": active_sprint["startDate"],
+            "endDate": active_sprint["endDate"]
+        }
+        close_res = requests.put(close_url, headers=headers, auth=auth, data=json.dumps(close_payload))
+        if close_res.status_code != 200:
+            raise HTTPException(status_code=400, detail=f"Failed to close sprint: {close_res.text}")
+
+        # Create new sprint
+        start, end = get_next_saturday_friday()
+        create_url = f"{BASE_URL}/rest/agile/1.0/sprint"
+        create_payload = {
+            "name": body.new_sprint_name,
+            "originBoardId": BOARD_ID,
+            "startDate": start,
+            "endDate": end
+        }
+        create_res = requests.post(create_url, headers=headers, auth=auth, data=json.dumps(create_payload))
+        create_res.raise_for_status()
+        new_sprint = create_res.json()
+
+        # Start new sprint
+        start_url = f"{BASE_URL}/rest/agile/1.0/sprint/{new_sprint['id']}"
+        start_payload = {
+            "state": "active",
+            "startDate": start,
+            "endDate": end,
+            "name": body.new_sprint_name
+        }
+        start_res = requests.put(start_url, headers=headers, auth=auth, data=json.dumps(start_payload))
+        start_res.raise_for_status()
+
+        # Add carry-forward issues
+        if unfinished:
+            add_url = f"{BASE_URL}/rest/agile/1.0/sprint/{new_sprint['id']}/issue"
+            add_payload = {"issues": unfinished}
+            add_res = requests.post(add_url, headers=headers, auth=auth, data=json.dumps(add_payload))
+            add_res.raise_for_status()
+
+        # Optionally add backlog
+        added_backlog = []
+        if body.add_backlog_to_new_sprint:
+            backlog_jql = f'project={PROJECT_KEY} AND sprint IS EMPTY AND statusCategory != Done'
+            backlog_url = f"{BASE_URL}/rest/api/3/search/jql"
+            backlog_params = {"jql": backlog_jql, "maxResults": 100}
+            backlog_res = requests.get(backlog_url, headers=headers, auth=auth, params=backlog_params)
+            backlog_res.raise_for_status()
+            backlog_issues = backlog_res.json()["issues"]
+            backlog_keys = [issue["key"] for issue in backlog_issues]
+
+            if backlog_keys:
+                add_backlog_url = f"{BASE_URL}/rest/agile/1.0/sprint/{new_sprint['id']}/issue"
+                add_backlog_payload = {"issues": backlog_keys}
+                add_backlog_res = requests.post(add_backlog_url, headers=headers, auth=auth, data=json.dumps(add_backlog_payload))
+                add_backlog_res.raise_for_status()
+                added_backlog = backlog_keys
+
+        return {
+            "success": True,
+            "message": "Sprint rolled over successfully",
+            "old_sprint": {
+                "id": active_sprint["id"],
+                "name": active_sprint["name"],
+                "status": "closed"
+            },
+            "new_sprint": {
+                "id": new_sprint["id"],
+                "name": body.new_sprint_name,
+                "start_date": start,
+                "end_date": end,
+                "status": "active"
+            },
+            "carried_forward": unfinished,
+            "carried_forward_count": len(unfinished),
+            "added_from_backlog": added_backlog,
+            "backlog_count": len(added_backlog)
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to rollover sprint: {str(e)}")
+
+
+# ================= RUN =================
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8001)

telegram_agent.py

@@ -0,0 +1,479 @@
+"""
+Jira Sprint Agent — Telegram + MCP Edition
+============================================
+Stack:
+  Phi-4-Mini (llama-cpp)        → local LLM, manual tool calling (JSON)
+  MCP (stdio)                   → connects to jira_mcp_server.py
+  sentence-transformers         → local embeddings (BAAI/bge-base-en-v1.5)
+  Pinecone                      → stores every turn + tool call + tool result
+  Telegram (pyTelegramBotAPI)   → chat interface
+
+Run order:
+  Terminal 1:  python jira_mcp_server.py      (keep running)
+  Terminal 2:  python telegram_agent.py       (Telegram bot)
+"""
+
+import os
+import sys
+import json
+import uuid
+import time
+import asyncio
+import datetime
+import threading
+from llama_cpp import Llama
+from sentence_transformers import SentenceTransformer
+from pinecone import Pinecone, ServerlessSpec
+from dotenv import load_dotenv
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+import telebot
+
+load_dotenv()
+
+# ── config ────────────────────────────────────────────────────────────────────
+TELEGRAM_TOKEN = os.environ.get("TELEGRAM_TOKEN")
+PINECONE_API_KEY = os.environ.get("PINECONE_API_KEY")
+PINECONE_INDEX   = os.environ.get("PINECONE_INDEX", "jira-agent-memory")
+
+MCP_SERVER_SCRIPT = os.path.join(os.path.dirname(__file__), "jira_mcp_server.py")
+
+EMBED_DIM = 768
+
+MODEL_PATH = os.path.join(os.path.dirname(__file__), "models", "microsoft_Phi-4-mini-instruct-Q4_K_M.gguf")
+
+if not TELEGRAM_TOKEN:
+    raise ValueError("Missing required environment variable: TELEGRAM_TOKEN")
+if not PINECONE_API_KEY:
+    raise ValueError("Missing required environment variable: PINECONE_API_KEY")
+
+# ── Telegram bot ─────────────────────────────────────────────────────────────
+bot = telebot.TeleBot(TELEGRAM_TOKEN, parse_mode=None)
+
+# Per-user conversation state: {chat_id: {"session": ClientSession, "openai_tools": [...], "messages": [...]}}
+user_sessions = {}
+loop_ref = None  # will hold the asyncio event loop
+
+# ── local embedder ────────────────────────────────────────────────────────────
+print("  Loading embedding model...")
+_embedder = SentenceTransformer("BAAI/bge-base-en-v1.5", device="cpu")
+print("  Embedding model ready.\n")
+
+def embed(text: str) -> list[float]:
+    vec = _embedder.encode(text[:8000], normalize_embeddings=True)
+    return vec.tolist()
+
+# ── local model loader ───────────────────────────────────────────────────────
+if not os.path.exists(MODEL_PATH):
+    print(f"  Model not found at {MODEL_PATH}")
+    print("  Downloading from HuggingFace (bartowski/Phi-4-mini-instruct-GGUF)...\n")
+    print("  This is ~2.2 GB — may take a few minutes depending on your connection.\n")
+    models_dir = os.path.dirname(MODEL_PATH)
+    os.makedirs(models_dir, exist_ok=True)
+    from huggingface_hub import hf_hub_download
+    downloaded_path = hf_hub_download(
+        repo_id="bartowski/Phi-4-mini-instruct-GGUF",
+        filename="Phi-4-mini-instruct-Q4_K_M.gguf",
+        local_dir=models_dir,
+        local_dir_use_symlinks=False,
+    )
+    # Move to expected path if needed
+    if downloaded_path != MODEL_PATH and not os.path.exists(MODEL_PATH):
+        import shutil
+        shutil.move(downloaded_path, MODEL_PATH)
+    print("\n  Download complete.\n")
+
+print("  Loading local model...")
+print(f"  Model: {MODEL_PATH}")
+print("  This may take 10-30 seconds on first run...\n")
+
+llm = Llama(
+    model_path=MODEL_PATH,
+    n_ctx=8192,
+    n_threads=4,
+    n_batch=512,
+    n_gpu_layers=0,
+    verbose=False,
+    temperature=0.2,
+)
+print("  Model loaded successfully.\n")
+
+# ── pinecone ──────────────────────────────────────────────────────────────────
+pc = Pinecone(api_key=PINECONE_API_KEY)
+existing = [i.name for i in pc.list_indexes()]
+if PINECONE_INDEX not in existing:
+    print(f"  Creating Pinecone index '{PINECONE_INDEX}' (dim={EMBED_DIM})...")
+    pc.create_index(
+        name=PINECONE_INDEX,
+        dimension=EMBED_DIM,
+        metric="cosine",
+        spec=ServerlessSpec(cloud="aws", region="us-east-1"),
+    )
+    print("  Index created.\n")
+
+pine_index = pc.Index(PINECONE_INDEX)
+
+
+def store(user_input: str, agent_reply: str, tool_name: str,
+          tool_args: dict, tool_result: dict):
+    doc = (
+        f"User: {user_input}\n"
+        f"Agent: {agent_reply}\n"
+        f"Tool called: {tool_name}\n"
+        f"Tool args: {json.dumps(tool_args)}\n"
+        f"Tool result: {json.dumps(tool_result)}"
+    )
+    pine_index.upsert(vectors=[{
+        "id": str(uuid.uuid4()),
+        "values": embed(doc),
+        "metadata": {
+            "doc": doc,
+            "user_input": user_input,
+            "agent_reply": agent_reply,
+            "tool_name": tool_name,
+            "tool_args": json.dumps(tool_args),
+            "tool_result": json.dumps(tool_result),
+            "timestamp": datetime.datetime.utcnow().isoformat(),
+        },
+    }])
+
+
+def recall(user_input: str, top_k: int = 2) -> str:
+    stats = pine_index.describe_index_stats()
+    total = stats.get("total_vector_count", 0)
+    if total == 0:
+        return ""
+    results = pine_index.query(
+        vector=embed(user_input),
+        top_k=min(top_k, total),
+        include_metadata=True,
+    )
+    matches = results.get("matches", [])
+    if not matches:
+        return ""
+    chunks = [
+        f"[past interaction]\n{m['metadata'].get('user_input', '')} → {m['metadata'].get('tool_name', 'no tool')}"
+        for m in matches if m.get('score', 0) > 0.5
+    ]
+    if not chunks:
+        return ""
+    return "\nRECENT SIMILAR REQUESTS (for context only, do NOT reuse old data):\n" + "\n---\n".join(chunks) + "\n"
+
+
+def mcp_tools_to_openai_schema(mcp_tools) -> list[dict]:
+    tools = []
+    for t in mcp_tools:
+        tools.append({
+            "type": "function",
+            "function": {
+                "name": t.name,
+                "description": t.description or "",
+                "parameters": t.inputSchema or {"type": "object", "properties": {}},
+            },
+        })
+    return tools
+
+
+# ── agent turn (returns final reply string) ───────────────────────────────────
+async def agent_turn_async(session, openai_tools, user_input: str, chat_id: int) -> str:
+    """Run one full agent turn. Returns the final reply for the user."""
+
+    memory_block = recall(user_input)
+
+    tool_descriptions = ""
+    for t in openai_tools:
+        params = t["function"].get("parameters", {})
+        req = params.get("required", [])
+        props = params.get("properties", {})
+        param_str = ", ".join([f"{k}" + (" (required)" if k in req else "") for k in props.keys()]) if props else "none"
+        tool_descriptions += f"- {t['function']['name']}: {t['function']['description']} | params: {param_str}\n"
+
+    tool_descriptions += """
+IMPORTANT: For add_issues_to_sprint, sprint_id must be a NUMBER (integer), NOT "current".
+If you don't know the sprint_id, first call get_active_sprint to find the sprint ID, then use that number.
+"""
+
+    system_prompt = f"""You are an intelligent Jira Sprint Management AI Agent.
+
+You have these tools available to you. To call a tool, respond with ONLY a JSON object in this exact format:
+{{"tool": "<tool_name>", "arguments": {{"<param>": "<value>"}}}}
+
+Available tools:
+{tool_descriptions}
+
+RULES:
+1. For ANY query about Jira data, you MUST call one of the tools above by responding with JSON.
+2. Do NOT make up Jira data. Only report what the tool returns.
+3. If the user asks for something that doesn't need a tool (e.g. greeting), just respond normally.
+4. After the tool result comes back, summarize it concisely for the user.
+5. Be concise.
+
+{memory_block}"""
+
+    final_reply = ""
+    tool_calls_parsed = []
+    all_results = []
+
+    # Build messages for this turn (do NOT pollute with old internal tool messages)
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user",   "content": user_input},
+    ]
+    # Add clean conversation history (only user/assistant exchanges, max 6 turns)
+    user_sessions.setdefault(chat_id, {"messages": []})
+    clean_history = []
+    for m in user_sessions[chat_id]["messages"]:
+        if m["role"] in ("user", "assistant"):
+            clean_history.append(m)
+    messages.extend(clean_history[-6:])
+
+    tool_name   = "none"
+    tool_args   = {}
+    tool_result = {}
+    final_reply = ""
+    tool_calls_parsed = []
+    all_results = []
+
+    max_tool_rounds = 5
+    for _ in range(max_tool_rounds):
+        try:
+            response = llm.create_chat_completion(
+                messages=messages,
+                max_tokens=1024,
+                temperature=0.2,
+                top_p=0.9,
+            )
+
+            choice = response['choices'][0]
+            message = choice['message']
+            response_text = message.get("content", "")
+
+            # Strip <think> blocks
+            if "<think>" in response_text and "</think>" in response_text:
+                response_text = response_text[response_text.rfind("</think>") + len("</think>"):].strip()
+
+            # Parse ONE or MORE JSON tool calls
+            tool_calls_parsed = []
+            remaining = response_text
+            while True:
+                json_start = remaining.find("{")
+                if json_start < 0:
+                    break
+                remaining = remaining[json_start:]
+                depth = 0
+                json_end = -1
+                for i, ch in enumerate(remaining):
+                    if ch == "{":
+                        depth += 1
+                    elif ch == "}":
+                        depth -= 1
+                        if depth == 0:
+                            json_end = i + 1
+                            break
+                if json_end < 0:
+                    break
+                try:
+                    parsed = json.loads(remaining[:json_end])
+                    if "tool" in parsed:
+                        tool_calls_parsed.append(parsed)
+                except json.JSONDecodeError:
+                    pass
+                remaining = remaining[json_end:]
+
+            # Model wants to call tools
+            if tool_calls_parsed:
+                all_results = []
+                for tc in tool_calls_parsed:
+                    tool_name = tc.get("tool", "unknown")
+                    tool_args = tc.get("arguments", {})
+
+                    print(f"\n  → MCP tool: {tool_name}({json.dumps(tool_args)})")
+
+                    result = await session.call_tool(tool_name, arguments=tool_args)
+
+                    if result.content and len(result.content) > 0:
+                        raw_result = result.content[0].text if hasattr(result.content[0], "text") else str(result.content[0])
+                        try:
+                            tool_result = json.loads(raw_result)
+                        except json.JSONDecodeError:
+                            tool_result = {"raw": raw_result}
+                    else:
+                        tool_result = {}
+
+                    print(f"     result: {json.dumps(tool_result, indent=2)}\n")
+                    all_results.append((tool_name, tool_result))
+
+                messages.append({
+                    "role": "assistant",
+                    "content": response_text,
+                })
+
+                results_text_parts = []
+                for tn, tr in all_results:
+                    results_text_parts.append(f"Tool {tn} returned: {json.dumps(tr)}")
+
+                has_sprint_id_error = any(
+                    "sprint_id" in json.dumps(tr).lower() and ("integer" in json.dumps(tr).lower() or "int_parsing" in json.dumps(tr).lower())
+                    for _, tr in all_results
+                )
+                if has_sprint_id_error:
+                    messages.append({
+                        "role": "user",
+                        "content": f"{' | '.join(results_text_parts)}\n\nThe sprint_id must be a number. First call get_active_sprint to find the current sprint ID, then use that number.",
+                    })
+                else:
+                    messages.append({
+                        "role": "user",
+                        "content": f"{' | '.join(results_text_parts)}\n\nNow summarize the results for the user concisely.",
+                    })
+
+            # Model gave final text answer
+            else:
+                final_reply = response_text
+                print(f"\n  Agent: {final_reply}\n")
+                break
+
+        except Exception as e:
+            err = str(e).lower()
+            if "out of memory" in err:
+                print("  Memory error...\n")
+                return "Sorry, I ran into a memory error. Please try again."
+            print(f"  Model Error: {str(e)[:300]}\n")
+            return f"Sorry, I ran into an error: {str(e)[:200]}"
+
+    # Store in Pinecone
+    if all_results:
+        last_tool_name, last_tool_res = all_results[-1]
+        last_tool_args_dict = tool_calls_parsed[-1].get("arguments", {}) if tool_calls_parsed else {}
+        store(user_input, final_reply, last_tool_name, last_tool_args_dict, last_tool_res)
+    else:
+        store(user_input, final_reply, "none", {}, {})
+
+    # Save conversation history (keep last 10 turns)
+    user_sessions[chat_id]["messages"].append({"role": "user", "content": user_input})
+    user_sessions[chat_id]["messages"].append({"role": "assistant", "content": final_reply})
+    if len(user_sessions[chat_id]["messages"]) > 20:
+        user_sessions[chat_id]["messages"] = user_sessions[chat_id]["messages"][-20:]
+
+    return final_reply
+
+
+# ── Telegram handlers ─────────────────────────────────────────────────────────
+@bot.message_handler(commands=['start'])
+def cmd_start(message):
+    name = message.from_user.first_name or "there"
+    bot.reply_to(message,
+        f"Hey {name}! 👋\n\n"
+        f"I'm your Jira Sprint Manager. I can help you:\n"
+        f"• View the backlog\n"
+        f"• Check active sprint progress\n"
+        f"• Create stories/tasks\n"
+        f"• Move issues between sprints\n"
+        f"• Transition issue status (To Do → In Progress → Testing → Done)\n"
+        f"• Close & rollover sprints\n\n"
+        f"Just ask me anything!"
+    )
+
+
+@bot.message_handler(commands=['memory'])
+def cmd_memory(message):
+    """Search Pinecone memory."""
+    parts = message.text.split(None, 1)
+    if len(parts) < 2:
+        bot.reply_to(message, "Usage: /memory <search query>")
+        return
+    query = parts[1]
+    result = recall(query, top_k=5)
+    if result:
+        # Truncate if too long for Telegram
+        reply = result[:4000]
+        bot.reply_to(message, reply)
+    else:
+        bot.reply_to(message, "Nothing found in memory.")
+
+
+@bot.message_handler(func=lambda m: True)
+def handle_message(message):
+    """Handle all other messages — run the agent."""
+    user_input = message.text.strip()
+    chat_id = message.chat.id
+    username = message.from_user.first_name or message.from_user.username or "User"
+
+    if not user_input:
+        return
+
+    # Log user message to terminal for debugging
+    print(f"\n{'='*50}")
+    print(f"  Telegram [{username}]: {user_input}")
+    print(f"{'='*50}\n")
+
+    # Show "typing" indicator
+    bot.send_chat_action(chat_id, "typing")
+
+    # Schedule the async agent turn on the event loop
+    future = asyncio.run_coroutine_threadsafe(
+        agent_turn_async(mcp_session_ref, openai_tools_ref, user_input, chat_id),
+        loop_ref,
+    )
+    reply = future.result(timeout=120)  # wait up to 2 minutes
+
+    # Send reply (split if too long for Telegram's 4096 char limit)
+    chunks = [reply[i:i+4000] for i in range(0, len(reply), 4000)] if reply else ["..."]
+    for chunk in chunks:
+        bot.send_message(chat_id, chunk)
+
+
+# ── main entry: start MCP + Telegram ─────────────────────────────────────────
+mcp_session_ref = None
+openai_tools_ref = None
+
+async def main_async():
+    global mcp_session_ref, openai_tools_ref, loop_ref
+    loop_ref = asyncio.get_event_loop()
+
+    server_params = StdioServerParameters(
+        command=sys.executable,
+        args=[MCP_SERVER_SCRIPT],
+        env={**os.environ},
+    )
+
+    async with stdio_client(server_params) as (read, write):
+        async with ClientSession(read, write) as session:
+            await session.initialize()
+
+            tools_response = await session.list_tools()
+            mcp_tools    = tools_response.tools
+            openai_tools = mcp_tools_to_openai_schema(mcp_tools)
+
+            # Store refs for the Telegram thread
+            mcp_session_ref = session
+            openai_tools_ref = openai_tools
+
+            stats = pine_index.describe_index_stats()
+            total = stats.get("total_vector_count", 0)
+
+            print("=" * 60)
+            print("  Jira Agent (Telegram + MCP)  |  Phi-4-Mini (local)")
+            print(f"  MCP tools  |  {[t.name for t in mcp_tools]}")
+            print(f"  Memory     |  {total} interactions in Pinecone")
+            print("=" * 60 + "\n")
+
+            # Start Telegram bot in a background thread
+            def run_telegram():
+                print("  Telegram bot started.\n")
+                bot.infinity_polling()
+
+            telegram_thread = threading.Thread(target=run_telegram, daemon=True)
+            telegram_thread.start()
+
+            # Keep the asyncio loop alive
+            try:
+                while True:
+                    await asyncio.sleep(1)
+            except (KeyboardInterrupt, SystemExit):
+                print("\nShutting down...")
+                bot.stop_polling()
+
+
+if __name__ == "__main__":
+    asyncio.run(main_async())