Upload 8 files

.gitignore

@@ -0,0 +1,5 @@
+__pycache__/
+*.pyc
+tasks.db
+*.csv
+.env

LICENSE

@@ -0,0 +1 @@
+MIT

README.md

@@ -1,26 +1,34 @@
+# FullTrack AI — Hugging Face Space (MVP)
 
----
-title: "🏏 FullTrack AI – Fixed Calibrated MVP"
-emoji: 🏏
-colorFrom: blue
-colorTo: indigo
-sdk: gradio
-sdk_version: "4.31.0"
-app_file: app.py
-pinned: true
----
+This repository contains a lightweight FullTrack AI MVP packaged as a **Hugging Face Space** using **Gradio**.
 
-# FullTrack AI – Fixed Calibrated MVP (Hugging Face Space)
+## Features
+- AI chat interface (uses OpenAI by default)
+- AI-parsed actions (create_task, create_project)
+- SQLite-backed task storage
+- Dashboard pie chart
+- Export tasks to CSV
 
-This package fixes the earlier runtime error by removing usage of non-installed libraries (e.g., ultralytics) and adding a robust click-to-select calibration flow that works with modern Gradio versions.
+## Files
+- `app.py` — Gradio app entrypoint
+- `ai.py` — OpenAI wrapper + JSON action parser
+- `db.py` — SQLite helper functions
+- `requirements.txt` — Python dependencies
 
-Files:
-- app.py (main Gradio app)
-- requirements.txt
-- README.md
+## Deploy to Hugging Face Spaces
+1. Create a new Space on Hugging Face: choose **Gradio** and **Python**.
+2. Upload all files from this repo.
+3. In the Space settings, add a secret named `OPENAI_API_KEY` with your OpenAI API key.
+4. (Optional) set `OPENAI_MODEL` to your preferred model (default: `gpt-4o-mini`).
+5. Click **Deploy**.
 
-How to deploy:
-1. Create a new Space (Gradio) on Hugging Face.
-2. Upload these files and run the Space.
-3. Use the "Calibration" tab to click 4 points on a frame, then go to Analysis and run on a video.
+## Local Run (for testing)
+1. Create and activate a venv: `python -m venv .venv && source .venv/bin/activate`
+2. Install: `pip install -r requirements.txt`
+3. Set `OPENAI_API_KEY` env var.
+4. Run: `python app.py`
 
+## Notes & Limitations
+- This is an MVP intended for prototyping inside Hugging Face Spaces.
+- The login is simulated (uses a static demo user).
+- Be cautious with OpenAI API usage and costs.

ai.py

@@ -0,0 +1,62 @@
+import os, re, json
+import openai
+
+openai.api_key = os.getenv("OPENAI_API_KEY")
+
+SYSTEM_PROMPT = """You are FullTrack AI, an assistant for project and task tracking.
+Be concise. When the user issues commands that create or update tasks or projects, respond with:
+1) A human-friendly reply.
+2) A JSON code block labeled ```json``` containing an object with an "actions" array.
+Each action must be an object: {"type": <string>, "confidence": <0-1 float>, "payload": {...}}.
+Supported action types for this Space: create_task, create_project.
+Use low temperature and deterministic outputs for parsing.
+"""
+
+def ask_ai(message, history):
+    # Build messages; include recent history for context
+    messages = [{"role":"system","content":SYSTEM_PROMPT}]
+    if history:
+        # history is list of (user, assistant)
+        for u, a in history[-6:]:
+            messages.append({"role":"user","content":u})
+            messages.append({"role":"assistant","content":a})
+    messages.append({"role":"user","content":message})
+
+    try:
+        resp = openai.ChatCompletion.create(
+            model=os.getenv("OPENAI_MODEL","gpt-4o-mini"),
+            messages=messages,
+            temperature=0.1,
+            max_tokens=600
+        )
+        content = resp.choices[0].message.get("content","")
+        return content
+    except Exception as e:
+        return f"[Error calling OpenAI API: {e}]"
+
+def parse_actions(reply_text):
+    # Extract JSON block labeled ```json ... ```
+    try:
+        m = re.search(r"```json\s*(\{.*?\})\s*```", reply_text, re.S)
+        if not m:
+            # fallback: try to find first JSON-like object
+            m = re.search(r"(\{\s*\"actions\"\s*:\s*\[.*?\])\s*\}", reply_text, re.S)
+            if m:
+                json_text = m.group(0)
+            else:
+                return []
+        else:
+            json_text = m.group(1)
+        data = json.loads(json_text)
+        actions = data.get("actions", [])
+        # sanitize actions: ensure keys exist
+        cleaned = []
+        for a in actions:
+            if not isinstance(a, dict): continue
+            atype = a.get("type")
+            conf = float(a.get("confidence", 0.0))
+            payload = a.get("payload", {})
+            cleaned.append({"type": atype, "confidence": conf, "payload": payload})
+        return cleaned
+    except Exception:
+        return []

