core/server/tools/notes.go

package tools

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"strings"

	"github.com/lib/pq"

	"git.gobha.me/xcaliber/chat-switchboard/database"
	"git.gobha.me/xcaliber/chat-switchboard/knowledge"
	"git.gobha.me/xcaliber/chat-switchboard/store"
)

// ── Late Registration ────────────────────────
// Note tools use late registration (like kb_search) because
// note_create, note_update, and note_search need the embedder for
// vector operations. The embedder is optional — if nil, notes still
// work but semantic search degrades to full-text search.

// RegisterNoteTools registers all note tools with captured dependencies.
// Call from main.go after stores + embedder init.
func RegisterNoteTools(stores store.Stores, embedder *knowledge.Embedder) {
	Register(&noteCreateTool{stores: stores, embedder: embedder})
	Register(&noteSearchTool{stores: stores, embedder: embedder})
	Register(&noteUpdateTool{stores: stores, embedder: embedder})
	Register(&noteListTool{})
}

// ── Shared helpers ─────────────────────────────

// embedNote generates a vector for a note's title+content and stores it.
// Silently no-ops if embedder is nil or not configured.
func embedNote(ctx context.Context, embedder *knowledge.Embedder, stores store.Stores, noteID, userID, title, content string) {
	if embedder == nil || !embedder.IsConfigured(ctx) {
		return
	}

	text := title + "\n\n" + content
	if len(text) > 8000 {
		text = text[:8000] // limit to ~2k tokens for embedding
	}

	// Resolve team for embedding role
	var teamID *string
	if stores.Teams != nil {
		ids, _ := stores.Teams.GetUserTeamIDs(ctx, userID)
		if len(ids) > 0 {
			teamID = &ids[0]
		}
	}

	result, err := embedder.EmbedChunks(ctx, userID, teamID, []string{text})
	if err != nil {
		log.Printf("⚠ note embed failed for %s: %v", noteID, err)
		return
	}
	if len(result.Vectors) == 0 {
		return
	}

	// Store the vector — format as pgvector literal
	vecStr := vectorToString(result.Vectors[0])
	_, err = database.DB.Exec(
		`UPDATE notes SET embedding = $1::vector WHERE id = $2`,
		vecStr, noteID,
	)
	if err != nil {
		log.Printf("⚠ note embed store failed for %s: %v", noteID, err)
		return
	}

	// Track embedding usage
	embedder.LogUsage(ctx, userID, nil, result)
	log.Printf("📝 note %s embedded (%d tokens)", noteID, result.InputTokens)
}

// vectorToString converts a float64 slice to pgvector literal format: [0.1,0.2,...]
func vectorToString(vec []float64) string {
	parts := make([]string, len(vec))
	for i, v := range vec {
		parts[i] = fmt.Sprintf("%g", v)
	}
	return "[" + strings.Join(parts, ",") + "]"
}

// ═══════════════════════════════════════════
// note_create
// ═══════════════════════════════════════════

type noteCreateTool struct {
	stores   store.Stores
	embedder *knowledge.Embedder
}

func (t *noteCreateTool) Definition() ToolDef {
	return ToolDef{
		Name:        "note_create",
		DisplayName: "Create",
		Category:    "notes",
		Description: "Create a new note for the user. Use this to save information, insights, summaries, or anything the user wants to remember. Notes are persistent and searchable.",
		Parameters: JSONSchema(map[string]interface{}{
			"title":   Prop("string", "Title of the note"),
			"content": Prop("string", "Markdown content of the note"),
			"folder":  Prop("string", "Folder path, e.g. '/projects/switchboard/'. Defaults to '/'"),
			"tags":    PropArray("Tags for categorization, e.g. ['research', 'golang']"),
		}, []string{"title", "content"}),
	}
}

func (t *noteCreateTool) Execute(ctx context.Context, execCtx ExecutionContext, argsJSON string) (string, error) {
	var args struct {
		Title   string   `json:"title"`
		Content string   `json:"content"`
		Folder  string   `json:"folder"`
		Tags    []string `json:"tags"`
	}
	if err := json.Unmarshal([]byte(argsJSON), &args); err != nil {
		return "", fmt.Errorf("invalid arguments: %w", err)
	}

	if args.Title == "" {
		return "", fmt.Errorf("title is required")
	}

	folder := normalizePath(args.Folder)
	tags := args.Tags
	if tags == nil {
		tags = []string{}
	}

	// source_channel_id links the note to the conversation that created it
	var sourceChannelID *string
	if execCtx.ChannelID != "" {
		sourceChannelID = &execCtx.ChannelID
	}

	var id, createdAt string
	err := database.DB.QueryRow(`
		INSERT INTO notes (user_id, title, content, folder_path, tags, source_channel_id)
		VALUES ($1, $2, $3, $4, $5, $6)
		RETURNING id, created_at::text
	`, execCtx.UserID, args.Title, args.Content, folder, pq.Array(tags), sourceChannelID,
	).Scan(&id, &createdAt)

	if err != nil {
		return "", fmt.Errorf("failed to create note: %w", err)
	}

	// Embed async — don't block the tool response
	go embedNote(context.Background(), t.embedder, t.stores, id, execCtx.UserID, args.Title, args.Content)

	result, _ := json.Marshal(map[string]interface{}{
		"id":         id,
		"title":      args.Title,
		"folder":     folder,
		"tags":       tags,
		"created_at": createdAt,
		"message":    fmt.Sprintf("Note '%s' created successfully.", args.Title),
	})
	return string(result), nil
}

