footprinter-cli 1.0.0__py3-none-any.whl

footprinter/db/clients.py

@@ -0,0 +1,307 @@
+"""Client queries.
+
+Provides list, detail, create, and update functions for clients.
+"""
+
+import json
+import sqlite3
+from typing import Optional
+
+from footprinter.db.sql_utils import build_status_filter, paginate, paginated_response
+from footprinter.utils.text import _make_slug
+
+VALID_CLIENT_TYPES = {"external", "internal", "personal"}
+VALID_STATUSES = frozenset({"active", "hidden", "removed"})
+
+
+def list_clients(
+    conn: sqlite3.Connection, *, status: Optional[str | list[str]] = None, limit: int = 50, page: int = 1
+) -> dict:
+    """Return clients with project and file counts.
+
+    Parameters
+    ----------
+    conn : sqlite3.Connection
+    status : str, list[str], or None
+        ``None`` → active only (default).
+        ``"all"`` → no status filter.
+        Single string → exact match.
+        List of strings → ``WHERE status IN (...)``.
+    limit : int
+        Maximum rows per page (default 50).
+    page : int
+        1-based page number (default 1).
+
+    Returns
+    -------
+    dict
+        ``{"clients": [...], "pagination": {page, limit, total, total_pages}}``
+    """
+    conditions: list[str] = []
+    params: list = []
+
+    status_conds, status_params = build_status_filter(
+        status,
+        column="client.status",
+        default_include=["active"],
+    )
+    conditions.extend(status_conds)
+    params.extend(status_params)
+
+    where = " WHERE " + " AND ".join(conditions) if conditions else ""
+
+    count_sql = f"SELECT COUNT(*) FROM clients client{where}"
+    fetch_sql = f"""
+        SELECT client.id, client.name, client.slug, client.client_type, client.status,
+               client.mcp_view, client.mcp_read, client.path_pattern,
+               (SELECT COUNT(*) FROM projects project WHERE project.client_id = client.id) as project_count,
+               (SELECT COUNT(*) FROM files file
+                JOIN projects project ON file.project_id = project.id
+                WHERE project.client_id = client.id AND file.status != 'removed') as file_count
+        FROM clients client
+        {where}
+        ORDER BY client.name
+        LIMIT ? OFFSET ?
+    """
+    rows, pagination = paginate(conn, count_sql, fetch_sql, params, page=page, limit=limit)
+
+    clients = [
+        {
+            "id": row["id"],
+            "name": row["name"],
+            "slug": row["slug"],
+            "client_type": row["client_type"],
+            "status": row["status"],
+            "project_count": row["project_count"],
+            "file_count": row["file_count"],
+            "mcp_view": row["mcp_view"] or "inherit",
+            "mcp_read": row["mcp_read"] or "inherit",
+            "path_pattern": row["path_pattern"] or "",
+        }
+        for row in rows
+    ]
+
+    return paginated_response("clients", clients, pagination)
+
+
+def update_client(conn: sqlite3.Connection, client_id: int, **fields) -> Optional[bool]:
+    """Update a client's fields.
+
+    Returns True on success, None if client not found.
+    Raises ValueError on invalid input.
+    """
+    cursor = conn.cursor()
+    cursor.execute("SELECT id, name FROM clients WHERE id = ?", (client_id,))
+    if not cursor.fetchone():
+        return None
+
+    updatable = {"name", "client_type", "path_pattern", "status", "status_reason", "metadata"}
+    sql_fields = []
+    values = []
+    new_name = None
+
+    for key in updatable:
+        if key in fields:
+            val = fields[key]
+            if key == "metadata" and val is not None:
+                val = json.dumps(val)
+            if key == "client_type" and val not in VALID_CLIENT_TYPES:
+                valid = ", ".join(sorted(VALID_CLIENT_TYPES))
+                raise ValueError(f"Invalid client_type. Must be one of: {valid}")
+            if key == "name":
+                new_name = (val or "").strip()
+                if not new_name:
+                    raise ValueError("Name cannot be empty")
+                val = new_name
+            sql_fields.append(f"{key} = ?")
+            values.append(val)
+
+    if not sql_fields:
+        return True
+
+    if new_name:
+        new_slug = _make_slug(new_name)
+        sql_fields.append("slug = ?")
+        values.append(new_slug)
+
+    values.append(client_id)
+    try:
+        cursor.execute(
+            f"UPDATE clients SET {', '.join(sql_fields)} WHERE id = ?",
+            values,
+        )
+    except sqlite3.IntegrityError:
+        raise ValueError("A client with that name or slug already exists")
+
+    if new_name:
+        cursor.execute(
+            "UPDATE projects SET client = ? WHERE client_id = ?",
+            (new_name, client_id),
+        )
+
+    conn.commit()
+    return True
+
+
+def create_client(conn: sqlite3.Connection, *, name: str, client_type: str, path_pattern: Optional[str] = None) -> dict:
+    """Create a new client.
+
+    Returns dict with ``id`` and ``slug``.
+    Raises ValueError on invalid input or duplicate.
+    """
+    name = (name or "").strip()
+    if not name:
+        raise ValueError("Name is required")
+    if client_type not in VALID_CLIENT_TYPES:
+        valid = ", ".join(sorted(VALID_CLIENT_TYPES))
+        raise ValueError(f"Invalid client_type. Must be one of: {valid}")
+
+    slug = _make_slug(name)
+    cursor = conn.cursor()
+    try:
+        cursor.execute(
+            """INSERT INTO clients (name, slug, client_type, path_pattern, status)
+               VALUES (?, ?, ?, ?, 'active')""",
+            (name, slug, client_type, path_pattern),
+        )
+        conn.commit()
+    except sqlite3.IntegrityError:
+        raise ValueError(f"A client with name '{name}' or slug '{slug}' already exists")
+    return {"id": cursor.lastrowid, "slug": slug}
+
+
+def get_client(conn: sqlite3.Connection, client_id: int) -> Optional[dict]:
+    """Fetch a single client with its projects and file count.
+
+    Returns a dict with client fields, ``projects`` list, and
+    ``file_count``, or ``None`` if not found.
+    """
+    cursor = conn.cursor()
+    cursor.execute(
+        """SELECT id, name, slug, client_type, status, path_pattern,
+                  mcp_view, mcp_read
+           FROM clients WHERE id = ?""",
+        (client_id,),
+    )
+    row = cursor.fetchone()
+    if not row:
+        return None
+
+    client = {
+        "id": row["id"],
+        "name": row["name"],
+        "slug": row["slug"],
+        "client_type": row["client_type"],
+        "status": row["status"],
+        "path_pattern": row["path_pattern"] or "",
+        "mcp_view": row["mcp_view"] or "inherit",
+        "mcp_read": row["mcp_read"] or "inherit",
+    }
+
+    # Attached projects
+    cursor.execute(
+        """SELECT id, project_name, project_type, status
+           FROM projects WHERE client_id = ? ORDER BY project_name""",
+        (client_id,),
+    )
+    client["projects"] = [
+        {
+            "id": r["id"],
+            "project_name": r["project_name"],
+            "project_type": r["project_type"],
+            "status": r["status"],
+        }
+        for r in cursor.fetchall()
+    ]
+
+    # File count across all projects for this client
+    cursor.execute(
+        """SELECT COUNT(*) as cnt FROM files file
+           JOIN projects project ON file.project_id = project.id
+           WHERE project.client_id = ? AND file.status != 'removed'""",
+        (client_id,),
+    )
+    client["file_count"] = cursor.fetchone()["cnt"]
+
+    return client
+
+
+def find_by_name_fuzzy(conn: sqlite3.Connection, name: str) -> list[dict]:
+    """Find clients matching name with LIKE %name%.
+
+    Returns all columns including mcp_view. Does NOT filter by visibility.
+    """
+    rows = conn.execute(
+        """SELECT id, name, slug, client_type, path_pattern, status,
+                  created_at, mcp_view, mcp_read
+           FROM clients WHERE name LIKE ?""",
+        (f"%{name}%",),
+    ).fetchall()
+    return [dict(r) for r in rows]
+
+
+def count_hidden_by_name(conn: sqlite3.Connection, name: str) -> int:
+    """Count hidden clients matching a fuzzy name query (for diagnostics)."""
+    row = conn.execute(
+        "SELECT COUNT(*) FROM clients WHERE name LIKE ? AND COALESCE(mcp_view, 'inherit') = 'hidden'",
+        (f"%{name}%",),
+    ).fetchone()
+    return row[0]
+
+
+def get_client_navigation(conn: sqlite3.Connection, client_id: int, project_ids: list[int]) -> dict:
+    """Return navigation aggregates for an MCP client view."""
+    if not project_ids:
+        return {
+            "total_files": 0,
+            "total_size_bytes": 0,
+            "total_folders": 0,
+            "total_entities": {"emails": 0, "chats": 0, "visits": 0},
+        }
+
+    ph = ",".join("?" * len(project_ids))
+    _nh = "AND COALESCE(mcp_view, 'inherit') != 'hidden'"
+
+    stats = conn.execute(
+        f"""SELECT COUNT(*) as count, COALESCE(SUM(size_bytes), 0) as size
+            FROM files
+            WHERE project_id IN ({ph}) AND status != 'removed' {_nh}""",
+        project_ids,
+    ).fetchone()
+
+    folder_count = conn.execute(
+        f"SELECT COUNT(*) FROM folders WHERE project_id IN ({ph}) {_nh}",
+        project_ids,
+    ).fetchone()[0]
+
+    email_count = conn.execute(
+        f"SELECT COUNT(*) FROM emails WHERE project_id IN ({ph}) AND status != 'removed' {_nh}",
+        project_ids,
+    ).fetchone()[0]
+    chat_count = conn.execute(
+        f"SELECT COUNT(*) FROM chats WHERE project_id IN ({ph}) AND status != 'removed' {_nh}",
+        project_ids,
+    ).fetchone()[0]
+    browser_count = conn.execute(
+        f"SELECT COUNT(*) FROM visits WHERE project_id IN ({ph}) AND status != 'removed' {_nh}",
+        project_ids,
+    ).fetchone()[0]
+
+    return {
+        "total_files": stats["count"],
+        "total_size_bytes": stats["size"],
+        "total_folders": folder_count,
+        "total_entities": {
+            "emails": email_count,
+            "chats": chat_count,
+            "visits": browser_count,
+        },
+    }
+
+
+def find_client_id_by_name(conn: sqlite3.Connection, name: str) -> Optional[int]:
+    """Return the client ID for the given name, or None if not found."""
+    cursor = conn.cursor()
+    cursor.execute("SELECT id FROM clients WHERE name = ?", (name,))
+    row = cursor.fetchone()
+    return row["id"] if row else None

