synapse-orch-ai 0.1.0

package/backend/tools/sql_agent.py

@@ -0,0 +1,221 @@
+
+from mcp.types import Tool, TextContent, ImageContent, EmbeddedResource
+import mcp.types as types
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+import asyncio
+import json
+import os
+from sqlalchemy import create_engine, inspect, text
+from core.config import load_settings, DATA_DIR
+
+# Initialize MCP Server
+app = Server("sql-mcp-server")
+
+# Per-db_id engine cache: db_id -> (engine, inspector)
+_engines: dict[str, tuple] = {}
+
+# Mutation keywords that indicate a write operation
+_WRITE_KEYWORDS = {
+    "insert", "update", "delete", "drop", "create", "alter",
+    "truncate", "replace", "merge", "upsert", "grant", "revoke",
+}
+
+
+def _is_write_query(query: str) -> bool:
+    first_word = query.strip().split()[0].lower() if query.strip() else ""
+    return first_word in _WRITE_KEYWORDS
+
+
+def _load_db_configs() -> list[dict]:
+    """Load db_configs.json from the data directory."""
+    path = os.path.join(DATA_DIR, "db_configs.json")
+    if not os.path.exists(path):
+        return []
+    try:
+        with open(path) as f:
+            return json.load(f)
+    except Exception:
+        return []
+
+
+def get_db_engine(db_id: str | None = None):
+    """Return (engine, inspector) for the given db_id, or fall back to global setting."""
+    global _engines
+
+    if db_id:
+        if db_id in _engines:
+            return _engines[db_id]
+        configs = _load_db_configs()
+        config = next((c for c in configs if c.get("id") == db_id), None)
+        if not config:
+            raise ValueError(f"No database config found for db_id='{db_id}'.")
+        conn_str = config.get("connection_string", "")
+        if not conn_str:
+            raise ValueError(f"Database config '{db_id}' has no connection string.")
+        engine = create_engine(conn_str, echo=False)
+        inspector = inspect(engine)
+        _engines[db_id] = (engine, inspector)
+        return engine, inspector
+
+    # Fallback: global sql_connection_string from settings
+    settings = load_settings()
+    db_url = settings.get("sql_connection_string", "")
+    if not db_url:
+        raise ValueError("No db_id provided and no global SQL connection string found in settings.")
+    cache_key = "__global__"
+    if cache_key in _engines:
+        return _engines[cache_key]
+    engine = create_engine(db_url, echo=False)
+    inspector = inspect(engine)
+    _engines[cache_key] = (engine, inspector)
+    return engine, inspector
+
+
+@app.list_tools()
+async def list_tools() -> list[types.Tool]:
+    db_id_prop = {
+        "db_id": {
+            "type": "string",
+            "description": "The ID of the database config to use (from LINKED DATABASES in your system prompt). Required when multiple databases are configured."
+        }
+    }
+    return [
+        types.Tool(
+            name="list_tables",
+            description="List all tables in a database. Provide db_id when multiple databases are linked.",
+            inputSchema={
+                "type": "object",
+                "properties": db_id_prop,
+            }
+        ),
+        types.Tool(
+            name="get_table_schema",
+            description="Get the detailed schema (columns, types, foreign keys) for specific table(s). Provide db_id when multiple databases are linked.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    **db_id_prop,
+                    "table_names": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "List of table names to inspect."
+                    }
+                },
+                "required": ["table_names"]
+            }
+        ),
+        types.Tool(
+            name="run_sql_query",
+            description=(
+                "Execute a SQL query against a linked database. "
+                "Provide db_id when multiple databases are linked. "
+                "Write queries (INSERT/UPDATE/DELETE/DROP/etc.) require allow_db_write to be enabled in settings "
+                "AND explicit user confirmation BEFORE calling this tool."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    **db_id_prop,
+                    "query": {
+                        "type": "string",
+                        "description": "The SQL query to execute."
+                    }
+                },
+                "required": ["query"]
+            }
+        )
+    ]
+
+@app.call_tool()
+async def call_tool(name: str, arguments: dict) -> list[types.TextContent | types.ImageContent | types.EmbeddedResource]:
+    try:
+        db_id = arguments.get("db_id") or None
+        engine, inspector = get_db_engine(db_id)
+
+        if name == "list_tables":
+            tables = inspector.get_table_names()
+            return [types.TextContent(
+                type="text",
+                text=f"Found {len(tables)} tables:\n" + "\n".join([f"- {t}" for t in tables])
+            )]
+
+        elif name == "get_table_schema":
+            table_names = arguments.get("table_names", [])
+            schemas = []
+            for table in table_names:
+                try:
+                    columns = inspector.get_columns(table)
+                    fks = inspector.get_foreign_keys(table)
+                    pk = inspector.get_pk_constraint(table)
+                    col_strings = []
+                    for col in columns:
+                        nullable = "NULL" if col['nullable'] else "NOT NULL"
+                        is_pk = " (PK)" if col['name'] in pk.get('constrained_columns', []) else ""
+                        col_strings.append(f"- {col['name']} ({col['type']}) {nullable}{is_pk}")
+                    fk_strings = [
+                        f"-> FK to {fk['referred_table']}.{fk['referred_columns'][0]} on {fk['constrained_columns'][0]}"
+                        for fk in fks
+                    ]
+                    schema_text = (
+                        f"**Table: {table}**\nColumns:\n" + "\n".join(col_strings) +
+                        ("\nForeign Keys:\n" + "\n".join(fk_strings) if fk_strings else "")
+                    )
+                    schemas.append(schema_text)
+                except Exception as e:
+                    schemas.append(f"Error inspecting table {table}: {str(e)}")
+            return [types.TextContent(type="text", text="\n\n".join(schemas))]
+
+        elif name == "run_sql_query":
+            query = arguments.get("query", "").strip()
+
+            if _is_write_query(query):
+                settings = load_settings()
+                allow_db_write = settings.get("allow_db_write", False)
+                if not allow_db_write:
+                    return [types.TextContent(
+                        type="text",
+                        text=(
+                            "BLOCKED: This query modifies the database and DB write access is currently disabled. "
+                            "A user with admin access must enable 'Allow agents to modify database' in General Settings."
+                        )
+                    )]
+
+            with engine.connect() as connection:
+                result = connection.execute(text(query))
+                # Commit for write operations so changes persist
+                if _is_write_query(query):
+                    connection.commit()
+                    return [types.TextContent(
+                        type="text",
+                        text=f"Query executed successfully. Rows affected: {result.rowcount}"
+                    )]
+                keys = list(result.keys())
+                rows = [dict(zip(keys, row)) for row in result.fetchall()]
+                if len(rows) > 50:
+                    rows = rows[:50]
+                    suffix = "\n...(Truncated to 50 rows)"
+                else:
+                    suffix = ""
+                return [types.TextContent(
+                    type="text",
+                    text=json.dumps(rows, default=str, indent=2) + suffix
+                )]
+
+        else:
+            raise ValueError(f"Unknown tool: {name}")
+
+    except Exception as e:
+        return [types.TextContent(type="text", text=f"Error: {str(e)}")]
+
+
+async def main():
+    async with stdio_server() as (read_stream, write_stream):
+        await app.run(
+            read_stream,
+            write_stream,
+            app.create_initialization_options()
+        )
+
+if __name__ == "__main__":
+    asyncio.run(main())