// ═══════════════════════════════════════════
// note_search
// ═══════════════════════════════════════════

type noteSearchTool struct {
	stores   store.Stores
	embedder *knowledge.Embedder
}

func (t *noteSearchTool) Definition() ToolDef {
	return ToolDef{
		Name:        "note_search",
		DisplayName: "Search",
		Category:    "notes",
		Description: "Search the user's notes by keyword or semantic meaning. " +
			"Set semantic=true for meaning-based search using AI embeddings, " +
			"or omit for fast keyword matching. Returns matching notes ranked by relevance.",
		Parameters: JSONSchema(map[string]interface{}{
			"query": Prop("string", "Search query — natural language keywords or question"),
			"limit": Prop("integer", "Maximum results to return (default 10, max 50)"),
			"semantic": map[string]interface{}{
				"type":        "boolean",
				"description": "Use semantic (vector) search instead of keyword search. Better for meaning-based queries.",
			},
		}, []string{"query"}),
	}
}

func (t *noteSearchTool) Execute(ctx context.Context, execCtx ExecutionContext, argsJSON string) (string, error) {
	var args struct {
		Query    string `json:"query"`
		Limit    int    `json:"limit"`
		Semantic bool   `json:"semantic"`
	}
	if err := json.Unmarshal([]byte(argsJSON), &args); err != nil {
		return "", fmt.Errorf("invalid arguments: %w", err)
	}

	if args.Query == "" {
		return "", fmt.Errorf("query is required")
	}
	if args.Limit <= 0 || args.Limit > 50 {
		args.Limit = 10
	}

	// Semantic search via vector similarity
	if args.Semantic {
		return t.semanticSearch(ctx, execCtx, args.Query, args.Limit)
	}

	// Default: full-text keyword search
	return t.keywordSearch(ctx, execCtx, args.Query, args.Limit)
}

func (t *noteSearchTool) keywordSearch(ctx context.Context, execCtx ExecutionContext, query string, limit int) (string, error) {
	rows, err := database.DB.Query(`
		SELECT id, title, folder_path, tags, LEFT(content, 500),
		       ts_rank(search_vector, plainto_tsquery('english', $2)) AS rank,
		       ts_headline('english', content, plainto_tsquery('english', $2),
		                   'MaxWords=60, MinWords=20, StartSel=**, StopSel=**') AS headline
		FROM notes
		WHERE user_id = $1
		  AND search_vector @@ plainto_tsquery('english', $2)
		ORDER BY rank DESC
		LIMIT $3
	`, execCtx.UserID, query, limit)

	if err != nil {
		return "", fmt.Errorf("search failed: %w", err)
	}
	defer rows.Close()

	results := make([]noteSearchResult, 0)
	for rows.Next() {
		var r noteSearchResult
		var dbTags pq.StringArray
		if err := rows.Scan(&r.ID, &r.Title, &r.Folder, &dbTags, &r.Excerpt, &r.Rank, &r.Headline); err != nil {
			continue
		}
		r.Tags = []string(dbTags)
		if r.Tags == nil {
			r.Tags = []string{}
		}
		results = append(results, r)
	}

	out, _ := json.Marshal(map[string]interface{}{
		"query":   query,
		"mode":    "keyword",
		"count":   len(results),
		"results": results,
	})
	return string(out), nil
}