app.py

@@ -1,51 +1,99 @@
 import gradio as gr
-import cv2
-import tempfile
-from ultralytics import YOLO
+from ai import ask_ai, parse_actions
+from db import init_db, add_task, get_dashboard_fig, list_tasks, export_tasks_csv
+import os
 
-# Load YOLOv8 model
-model = YOLO("yolov8n.pt")
+init_db()
 
-# Function for object detection + tracking
-def detect_and_track(video_file):
-    if video_file is None:
-        return None
+DEFAULT_USER = "demo_user"
 
-    cap = cv2.VideoCapture(video_file.name)
-    output_path = tempfile.mktemp(suffix=".mp4")
+def chat_and_handle(message, history, user=DEFAULT_USER):
+    # Save user message to history
+    history = history or []
+    history.append((message, ""))
 
-    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-    fps = cap.get(cv2.CAP_PROP_FPS) or 25.0
-    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    # Call AI
+    reply = ask_ai(message, history)
+    # Parse actions
+    actions = parse_actions(reply)
 
-    out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+    applied = []
+    suggestions = []
+    for act in actions:
+        t = act.get("type")
+        conf = act.get("confidence", 0)
+        payload = act.get("payload", {})
+        if t == "create_task" and payload.get("title"):
+            # For safety, only auto-apply if confidence high
+            if conf >= 0.9:
+                add_task(user, payload)
+                applied.append(payload.get("title"))
+            else:
+                suggestions.append(payload)
+        elif t == "create_project":
+            # projects are treated as tasks with tag 'project' in this simple MVP
+            if payload.get("name"):
+                add_task(user, {"title": f"Project: {payload.get('name')}", "tags": ["project"]})
+                applied.append(f"Project: {payload.get('name')}")
+        else:
+            # unsupported action types are returned as suggestions
+            suggestions.append(act)
 
-    while True:
-        ret, frame = cap.read()
-        if not ret:
-            break
+    final_reply_lines = [reply.strip()]
+    if applied:
+        final_reply_lines.append("\n\nApplied actions (auto):")
+        for a in applied:
+            final_reply_lines.append("- " + a)
+    if suggestions:
+        final_reply_lines.append("\n\nSuggested actions (please confirm manually):")
+        for s in suggestions:
+            final_reply_lines.append("- " + (s.get("title") if isinstance(s, dict) else str(s)))
 
-        results = model.track(frame, persist=True, verbose=False)
-        annotated_frame = results[0].plot()
-        out.write(annotated_frame)
+    final_reply = "\n".join(final_reply_lines)
 
-    cap.release()
-    out.release()
-    return output_path  # must return path for gr.Video
+    # update history with assistant reply
+    history[-1] = (message, final_reply)
 
-# Gradio UI
-with gr.Blocks() as demo:
-    gr.Markdown("# 🎯 FullTrack AI - Object Tracking\nUpload a video to run YOLOv8 tracking with trajectory predictions.")
+    # dashboard figure
+    fig = get_dashboard_fig(user)
+    tasks = list_tasks(user)
+    return history, final_reply, fig, tasks
+
+def export_csv(user=DEFAULT_USER):
+    path = export_tasks_csv(user)
+    return path
+
+with gr.Blocks(title="FullTrack AI — Hugging Face Space (MVP)") as demo:
+    gr.Markdown("""# 🚀 FullTrack AI — Hugging Face Space (MVP)
+    This Space demonstrates an AI-driven task/project tracker MVP.
+    - Type instructions in the chat (e.g. "Create a project Website Redesign and 3 tasks due next week assigned to Raj.")
+    - The assistant will reply and propose actions in JSON. High-confidence task creations are auto-applied.
+    """)
 
     with gr.Row():
-        with gr.Column():
-            video_in = gr.File(label="Upload a Video", file_types=[".mp4", ".avi", ".mov"])
-            btn = gr.Button("Submit", variant="primary")
-        with gr.Column():
-            video_out = gr.Video(label="Tracked Output")
+        with gr.Column(scale=2):
+            chatbot = gr.Chatbot([], elem_id="chatbot")
+            msg = gr.Textbox(placeholder="Type a message and press Enter", lines=2)
+            send_btn = gr.Button("Send")
+            clear_btn = gr.Button("Clear chat")
+        with gr.Column(scale=1):
+            gr.Markdown("### Dashboard")
+            dash_plot = gr.Plot()
+            gr.Markdown("### Tasks (latest)")
+            tasks_table = gr.Dataframe(headers=["id","title","status","created_at"], interactive=False)
+            export_button = gr.Button("Export CSV")
+            export_path = gr.Textbox(label="Export path", interactive=False)
+
+    def on_send(message, history):
+        return chat_and_handle(message, history)
+
+    def on_clear():
+        return [], "", None, []
 
