inou/portal/mcp_tools.go

package main

import (
	"bytes"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"net/url"
	"strconv"
	"strings"

	"inou/lib"
)

// MCP Tool Implementations
// These call the internal API endpoints to get data

const apiBaseURL = "http://localhost:8082" // Internal API server

func mcpAPICall(accessToken, path string, params map[string]string) ([]byte, error) {
	u := apiBaseURL + path
	if params != nil && len(params) > 0 {
		v := url.Values{}
		for k, val := range params {
			if val != "" {
				v.Set(k, val)
			}
		}
		u += "?" + v.Encode()
	}

	log.Printf("[MCP] API call: %s", u)

	req, err := http.NewRequest("GET", u, nil)
	if err != nil {
		log.Printf("[MCP] Request error: %v", err)
		return nil, err
	}
	// Use the access token for auth
	req.Header.Set("Authorization", "Bearer "+accessToken)

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		log.Printf("[MCP] HTTP error: %v", err)
		return nil, err
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Printf("[MCP] Read error: %v", err)
		return nil, err
	}

	if resp.StatusCode != 200 {
		errMsg := fmt.Errorf("HTTP %d: %s", resp.StatusCode, string(body))
		log.Printf("[MCP] API error: %v", errMsg)
		return nil, errMsg
	}

	log.Printf("[MCP] API success: %d bytes", len(body))
	return body, nil
}

func mcpListDossiers(accessToken string) (string, error) {
	body, err := mcpAPICall(accessToken, "/api/v1/dossiers", nil)
	if err != nil {
		return "", err
	}
	// Pretty print JSON
	var data interface{}
	json.Unmarshal(body, &data)
	pretty, _ := json.MarshalIndent(data, "", "  ")
	return string(pretty), nil
}

func mcpListStudies(accessToken, dossier string) (string, error) {
	body, err := mcpAPICall(accessToken, "/api/v1/dossiers/"+dossier+"/entries", map[string]string{"category": "imaging"})
	if err != nil {
		return "", err
	}
	var data interface{}
	json.Unmarshal(body, &data)
	pretty, _ := json.MarshalIndent(data, "", "  ")
	return string(pretty), nil
}

func mcpListSeries(accessToken, dossier, study string) (string, error) {
	body, err := mcpAPICall(accessToken, "/api/v1/dossiers/"+dossier+"/entries", map[string]string{"parent": study})
	if err != nil {
		return "", err
	}
	var data interface{}
	json.Unmarshal(body, &data)
	pretty, _ := json.MarshalIndent(data, "", "  ")
	return string(pretty), nil
}

func mcpListSlices(accessToken, dossier, series string) (string, error) {
	body, err := mcpAPICall(accessToken, "/api/v1/dossiers/"+dossier+"/entries", map[string]string{"parent": series})
	if err != nil {
		return "", err
	}
	var data interface{}
	json.Unmarshal(body, &data)
	pretty, _ := json.MarshalIndent(data, "", "  ")
	return string(pretty), nil
}

func mcpFetchImage(accessToken, dossier, slice string, wc, ww float64) (map[string]interface{}, error) {
	params := map[string]string{}
	if wc != 0 {
		params["wc"] = strconv.FormatFloat(wc, 'f', 0, 64)
	}
	if ww != 0 {
		params["ww"] = strconv.FormatFloat(ww, 'f', 0, 64)
	}

	body, err := mcpAPICall(accessToken, "/image/"+slice, params)
	if err != nil {
		return nil, err
	}

	b64 := base64.StdEncoding.EncodeToString(body)
	return mcpImageContent(b64, "image/webp", fmt.Sprintf("Slice %s (%d bytes)", slice[:8], len(body))), nil
}

func mcpFetchContactSheet(accessToken, dossier, series string, wc, ww float64) (map[string]interface{}, error) {
	params := map[string]string{}
	if wc != 0 {
		params["wc"] = strconv.FormatFloat(wc, 'f', 0, 64)
	}
	if ww != 0 {
		params["ww"] = strconv.FormatFloat(ww, 'f', 0, 64)
	}

	body, err := mcpAPICall(accessToken, "/contact-sheet.webp/"+series, params)
	if err != nil {
		return nil, err
	}

	b64 := base64.StdEncoding.EncodeToString(body)
	return mcpImageContent(b64, "image/webp", fmt.Sprintf("Contact sheet %s (%d bytes)", series[:8], len(body))), nil
}

func mcpQueryEntries(accessToken, dossier, category, typ, searchKey, parent, from, to string, limit int) (string, error) {
	params := map[string]string{}
	if category != "" {
		params["category"] = category
	}
	if typ != "" {
		params["type"] = typ
	}
	if searchKey != "" {
		params["search_key"] = searchKey
	}
	if parent != "" {
		params["parent"] = parent
	}
	if from != "" {
		params["from"] = from
	}
	if to != "" {
		params["to"] = to
	}
	if limit > 0 {
		params["limit"] = strconv.Itoa(limit)
	}

	body, err := mcpAPICall(accessToken, "/api/v1/dossiers/"+dossier+"/entries", params)
	if err != nil {
		return "", err
	}
	var data interface{}
	json.Unmarshal(body, &data)
	pretty, _ := json.MarshalIndent(data, "", "  ")
	return string(pretty), nil
}