func (t *noteSearchTool) semanticSearch(ctx context.Context, execCtx ExecutionContext, query string, limit int) (string, error) {
	// Check embedder availability — fall back to keyword search if not configured
	if t.embedder == nil || !t.embedder.IsConfigured(ctx) {
		log.Printf("⚠ note semantic search: embedder not configured, falling back to keyword")
		return t.keywordSearch(ctx, execCtx, query, limit)
	}

	// Resolve team for embedding role
	var teamID *string
	if t.stores.Teams != nil {
		ids, _ := t.stores.Teams.GetUserTeamIDs(ctx, execCtx.UserID)
		if len(ids) > 0 {
			teamID = &ids[0]
		}
	}

	// Embed the query
	embedResult, err := t.embedder.EmbedChunks(ctx, execCtx.UserID, teamID, []string{query})
	if err != nil {
		log.Printf("⚠ note semantic search embed failed: %v — falling back to keyword", err)
		return t.keywordSearch(ctx, execCtx, query, limit)
	}
	if len(embedResult.Vectors) == 0 {
		return t.keywordSearch(ctx, execCtx, query, limit)
	}

	// Track embedding usage
	chanPtr := &execCtx.ChannelID
	t.embedder.LogUsage(ctx, execCtx.UserID, chanPtr, embedResult)

	queryVec := vectorToString(embedResult.Vectors[0])

	// Vector similarity search — only notes that have embeddings
	rows, err := database.DB.Query(`
		SELECT id, title, folder_path, tags, LEFT(content, 500),
		       1 - (embedding <=> $2::vector) AS similarity
		FROM notes
		WHERE user_id = $1
		  AND embedding IS NOT NULL
		  AND 1 - (embedding <=> $2::vector) > 0.3
		ORDER BY embedding <=> $2::vector
		LIMIT $3
	`, execCtx.UserID, queryVec, limit)

	if err != nil {
		log.Printf("⚠ note semantic search query failed: %v — falling back to keyword", err)
		return t.keywordSearch(ctx, execCtx, query, limit)
	}
	defer rows.Close()

	results := make([]noteSearchResult, 0)
	for rows.Next() {
		var r noteSearchResult
		var dbTags pq.StringArray
		if err := rows.Scan(&r.ID, &r.Title, &r.Folder, &dbTags, &r.Excerpt, &r.Similarity); err != nil {
			continue
		}
		r.Tags = []string(dbTags)
		if r.Tags == nil {
			r.Tags = []string{}
		}
		results = append(results, r)
	}

	out, _ := json.Marshal(map[string]interface{}{
		"query":   query,
		"mode":    "semantic",
		"count":   len(results),
		"results": results,
	})
	return string(out), nil
}

type noteSearchResult struct {
	ID         string   `json:"id"`
	Title      string   `json:"title"`
	Folder     string   `json:"folder"`
	Tags       []string `json:"tags"`
	Excerpt    string   `json:"excerpt"`
	Headline   string   `json:"headline,omitempty"`
	Rank       float64  `json:"rank,omitempty"`
	Similarity float64  `json:"similarity,omitempty"`
}

// ═══════════════════════════════════════════
// note_update
// ═══════════════════════════════════════════

type noteUpdateTool struct {
	stores   store.Stores
	embedder *knowledge.Embedder
}

func (t *noteUpdateTool) Definition() ToolDef {
	return ToolDef{
		Name:        "note_update",
		DisplayName: "Update",
		Category:    "notes",
		Description: "Update an existing note. Can replace content entirely, append to it, or prepend. Use note_search first to find the note ID.",
		Parameters: JSONSchema(map[string]interface{}{
			"note_id": Prop("string", "UUID of the note to update (from note_search results)"),
			"title":   Prop("string", "New title (omit to keep current)"),
			"content": Prop("string", "New content or text to append/prepend"),
			"mode":    PropEnum("How to apply content", "replace", "append", "prepend"),
			"tags":    PropArray("New tags (replaces existing tags)"),
		}, []string{"note_id"}),
	}
}

func (t *noteUpdateTool) Execute(ctx context.Context, execCtx ExecutionContext, argsJSON string) (string, error) {
	var args struct {
		NoteID  string   `json:"note_id"`
		Title   *string  `json:"title"`
		Content *string  `json:"content"`
		Mode    string   `json:"mode"`
		Tags    []string `json:"tags"`
	}
	if err := json.Unmarshal([]byte(argsJSON), &args); err != nil {
		return "", fmt.Errorf("invalid arguments: %w", err)
	}

	if args.NoteID == "" {
		return "", fmt.Errorf("note_id is required")
	}

	// Build dynamic update
	setClauses := []string{}
	queryArgs := []interface{}{}
	argIdx := 1

	if args.Title != nil {
		setClauses = append(setClauses, fmt.Sprintf("title = $%d", argIdx))
		queryArgs = append(queryArgs, *args.Title)
		argIdx++
	}

	if args.Content != nil {
		mode := strings.ToLower(args.Mode)
		switch mode {
		case "append":
			setClauses = append(setClauses, fmt.Sprintf("content = content || $%d", argIdx))
		case "prepend":
			setClauses = append(setClauses, fmt.Sprintf("content = $%d || content", argIdx))
		default:
			setClauses = append(setClauses, fmt.Sprintf("content = $%d", argIdx))
		}
		queryArgs = append(queryArgs, *args.Content)
		argIdx++
	}

	if args.Tags != nil {
		setClauses = append(setClauses, fmt.Sprintf("tags = $%d", argIdx))
		queryArgs = append(queryArgs, pq.Array(args.Tags))
		argIdx++
	}

	if len(setClauses) == 0 {
		return "", fmt.Errorf("no fields to update — provide at least title, content, or tags")
	}

	queryArgs = append(queryArgs, args.NoteID, execCtx.UserID)
	query := "UPDATE notes SET " + strings.Join(setClauses, ", ") +
		fmt.Sprintf(" WHERE id = $%d AND user_id = $%d", argIdx, argIdx+1) +
		" RETURNING id, title, content, updated_at::text"

	var id, title, content, updatedAt string
	err := database.DB.QueryRow(query, queryArgs...).Scan(&id, &title, &content, &updatedAt)
	if err != nil {
		return "", fmt.Errorf("note not found or update failed")
	}

	// Re-embed async with updated content
	go embedNote(context.Background(), t.embedder, t.stores, id, execCtx.UserID, title, content)

	result, _ := json.Marshal(map[string]interface{}{
		"id":         id,
		"title":      title,
		"updated_at": updatedAt,
		"message":    fmt.Sprintf("Note '%s' updated successfully.", title),
	})
	return string(result), nil
}

