381 lines
12 KiB
Go
381 lines
12 KiB
Go
package tools
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"strings"
|
|
|
|
"github.com/lib/pq"
|
|
|
|
"git.gobha.me/xcaliber/chat-switchboard/database"
|
|
)
|
|
|
|
// ── Init ────────────────────────────────────
|
|
|
|
func init() {
|
|
Register(&NoteCreateTool{})
|
|
Register(&NoteSearchTool{})
|
|
Register(&NoteUpdateTool{})
|
|
Register(&NoteListTool{})
|
|
}
|
|
|
|
// ═══════════════════════════════════════════
|
|
// note_create
|
|
// ═══════════════════════════════════════════
|
|
|
|
type NoteCreateTool struct{}
|
|
|
|
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)
|
|
}
|
|
|
|
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{}
|
|
|
|
func (t *NoteSearchTool) Definition() ToolDef {
|
|
return ToolDef{
|
|
Name: "note_search",
|
|
DisplayName: "Search",
|
|
Category: "notes",
|
|
Description: "Search the user's notes by keyword. Returns matching notes ranked by relevance with highlighted excerpts. Use this to find previously saved information.",
|
|
Parameters: JSONSchema(map[string]interface{}{
|
|
"query": Prop("string", "Search query — natural language keywords"),
|
|
"limit": Prop("integer", "Maximum results to return (default 10, max 50)"),
|
|
}, []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"`
|
|
}
|
|
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
|
|
}
|
|
|
|
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, args.Query, args.Limit)
|
|
|
|
if err != nil {
|
|
return "", fmt.Errorf("search failed: %w", err)
|
|
}
|
|
defer rows.Close()
|
|
|
|
type result 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"`
|
|
Rank float64 `json:"rank"`
|
|
}
|
|
|
|
results := make([]result, 0)
|
|
for rows.Next() {
|
|
var r result
|
|
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": args.Query,
|
|
"count": len(results),
|
|
"results": results,
|
|
})
|
|
return string(out), nil
|
|
}
|
|
|
|
// ═══════════════════════════════════════════
|
|
// note_update
|
|
// ═══════════════════════════════════════════
|
|
|
|
type NoteUpdateTool struct{}
|
|
|
|
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, updated_at::text"
|
|
|
|
var id, title, updatedAt string
|
|
err := database.DB.QueryRow(query, queryArgs...).Scan(&id, &title, &updatedAt)
|
|
if err != nil {
|
|
return "", fmt.Errorf("note not found or update failed")
|
|
}
|
|
|
|
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
|
|
}
|