func mcpGetCategories(dossier, accessorID string) (string, error) {
	ctx := &lib.AccessContext{AccessorID: accessorID}
	result, err := lib.EntryCategoryCounts(ctx, dossier)
	if err != nil {
		return "", err
	}
	pretty, _ := json.MarshalIndent(result, "", "  ")
	return string(pretty), nil
}

func mcpQueryGenome(accessToken, dossier, accessorID, gene, search, category, rsids string, minMag float64, repute string, includeHidden bool, limit, offset int) (string, error) {
	ctx := &lib.AccessContext{AccessorID: accessorID}
	var rsidList []string
	if rsids != "" {
		rsidList = strings.Split(rsids, ",")
	}

	if limit <= 0 {
		numTerms := 1
		if gene != "" {
			numTerms = len(strings.Split(gene, ","))
		}
		if len(rsidList) > numTerms {
			numTerms = len(rsidList)
		}
		limit = 20 * numTerms
	}

	result, err := lib.GenomeQuery(ctx, dossier, lib.GenomeQueryOpts{
		Category:      category,
		Search:        search,
		Gene:          gene,
		RSIDs:         rsidList,
		MinMagnitude:  minMag,
		Repute:        repute,
		IncludeHidden: includeHidden,
		Limit:         limit,
		Offset:        offset,
		AccessorID:    accessorID,
	})
	if err != nil {
		return "", err
	}
	pretty, _ := json.MarshalIndent(result, "", "  ")
	return string(pretty), nil
}

// Journal MCP Tools

func mcpListJournals(accessToken, dossier string, days int, status *int, journalType string) (string, error) {
	params := map[string]string{"dossier": dossier}
	if days > 0 {
		params["days"] = strconv.Itoa(days)
	}
	if status != nil {
		params["status"] = strconv.Itoa(*status)
	}
	if journalType != "" {
		params["type"] = journalType
	}

	body, err := mcpAPICall(accessToken, "/api/v1/dossiers/"+dossier+"/journal", params)
	if err != nil {
		return "", err
	}
	var data interface{}
	json.Unmarshal(body, &data)
	pretty, _ := json.MarshalIndent(data, "", "  ")
	return string(pretty), nil
}

func mcpGetJournalEntry(accessToken, dossier, entryID string) (string, error) {
	body, err := mcpAPICall(accessToken, "/api/v1/dossiers/"+dossier+"/journal/"+entryID, nil)
	if err != nil {
		return "", err
	}
	var data interface{}
	json.Unmarshal(body, &data)
	pretty, _ := json.MarshalIndent(data, "", "  ")
	return string(pretty), nil
}

func mcpCreateJournalEntry(accessToken, dossier string, params map[string]interface{}) (string, error) {
	u := apiBaseURL + "/api/v1/dossiers/" + dossier + "/journal"

	jsonData, err := json.Marshal(params)
	if err != nil {
		return "", fmt.Errorf("failed to marshal request: %w", err)
	}

	req, err := http.NewRequest("POST", u, io.NopCloser(bytes.NewReader(jsonData)))
	if err != nil {
		return "", err
	}
	req.Header.Set("Authorization", "Bearer "+accessToken)
	req.Header.Set("Content-Type", "application/json")

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return "", err
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return "", err
	}

	if resp.StatusCode != 200 && resp.StatusCode != 201 {
		return "", fmt.Errorf("HTTP %d: %s", resp.StatusCode, string(body))
	}

	var data interface{}
	json.Unmarshal(body, &data)
	pretty, _ := json.MarshalIndent(data, "", "  ")
	return string(pretty), nil
}

func mcpUpdateJournalEntry(accessToken, dossier, entryID string, params map[string]interface{}) (string, error) {
	u := apiBaseURL + "/api/v1/dossiers/" + dossier + "/journal/" + entryID

	jsonData, err := json.Marshal(params)
	if err != nil {
		return "", fmt.Errorf("failed to marshal request: %w", err)
	}

	req, err := http.NewRequest("PATCH", u, io.NopCloser(bytes.NewReader(jsonData)))
	if err != nil {
		return "", err
	}
	req.Header.Set("Authorization", "Bearer "+accessToken)
	req.Header.Set("Content-Type", "application/json")

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return "", err
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return "", err
	}

	if resp.StatusCode != 200 {
		return "", fmt.Errorf("HTTP %d: %s", resp.StatusCode, string(body))
	}

	var data interface{}
	json.Unmarshal(body, &data)
	pretty, _ := json.MarshalIndent(data, "", "  ")
	return string(pretty), nil
}