// ═══════════════════════════════════════════
// note_list
// ═══════════════════════════════════════════

type noteListTool struct{}

func (t *noteListTool) Definition() ToolDef {
	return ToolDef{
		Name:        "note_list",
		DisplayName: "List",
		Category:    "notes",
		Description: "List the user's notes, optionally filtered by folder or tag. Shows titles and metadata without full content. Use note_search for keyword searching.",
		Parameters: JSONSchema(map[string]interface{}{
			"folder": Prop("string", "Filter by folder path, e.g. '/projects/' (omit for all)"),
			"tag":    Prop("string", "Filter by tag (omit for all)"),
			"limit":  Prop("integer", "Maximum results (default 20, max 100)"),
		}, nil),
	}
}

func (t *noteListTool) Execute(ctx context.Context, execCtx ExecutionContext, argsJSON string) (string, error) {
	var args struct {
		Folder string `json:"folder"`
		Tag    string `json:"tag"`
		Limit  int    `json:"limit"`
	}
	if err := json.Unmarshal([]byte(argsJSON), &args); err != nil {
		return "", fmt.Errorf("invalid arguments: %w", err)
	}

	if args.Limit <= 0 || args.Limit > 100 {
		args.Limit = 20
	}

	query := `SELECT id, title, folder_path, tags, LEFT(content, 100),
	                 created_at::text, updated_at::text
	          FROM notes WHERE user_id = $1`
	queryArgs := []interface{}{execCtx.UserID}
	argIdx := 2

	if args.Folder != "" {
		query += fmt.Sprintf(" AND folder_path = $%d", argIdx)
		queryArgs = append(queryArgs, normalizePath(args.Folder))
		argIdx++
	}
	if args.Tag != "" {
		query += fmt.Sprintf(" AND $%d = ANY(tags)", argIdx)
		queryArgs = append(queryArgs, args.Tag)
		argIdx++
	}

	query += fmt.Sprintf(" ORDER BY updated_at DESC LIMIT $%d", argIdx)
	queryArgs = append(queryArgs, args.Limit)

	rows, err := database.DB.Query(query, queryArgs...)
	if err != nil {
		return "", fmt.Errorf("failed to list notes: %w", err)
	}
	defer rows.Close()

	type item struct {
		ID        string   `json:"id"`
		Title     string   `json:"title"`
		Folder    string   `json:"folder"`
		Tags      []string `json:"tags"`
		Preview   string   `json:"preview"`
		CreatedAt string   `json:"created_at"`
		UpdatedAt string   `json:"updated_at"`
	}

	items := make([]item, 0)
	for rows.Next() {
		var n item
		var dbTags pq.StringArray
		if err := rows.Scan(&n.ID, &n.Title, &n.Folder, &dbTags, &n.Preview,
			&n.CreatedAt, &n.UpdatedAt); err != nil {
			continue
		}
		n.Tags = []string(dbTags)
		if n.Tags == nil {
			n.Tags = []string{}
		}
		items = append(items, n)
	}

	out, _ := json.Marshal(map[string]interface{}{
		"count": len(items),
		"notes": items,
	})
	return string(out), nil
}

// ── Path Helper ─────────────────────────────

func normalizePath(p string) string {
	p = strings.TrimSpace(p)
	if p == "" {
		return "/"
	}
	if !strings.HasPrefix(p, "/") {
		p = "/" + p
	}
	if !strings.HasSuffix(p, "/") {
		p = p + "/"
	}
	for strings.Contains(p, "//") {
		p = strings.ReplaceAll(p, "//", "/")
	}
	return p
}