Refactor code structure for improved readability and maintainability

.gitignore

@@ -0,0 +1,4 @@
+data/*
+plan.md
+__pycache__/
+*.log

.python-version

@@ -0,0 +1 @@
+3.11

app.py

@@ -1,5 +1,77 @@
+import os
+from pathlib import Path
+from typing import Dict, List, Tuple
+
 import gradio as gr
-from huggingface_hub import InferenceClient
+
+from smolagents import CodeAgent, OpenAIModel
+
+from tools import create_task
+from helper import (
+    add_row_to_csv,
+    generate_unique_id,
+    get_current_timestamp,
+    get_csv_headers,
+    get_csv_path,
+    read_csv_as_dicts
+)
+
+
+
+
+def append_conversation_entry(role: str, content: str, tags: str = "") -> None:
+    """
+    Append a single conversation message to conversations.csv.
+
+    Columns: id, timestamp, role, content, tags
+    """
+    # Get the CSV path using helper
+    csv_path = get_csv_path("conversations")
+    
+    # Generate message data
+    message_data: Dict[str, str] = {
+        "id": generate_unique_id("msg"),
+        "timestamp": get_current_timestamp(),
+        "role": role,
+        "content": content,
+        "tags": tags,
+    }
+    
+    # Add row to CSV using helper
+    add_row_to_csv(csv_path, message_data)
+
+
+
+
+model = OpenAIModel(
+    model_id="Qwen/Qwen3-Coder-480B-A35B-Instruct",
+    api_base="https://api.tokenfactory.nebius.com/v1/",
+    api_key=os.environ.get("NEBIUS_API_KEY"),
+)
+
+# Get CSV schema information
+csv_schema_info = get_csv_headers()
+
+agent = CodeAgent(
+    tools=[],
+    model=model,
+    stream_outputs=True,
+    instructions=(
+        "You are a friendly chatbot with access to structured data.\n\n"
+        "Available CSV files:\n"
+        f"{csv_schema_info}\n\n"
+        "You can use pandas to analyze this data. The CSV files are located in the 'data/' directory.\n"
+        "Example operations you can perform:\n"
+        "- pd.read_csv('data/conversations.csv').query(\"role == 'user'\")\n"
+        "- pd.read_csv('data/tasks.csv').query(\"status == 'pending'\")\n"
+        "- pd.read_csv('data/conversations.csv')['content'].tolist()\n\n"
+        "You can also create tasks by calling the `create_task` tool when the user "
+        "asks you to remember something or schedule a reminder.\n"
+        "Confirm task details in natural language after calling the tool."
+    ),
+    additional_authorized_imports=["pandas", "numpy"],
+    max_steps=10,
+)
 
 
 def respond(
@@ -12,32 +84,18 @@ def respond(
     hf_token: gr.OAuthToken,
 ):
     """
-    For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
+    Uses smolagents CodeAgent to process the user message.
+    The agent can chat normally and, when appropriate, call the
+    `create_task` tool to append a new row to tasks.csv.
     """
-    client = InferenceClient(token=hf_token.token, model="openai/gpt-oss-20b")
-
-    messages = [{"role": "system", "content": system_message}]
-
-    messages.extend(history)
+    append_conversation_entry(role="user", content=message)
 
-    messages.append({"role": "user", "content": message})
+    prompt = f"{system_message}\n\nUser: {message}"
 
-    response = ""
-
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        choices = message.choices
-        token = ""
-        if len(choices) and choices[0].delta.content:
-            token = choices[0].delta.content
-
-        response += token
-        yield response
+    result = agent.run(prompt)
+    response = str(result) if result is not None else ""
+    append_conversation_entry(role="assistant", content=response)
+    yield response
 
 
 """
@@ -65,6 +123,56 @@ with gr.Blocks() as demo:
         gr.LoginButton()
     chatbot.render()
 
+    refresh_btn = gr.Button("Refresh CSV views")
+
+    with gr.Tab("Conversations CSV"):
+        conversations_df = gr.Dataframe(
+            label="conversations.csv",
+            interactive=False,
+            wrap=False,
+        )
+    with gr.Tab("Tasks CSV"):
+        tasks_df = gr.Dataframe(
+            label="tasks.csv",
+            interactive=False,
+            wrap=False,
+        )
+    with gr.Tab("Memories CSV"):
+        memories_df = gr.Dataframe(
+            label="memories.csv",
+            interactive=False,
+            wrap=False,
+        )
+
+    def load_csv_paths() -> Tuple[List[Dict], List[Dict], List[Dict]]:
+        """Load data from CSV files for display"""
+        conversations_path = get_csv_path("conversations")
+        tasks_path = get_csv_path("tasks")
+        memories_path = get_csv_path("memories")
+        
+        # Read CSV data using helper
+        conversations_data = read_csv_as_dicts(conversations_path)
+        tasks_data = read_csv_as_dicts(tasks_path)
+        memories_data = read_csv_as_dicts(memories_path)
+        
+        return (
+            conversations_data,
+            tasks_data,
+            memories_data,
+        )
+
+    refresh_btn.click(
+        fn=load_csv_paths,
+        inputs=None,
+        outputs=[conversations_df, tasks_df, memories_df],
+    )
+
+    demo.load(
+        fn=load_csv_paths,
+        inputs=None,
+        outputs=[conversations_df, tasks_df, memories_df],
+    )
+
 
 if __name__ == "__main__":
     demo.launch()

helper.py

@@ -0,0 +1,220 @@
+import csv
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+import pandas as pd
+
+
+DATA_DIR = Path(__file__).parent / "data"
+
+
+def get_csv_path(csv_name: str) -> Path:
+    """
+    Get the full path for a CSV file in the data directory.
+    
+    Args:
+        csv_name: Name of the CSV file (with or without .csv extension)
+    
+    Returns:
+        Path object for the CSV file in the data directory
+    """
+    if not csv_name.endswith('.csv'):
+        csv_name = f"{csv_name}.csv"
+    
+    return DATA_DIR / csv_name
+
+
+def ensure_csv_exists(
+    csv_path: Path, 
+    fieldnames: List[str], 
+    overwrite: bool = False
+) -> bool:
+    """
+    Ensure a CSV file exists with the specified fieldnames.
+    
+    Args:
+        csv_path: Path to the CSV file
+        fieldnames: List of column headers for the CSV
+        overwrite: If True, will overwrite existing file with headers only
+    
+    Returns:
+        True if file was created or headers were written, False if file already exists
+    """
+    # Ensure data directory exists
+    csv_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    # Check if file exists
+    file_exists = csv_path.exists()
+    
+    # If file doesn't exist or we want to overwrite, create/write headers
+    if not file_exists or overwrite:
+        with csv_path.open("w", newline="", encoding="utf-8") as f:
+            writer = csv.DictWriter(f, fieldnames=fieldnames)
+            writer.writeheader()
+        return True
+    
+    return False
+
+
+def add_row_to_csv(
+    csv_path: Path,
+    row_data: Dict[str, Any],
+    fieldnames: Optional[List[str]] = None
+) -> None:
+    """
+    Add a row to a CSV file, creating the file if it doesn't exist.
+    
+    Args:
+        csv_path: Path to the CSV file
+        row_data: Dictionary containing the data to add
+        fieldnames: Optional list of column headers. If not provided,
+                   will use keys from row_data
+    """
+    # Use row_data keys if fieldnames not provided
+    if fieldnames is None:
+        fieldnames = list(row_data.keys())
+    
+    # Ensure CSV exists with headers
+    ensure_csv_exists(csv_path, fieldnames)
+    
+    # Append the new row
+    with csv_path.open("a", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=fieldnames)
+        writer.writerow(row_data)
+
+
+def read_csv_as_dicts(csv_path: Path) -> List[Dict[str, Any]]:
+    """
+    Read a CSV file and return a list of dictionaries.
+    
+    Args:
+        csv_path: Path to the CSV file
+        
+    Returns:
+        List of dictionaries representing the CSV rows
+    """
+    if not csv_path.exists():
+        return []
+    
+    with csv_path.open("r", encoding="utf-8") as f:
+        reader = csv.DictReader(f)
+        return list(reader)
+
+
+def find_row_in_csv(
+    csv_path: Path,
+    key_field: str,
+    value: Any
+) -> Optional[Dict[str, Any]]:
+    """
+    Find a row in a CSV file based on a key field value.
+    
+    Args:
+        csv_path: Path to the CSV file
+        key_field: The column to search in
+        value: The value to search for
+        
+    Returns:
+        The matching row as a dictionary, or None if not found
+    """
+    rows = read_csv_as_dicts(csv_path)
+    
+    for row in rows:
+        if row.get(key_field) == str(value):
+            return row
+    
+    return None
+
+
+def update_row_in_csv(
+    csv_path: Path,
+    key_field: str,
+    key_value: Any,
+    update_data: Dict[str, Any]
+) -> bool:
+    """
+    Update a row in a CSV file based on a key field value.
+    
+    Args:
+        csv_path: Path to the CSV file
+        key_field: The column to identify the row
+        key_value: The value to identify the row
+        update_data: Dictionary of fields to update
+        
+    Returns:
+        True if row was updated, False if not found
+    """
+    rows = read_csv_as_dicts(csv_path)
+    updated = False
+    
+    # Find and update the matching row
+    for row in rows:
+        if row.get(key_field) == str(key_value):
+            row.update(update_data)
+            updated = True
+            break
+    
+    # If we updated a row, write all rows back to the file
+    if updated:
+        if rows:  # Check if we have any rows
+            fieldnames = list(rows[0].keys())
+            with csv_path.open("w", newline="", encoding="utf-8") as f:
+                writer = csv.DictWriter(f, fieldnames=fieldnames)
+                writer.writeheader()
+                writer.writerows(rows)
+    
+    return updated
+
+
+def generate_unique_id(prefix: str = "row") -> str:
+    """
+    Generate a unique ID with a prefix and timestamp.
+    
+    Args:
+        prefix: Prefix for the ID
+        
+    Returns:
+        A unique ID string
+    """
+    timestamp = int(datetime.utcnow().timestamp() * 1000)
+    return f"{prefix}-{timestamp}"
+
+
+def get_current_timestamp() -> str:
+    """
+    Get the current UTC timestamp in ISO format.
+
+    Returns:
+        Current timestamp as ISO string
+    """
+    return datetime.utcnow().isoformat()
+
+
+def get_csv_headers() -> str:
+    """
+    Get column headers from all CSV files and format them as instructions.
+
+    Returns:
+        Formatted string containing CSV file schemas
+    """
+    csv_files = ["conversations", "tasks", "memories"]
+    schemas = []
+
+    for csv_name in csv_files:
+        try:
+            csv_path = get_csv_path(csv_name)
+            # Read only header to get column names
+            df = pd.read_csv(csv_path, nrows=0)
+            columns = df.columns.tolist()
+            schemas.append(f"- {csv_name}.csv: columns {columns}")
+        except FileNotFoundError:
+            # Handle case where CSV doesn't exist yet
+            if csv_name == "conversations":
+                schemas.append(f"- {csv_name}.csv: columns ['id', 'timestamp', 'role', 'content', 'tags']")
+            elif csv_name == "tasks":
+                schemas.append(f"- {csv_name}.csv: columns ['task_id', 'created_at', 'description', 'status', 'schedule_type', 'scheduled_at', 'recurrence_rule']")
+            elif csv_name == "memories":
+                schemas.append(f"- {csv_name}.csv: columns ['memory_id', 'created_at', 'source_message_ids', 'content', 'tags']")
+
+    return "\n".join(schemas)

main.py

@@ -0,0 +1,6 @@
+def main():
+    print("Hello from rowmind!")
+
+
+if __name__ == "__main__":
+    main()

pyproject.toml

@@ -0,0 +1,12 @@
+[project]
+name = "rowmind"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "gradio[oauth]>=5.49.1",
+    "huggingface-hub>=1.1.4",
+    "openai>=2.8.1",
+    "smolagents[toolkit]>=1.22.0",
+]

tools.py

@@ -0,0 +1,50 @@
+from typing import Dict
+
+from smolagents import tool
+
+from helper import (
+    add_row_to_csv,
+    generate_unique_id,
+    get_current_timestamp,
+    get_csv_path
+)
+
+
+@tool
+def create_task(
+    description: str,
+    schedule_type: str = "one_time",
+    scheduled_at: str | None = None,
+    recurrence_rule: str | None = None,
+) -> str:
+    """
+    Creates a new task in the tasks CSV file.
+
+    Args:
+        description: Short human-friendly description of the task.
+        schedule_type: Either "one_time" or "recurring".
+        scheduled_at: ISO 8601 datetime string for the next run (optional).
+        recurrence_rule: Optional human-readable recurrence rule
+            (for example: "daily" or "weekly:mon,wed").
+    """
+    # Get the CSV path using helper
+    csv_path = get_csv_path("tasks")
+    
+    # Generate task data
+    task_data: Dict[str, str] = {
+        "task_id": generate_unique_id("task"),
+        "created_at": get_current_timestamp(),
+        "description": description,
+        "status": "pending",
+        "schedule_type": schedule_type,
+        "scheduled_at": scheduled_at or "",
+        "recurrence_rule": recurrence_rule or "",
+    }
+    
+    # Add row to CSV using helper
+    add_row_to_csv(csv_path, task_data)
+
+    return (
+        f"Created task {task_data['task_id']!r} scheduled_type={schedule_type!r} "
+        f"scheduled_at={scheduled_at!r} recurrence_rule={recurrence_rule!r}"
+    )