footprinter/db/emails.py

@@ -0,0 +1,279 @@
+"""Email queries, write operations — list, detail, and insert.
+
+Query and write layer for email data.
+"""
+
+import json
+import sqlite3
+from typing import Any, Dict, Optional
+
+from footprinter.db.sql_utils import paginate, paginated_response
+
+SORT_WHITELIST = {"subject", "from_address", "account", "received_at", "has_attachments"}
+
+
+def list_emails(
+    conn: sqlite3.Connection,
+    *,
+    page: int = 1,
+    limit: int = 50,
+    sort_by: str = "received_at",
+    order: str = "desc",
+    account: Optional[str] = None,
+    client_id: Optional[int] = None,
+    project_id: Optional[int] = None,
+    query: Optional[str] = None,
+    has_attachments: Optional[bool] = None,
+) -> dict:
+    """List emails with pagination, filtering, and sorting.
+
+    Returns dict with keys: emails, pagination.
+    """
+    sort_col = sort_by if sort_by in SORT_WHITELIST else "received_at"
+    sort_col_sql = f"email.{sort_col}"
+    order_sql = "ASC" if order.lower() == "asc" else "DESC"
+
+    # Build dynamic WHERE clause
+    conditions: list[str] = ["email.status != 'removed'"]
+    params: list = []
+
+    if account:
+        acct_list = [a.strip() for a in account.split(",") if a.strip()]
+        if len(acct_list) == 1:
+            conditions.append("email.account = ?")
+            params.append(acct_list[0])
+        elif acct_list:
+            placeholders = ",".join("?" for _ in acct_list)
+            conditions.append(f"email.account IN ({placeholders})")
+            params.extend(acct_list)
+
+    if client_id:
+        conditions.append("email.client_id = ?")
+        params.append(client_id)
+
+    if project_id:
+        conditions.append("email.project_id = ?")
+        params.append(project_id)
+
+    if has_attachments is not None:
+        if has_attachments:
+            conditions.append("email.has_attachments = 1")
+        else:
+            conditions.append("email.has_attachments = 0")
+
+    fts_join = ""
+    if query:
+        fts_join = "JOIN emails_fts fts ON fts.rowid = email.id"
+        fts_query = f'"{query}"*'
+        conditions.append("emails_fts MATCH ?")
+        params.append(fts_query)
+
+    where_clause = ""
+    if conditions:
+        where_clause = "WHERE " + " AND ".join(conditions)
+
+    count_sql = f"SELECT COUNT(*) FROM emails email {fts_join} {where_clause}"
+    fetch_sql = f"""
+        SELECT email.id, email.message_id, email.thread_id, email.account,
+               email.from_address, email.from_name, email.to_addresses, email.cc_addresses,
+               email.subject, email.body_preview, email.received_at,
+               email.labels, email.has_attachments, email.is_read,
+               email.client_id, email.project_id,
+               client.name AS client_name, project.project_name,
+               email.mcp_view, email.mcp_read
+        FROM emails email
+        {fts_join}
+        LEFT JOIN clients client ON email.client_id = client.id
+        LEFT JOIN projects project ON email.project_id = project.id
+        {where_clause}
+        ORDER BY {sort_col_sql} {order_sql}
+        LIMIT ? OFFSET ?
+    """
+    rows, pagination = paginate(conn, count_sql, fetch_sql, params, page=page, limit=limit)
+
+    emails = []
+    for row in rows:
+        emails.append(
+            {
+                "id": row["id"],
+                "message_id": row["message_id"],
+                "thread_id": row["thread_id"],
+                "account": row["account"] or "unknown",
+                "from_address": row["from_address"] or "",
+                "from_name": row["from_name"] or "",
+                "to_addresses": row["to_addresses"] or "",
+                "cc_addresses": row["cc_addresses"] or "",
+                "subject": row["subject"] or "(no subject)",
+                "body_preview": (row["body_preview"] or "")[:200],
+                "received_at": row["received_at"] or "",
+                "labels": row["labels"] or "",
+                "has_attachments": bool(row["has_attachments"]),
+                "is_read": bool(row["is_read"]),
+                "client_id": row["client_id"],
+                "client_name": row["client_name"],
+                "project_id": row["project_id"],
+                "project_name": row["project_name"],
+                "mcp_view": row["mcp_view"],
+                "mcp_read": row["mcp_read"],
+            }
+        )
+
+    return paginated_response("emails", emails, pagination)
+
+
+def get_email(conn: sqlite3.Connection, email_id: int) -> Optional[dict]:
+    """Get full details for a single email.
+
+    Returns dict or None if not found.
+    """
+    cursor = conn.cursor()
+    cursor.execute(
+        """
+        SELECT email.*, client.name AS client_name, project.project_name
+        FROM emails email
+        LEFT JOIN clients client ON email.client_id = client.id
+        LEFT JOIN projects project ON email.project_id = project.id
+        WHERE email.id = ? AND email.status != 'removed'
+        """,
+        (email_id,),
+    )
+    row = cursor.fetchone()
+    if not row:
+        return None
+
+    return {
+        "id": row["id"],
+        "message_id": row["message_id"],
+        "thread_id": row["thread_id"],
+        "account": row["account"] or "unknown",
+        "from_address": row["from_address"] or "",
+        "from_name": row["from_name"] or "",
+        "to_addresses": row["to_addresses"] or "",
+        "cc_addresses": row["cc_addresses"] or "",
+        "subject": row["subject"] or "(no subject)",
+        "body_preview": row["body_preview"] or "",
+        "received_at": row["received_at"] or "",
+        "labels": row["labels"] or "",
+        "has_attachments": bool(row["has_attachments"]),
+        "is_read": bool(row["is_read"]),
+        "client_id": row["client_id"],
+        "client_name": row["client_name"],
+        "project_id": row["project_id"],
+        "project_name": row["project_name"],
+        "status": row["status"],
+        "metadata": row["metadata"] or "",
+        "mcp_view": row["mcp_view"] or "inherit",
+        "mcp_read": row["mcp_read"] or "inherit",
+    }
+
+
+def update_email_relationships(
+    conn: sqlite3.Connection,
+    email_id: int,
+    *,
+    project_id: Optional[int] = None,
+    client_id: Optional[int] = None,
+) -> Optional[bool]:
+    """Update project and/or client assignment on an email.
+
+    Only updates fields that are passed (not None). Pass ``0`` to clear
+    a field (set to NULL). Stamps ``assignment_source = 'user'``
+    when the column exists (app-scope DBs only).
+    Returns True on success, None if email not found.
+    """
+    cursor = conn.execute("SELECT id FROM emails WHERE id = ?", (email_id,))
+    if cursor.fetchone() is None:
+        return None
+
+    if project_id is not None and project_id != 0:
+        proj = conn.execute("SELECT id FROM projects WHERE id = ?", (project_id,)).fetchone()
+        if not proj:
+            raise ValueError(f"No project with id {project_id}")
+    if client_id is not None and client_id != 0:
+        cli = conn.execute("SELECT id FROM clients WHERE id = ?", (client_id,)).fetchone()
+        if not cli:
+            raise ValueError(f"No client with id {client_id}")
+
+    sets: list[str] = []
+    params: list = []
+    if project_id is not None:
+        if project_id == 0:
+            sets.append("project_id = NULL")
+        else:
+            sets.append("project_id = ?")
+            params.append(project_id)
+    if client_id is not None:
+        if client_id == 0:
+            sets.append("client_id = NULL")
+        else:
+            sets.append("client_id = ?")
+            params.append(client_id)
+    if not sets:
+        return True
+
+    sets.append("assignment_source = 'user'")
+    params.append(email_id)
+    try:
+        conn.execute(f"UPDATE emails SET {', '.join(sets)} WHERE id = ?", params)
+    except sqlite3.OperationalError as e:
+        if "no such column" not in str(e):
+            raise
+        # assignment_source not present (tool-only DB)
+        sets.pop()
+        conn.execute(f"UPDATE emails SET {', '.join(sets)} WHERE id = ?", params)
+    conn.commit()
+    return True
+
+
+# ---------------------------------------------------------------------------
+# Write operations
+# ---------------------------------------------------------------------------
+
+
+def insert_email(conn: sqlite3.Connection, email_data: Dict[str, Any]) -> int:
+    """Insert or update an email record, preserving the row id on conflict."""
+    cursor = conn.cursor()
+    cursor.execute(
+        """
+        INSERT INTO emails
+        (message_id, thread_id, account, from_address, from_name,
+         to_addresses, cc_addresses, subject, body_preview, received_at,
+         labels, has_attachments, is_read, metadata)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(message_id, account) DO UPDATE SET
+            thread_id = excluded.thread_id,
+            from_address = excluded.from_address,
+            from_name = excluded.from_name,
+            to_addresses = excluded.to_addresses,
+            cc_addresses = excluded.cc_addresses,
+            subject = excluded.subject,
+            body_preview = excluded.body_preview,
+            received_at = excluded.received_at,
+            labels = excluded.labels,
+            has_attachments = excluded.has_attachments,
+            is_read = excluded.is_read,
+            metadata = excluded.metadata,
+            updated_at = CURRENT_TIMESTAMP
+    """,
+        (
+            email_data["message_id"],
+            email_data["thread_id"],
+            email_data["account"],
+            email_data.get("from_address"),
+            email_data.get("from_name"),
+            email_data.get("to_addresses"),
+            email_data.get("cc_addresses"),
+            email_data.get("subject"),
+            email_data.get("body_preview"),
+            email_data["received_at"],
+            email_data.get("labels"),
+            email_data.get("has_attachments", False),
+            email_data.get("is_read", True),
+            json.dumps(email_data.get("metadata", {})),
+        ),
+    )
+    cursor.execute(
+        "SELECT id FROM emails WHERE message_id = ? AND account = ?",
+        (email_data["message_id"], email_data["account"]),
+    )
+    return cursor.fetchone()[0]