package/backend/tools/time.py

@@ -0,0 +1,283 @@
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+from mcp.types import Tool, TextContent
+from datetime import datetime, timedelta
+import calendar
+import zoneinfo
+import json
+
+# Initialize MCP server
+server = Server("time-agent")
+
+@server.list_tools()
+async def list_tools() -> list[Tool]:
+    """List available time tools."""
+    return [
+        Tool(
+            name="get_datetime",
+            description="""Get the current or future date as a 10-digit Unix timestamp based on natural language inputs.
+
+PARAMETER COMBINATIONS & LOGIC:
+
+1. WEEKS + WEEKDAY:
+   - Apply weeks offset FIRST, then find the weekday from that week
+   - Example: {weeks: 1, weekday: "friday"} = next week's Friday
+   
+2. MONTHS + DATE (numeric):
+   - Complete month offset FIRST, then take the date from that month
+   - Example: {months: 1, date: "16"} = 16th of next month
+   
+3. MONTH (name) + DATE:
+   - Go to that month and date in the CURRENT year
+   - If already passed this year, use NEXT year
+   - Example: {month: "april", date: 15} = April 15 of current/next year
+   
+4. MONTH + DATE + YEAR:
+   - Find that exact month and date in the specified year
+   - Example: {month: "april", date: 15, year: 2027} = April 15, 2027
+
+EXAMPLES:
+
+"next friday":
+  {weeks: 1, weekday: "friday"}
+  → Advance 1 week, then find Friday in that week
+
+"16th next month":
+  {months: 1, date: "16"}
+  → Advance 1 month, then go to the 16th
+
+"April 15":
+  {month: "april", date: 15}
+  → April 15 of current year (or next year if already passed)
+
+"April 15, 2027":
+  {month: "april", date: 15, year: 2027}
+  → April 15, 2027
+
+"tomorrow":
+  {days: 1}
+  → Add 1 day to current date
+
+"in 2 weeks on Monday":
+  {weeks: 2, weekday: "monday"}
+  → Advance 2 weeks, then find Monday""",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "timezone": {
+                        "type": "string",
+                        "description": "Timezone name (e.g., 'UTC', 'America/New_York', 'Asia/Kolkata'). Default: UTC",
+                        "default": "UTC"
+                    },
+                    "days": {
+                        "type": "integer",
+                        "description": "Add N days to current date"
+                    },
+                    "weeks": {
+                        "type": "integer",
+                        "description": "Add N weeks. If combined with weekday, weeks offset is applied FIRST"
+                    },
+                    "months": {
+                        "type": "integer",
+                        "description": "Add N months. If combined with date (numeric), month offset is applied FIRST"
+                    },
+                    "weekday": {
+                        "type": "string",
+                        "description": "Target weekday (monday, tuesday, wednesday, thursday, friday, saturday, sunday). If weeks is provided, find this weekday in the target week",
+                        "enum": ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"]
+                    },
+                    "date": {
+                        "type": "string",
+                        "description": "Day of month (1-31). Used with months parameter OR as part of dd/mm format"
+                    },
+                    "month": {
+                        "type": "string",
+                        "description": "Month name (january, february, ..., december). Goes to this month in current year (or next year if passed)",
+                        "enum": ["january", "february", "march", "april", "may", "june", 
+                                "july", "august", "september", "october", "november", "december"]
+                    },
+                    "year": {
+                        "type": "integer",
+                        "description": "Specific year (e.g., 2027). Used with month and date parameters"
+                    }
+                }
+            }
+        )
+    ]
+
+@server.call_tool()
+async def call_tool(name: str, arguments: dict) -> list[TextContent]:
+    """Handle tool calls."""
+    if name == "get_datetime":
+        try:
+            # Extract parameters
+            timezone = arguments.get("timezone", "UTC")
+            days = arguments.get("days")
+            weeks = arguments.get("weeks")
+            months = arguments.get("months")
+            weekday = arguments.get("weekday")
+            date_param = arguments.get("date")
+            month_param = arguments.get("month")
+            year_param = arguments.get("year")
+            
+            # Initialize timezone and base date
+            tz = zoneinfo.ZoneInfo(timezone)
+            base_date = datetime.now(tz)
+            target_date = base_date
+            
+            # LOGIC PRIORITY:
+            # 1. Handle days offset
+            if days is not None:
+                target_date += timedelta(days=days)
+            
+            # 2. Handle WEEKS + WEEKDAY combination (weeks first, then weekday)
+            if weeks is not None:
+                target_date += timedelta(weeks=weeks)
+            
+            # 3. Handle MONTHS + DATE combination (months first, then date)
+            if months is not None:
+                year = target_date.year
+                month = target_date.month + months
+                
+                # Normalize month and year
+                while month > 12:
+                    month -= 12
+                    year += 1
+                while month < 1:
+                    month += 12
+                    year -= 1
+                
+                # Handle day overflow (e.g., Jan 30 + 1 month -> Feb 30 invalid)
+                last_day = calendar.monthrange(year, month)[1]
+                day = min(target_date.day, last_day)
+                target_date = target_date.replace(year=year, month=month, day=day)
+                
+                # If date parameter exists with months, set to that specific date
+                if date_param is not None and '/' not in str(date_param):
+                    try:
+                        day = int(date_param)
+                        last_day = calendar.monthrange(year, month)[1]
+                        if 1 <= day <= last_day:
+                            target_date = target_date.replace(day=day)
+                    except (ValueError, TypeError):
+                        pass
+            
+            # 4. Handle MONTH (name) + DATE + optional YEAR
+            if month_param is not None:
+                month_names = ['january', 'february', 'march', 'april', 'may', 'june',
+                              'july', 'august', 'september', 'october', 'november', 'december']
+                month_lower = month_param.lower().strip()
+                
+                if month_lower in month_names:
+                    target_month = month_names.index(month_lower) + 1
+                    target_year = year_param if year_param is not None else base_date.year
+                    
+                    # Get day from date parameter or keep current day
+                    if date_param is not None and '/' not in str(date_param):
+                        try:
+                            target_day = int(date_param)
+                        except (ValueError, TypeError):
+                            target_day = target_date.day
+                    else:
+                        target_day = target_date.day
+                    
+                    # Validate and clamp day
+                    last_day = calendar.monthrange(target_year, target_month)[1]
+                    target_day = min(target_day, last_day)
+                    
+                    # Create candidate date
+                    candidate = base_date.replace(year=target_year, month=target_month, day=target_day)
+                    
+                    # If no year specified and date has passed, use next year
+                    if year_param is None and candidate.date() < base_date.date():
+                        candidate = candidate.replace(year=target_year + 1)
+                    
+                    target_date = candidate
+            
+            # 5. Handle WEEKDAY (after weeks offset if applicable)
+            if weekday is not None:
+                weekday_lower = weekday.lower().strip()
+                weekdays = ['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']
+                
+                if weekday_lower not in weekdays:
+                    return [TextContent(
+                        type="text",
+                        text=json.dumps({
+                            "error": f"Invalid weekday '{weekday}'. Must be one of {weekdays}"
+                        })
+                    )]
+                
+                current_weekday = target_date.weekday()  # Mon=0, Sun=6
+                target_weekday = weekdays.index(weekday_lower)
+                
+                days_ahead = target_weekday - current_weekday
+                
+                # If weeks was specified, we're already in the target week
+                # Find the weekday in that week (could be before or after current day)
+                if weeks is not None:
+                    # In the target week, find the specific weekday
+                    if days_ahead < 0:
+                        days_ahead += 7
+                else:
+                    # No weeks specified, find next occurrence
+                    if days_ahead <= 0:
+                        days_ahead += 7
+                
+                target_date += timedelta(days=days_ahead)
+            
+            # 6. Handle 'dd/mm' date format (legacy format)
+            if date_param is not None and '/' in str(date_param):
+                parts = str(date_param).split('/')
+                if len(parts) == 2:
+                    try:
+                        day = int(parts[0])
+                        month = int(parts[1])
+                        current_year = base_date.year
+                        
+                        candidate = base_date.replace(year=current_year, month=month, day=day)
+                        
+                        if candidate.date() < base_date.date():
+                            candidate = candidate.replace(year=current_year + 1)
+                        
+                        target_date = candidate
+                    except ValueError as e:
+                        return [TextContent(
+                            type="text",
+                            text=json.dumps({
+                                "error": f"Invalid date format '{date_param}'. Expected 'dd/mm'. {str(e)}"
+                            })
+                        )]
+            
+            # Convert to 10-digit Unix timestamp
+            unix_timestamp = int(target_date.timestamp())
+            
+            # Return JSON with timestamp and human-readable format
+            result = {
+                "timestamp": unix_timestamp,
+                "datetime": target_date.strftime("%Y-%m-%d %H:%M:%S %Z"),
+                "timezone": timezone,
+                "iso_format": target_date.isoformat()
+            }
+            
+            return [TextContent(type="text", text=json.dumps(result, indent=2))]
+            
+        except Exception as e:
+            return [TextContent(
+                type="text",
+                text=json.dumps({"error": f"Error processing datetime: {str(e)}"})
+            )]
+    
+    return [TextContent(type="text", text=json.dumps({"error": f"Unknown tool: {name}"}))]
+
+async def main():
+    """Run the server using stdio transport."""
+    async with stdio_server() as (read_stream, write_stream):
+        await server.run(
+            read_stream,
+            write_stream,
+            server.create_initialization_options()
+        )
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main())