-    btn.click(detect_and_track, inputs=video_in, outputs=video_out)
+    msg.submit(on_send, inputs=[msg, chatbot], outputs=[chatbot, gr.Textbox(), dash_plot, tasks_table])
+    send_btn.click(on_send, inputs=[msg, chatbot], outputs=[chatbot, gr.Textbox(), dash_plot, tasks_table])
+    clear_btn.click(on_clear, outputs=[chatbot, gr.Textbox(), dash_plot, tasks_table])
+    export_button.click(export_csv, outputs=[export_path])
 
 if __name__ == "__main__":
     demo.launch()

db.py

@@ -0,0 +1,73 @@
+import sqlite3, os, datetime, csv
+import matplotlib.pyplot as plt
+
+DB_PATH = os.path.join(os.path.dirname(__file__), "tasks.db")
+
+def init_db():
+    conn = sqlite3.connect(DB_PATH)
+    c = conn.cursor()
+    c.execute("""CREATE TABLE IF NOT EXISTS tasks (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        user TEXT,
+        title TEXT,
+        description TEXT,
+        status TEXT,
+        tags TEXT,
+        created_at TEXT
+    )""")
+    conn.commit()
+    conn.close()
+
+def add_task(user, payload):
+    title = payload.get("title") or payload.get("name") or "Untitled"
+    desc = payload.get("description", "")
+    status = payload.get("status", "todo")
+    tags = ",".join(payload.get("tags", [])) if isinstance(payload.get("tags"), list) else (payload.get("tags") or "")
+    created_at = datetime.datetime.utcnow().isoformat()
+    conn = sqlite3.connect(DB_PATH)
+    c = conn.cursor()
+    c.execute("INSERT INTO tasks (user, title, description, status, tags, created_at) VALUES (?,?,?,?,?,?)",
+              (user, title, desc, status, tags, created_at))
+    conn.commit()
+    conn.close()
+
+def list_tasks(user, limit=20):
+    conn = sqlite3.connect(DB_PATH)
+    c = conn.cursor()
+    c.execute("SELECT id, title, status, created_at FROM tasks WHERE user=? ORDER BY id DESC LIMIT ?", (user, limit))
+    rows = c.fetchall()
+    conn.close()
+    return rows
+
+def get_dashboard_fig(user):
+    conn = sqlite3.connect(DB_PATH)
+    c = conn.cursor()
+    c.execute("SELECT status, COUNT(*) FROM tasks WHERE user=? GROUP BY status", (user,))
+    rows = c.fetchall()
+    conn.close()
+    statuses = [r[0] for r in rows] if rows else []
+    counts = [r[1] for r in rows] if rows else []
+    if not rows:
+        # empty fig
+        fig, ax = plt.subplots()
+        ax.text(0.5, 0.5, 'No tasks yet', horizontalalignment='center', verticalalignment='center', fontsize=12)
+        ax.axis('off')
+        return fig
+    fig, ax = plt.subplots()
+    ax.pie(counts, labels=statuses, autopct='%1.1f%%')
+    ax.set_title('Tasks by Status')
+    return fig
+
+def export_tasks_csv(user):
+    path = os.path.join(os.path.dirname(__file__), f"tasks_export_{user}.csv")
+    conn = sqlite3.connect(DB_PATH)
+    c = conn.cursor()
+    c.execute("SELECT id, title, description, status, tags, created_at FROM tasks WHERE user=? ORDER BY id DESC", (user,))
+    rows = c.fetchall()
+    conn.close()
+    with open(path, 'w', newline='', encoding='utf-8') as f:
+        writer = csv.writer(f)
+        writer.writerow(["id","title","description","status","tags","created_at"])
+        for r in rows:
+            writer.writerow(r)
+    return path

env.example

@@ -0,0 +1,3 @@
+# Copy to .env and fill
+OPENAI_API_KEY=sk-...
+OPENAI_MODEL=gpt-4o-mini

requirements.txt

@@ -1,6 +1,3 @@
-
-ultralytics
-opencv-python-headless
-gradio
-pandas>=2.2.2
-matplotlib>=3.8.4
+gradio>=3.0
+openai
+matplotlib