quietlight/skraak_mcp - Change 25GQ5TYGSGL7QED7L2IAPFLZ4WJJ2ZFAM6O6X5AOSTYPVJNCOGPQC

new update cluster, now put path into cluster when importing files, I deleted ndb.nanoid function as its easier just to do it each time inline I think

Created by quietlight on January 27, 2026

25GQ5TYGSGL7QED7L2IAPFLZ4WJJ2ZFAM6O6X5AOSTYPVJNCOGPQC

Dependencies

In channels

main

Change contents

File addition: path_normalization_test.go (----------)

[3.1]

package utils
import (
	"testing"
)
func TestStripMountPoint(t *testing.T) {
	tests := []struct {
		name     string
		input    string
		expected string
	}{
		// macOS
		{"macOS volume", "/Volumes/ExternalDrive/Audio", "ExternalDrive/Audio"},
		{"macOS root volume", "/Volumes/Drive", "Drive"},
		// Linux /media/ with username
		{"Linux media mount", "/media/david/USB-Drive/Audio", "USB-Drive/Audio"},
		{"Linux media different user", "/media/john/Backup/Audio", "Backup/Audio"},
		{"Linux media Pomona", "/media/david/Pomona-4/Pomona/A05/2025-11-08", "Pomona-4/Pomona/A05/2025-11-08"},
		// Linux /mnt/
		{"Linux mnt mount", "/mnt/storage/Audio", "storage/Audio"},
		// No mount point
		{"Absolute no mount", "/home/user/Audio", "/home/user/Audio"},
		{"Relative path", "./relative/path", "relative/path"},
		// Edge cases
		{"Root", "/", "/"},
		{"Empty", "", "."},
		{"Volumes only", "/Volumes/", "."},
		{"Media with user only", "/media/david/", "."},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := StripMountPoint(tt.input)
			if result != tt.expected {
				t.Errorf("StripMountPoint(%q) = %q, want %q", tt.input, result, tt.expected)
			}
		})
	}
}
func TestNormalizeFolderPath(t *testing.T) {
	tests := []struct {
		name     string
		input    string
		expected string
	}{
		// Full workflow
		{"Linux media path", "/media/david/Pomona-4/Pomona/A05/2025-11-08/", "Pomona-4/Pomona/A05/2025-11-08"},
		{"macOS volumes path", "/Volumes/Drive/Audio/Recordings/", "Drive/Audio/Recordings"},
		{"Linux mnt path", "/mnt/storage/Audio/Files/", "storage/Audio/Files"},
		// Trailing slashes handled
		{"With trailing slash", "/media/david/USB/Audio/", "USB/Audio"},
		{"Without trailing slash", "/media/david/USB/Audio", "USB/Audio"},
		// Multiple levels
		{"Deep nested path", "/media/david/Pomona-4/Level1/Level2/Level3/", "Pomona-4/Level1/Level2/Level3"},
		// Edge cases
		{"File at mount root", "/media/david/", "."},
		{"Volumes with drive only", "/Volumes/Drive/", "Drive"},
		{"Volumes drive no trailing slash", "/Volumes/Drive", "Drive"},
		{"Root", "/", ""},
		{"Empty", "", "."},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := NormalizeFolderPath(tt.input)
			if result != tt.expected {
				t.Errorf("NormalizeFolderPath(%q) = %q, want %q", tt.input, result, tt.expected)
			}
		})
	}
}

File addition: path_normalization.go (----------)

[3.1]

package utils
import (
	"path/filepath"
	"runtime"
	"strings"
)
// StripMountPoint removes OS-specific mount point prefixes from a path
func StripMountPoint(absPath string) string {
	// Clean path first
	absPath = filepath.Clean(absPath)
	// Handle Windows drive letters
	if runtime.GOOS == "windows" {
		volumeName := filepath.VolumeName(absPath)
		if volumeName != "" {
			// Remove "C:\" and return rest
			return strings.TrimPrefix(absPath, volumeName+string(filepath.Separator))
		}
	}
	// Handle Unix-like mount points
	switch {
	case absPath == "/Volumes":
		// Exact match to mount point root
		return "."
	case strings.HasPrefix(absPath, "/Volumes/"):
		// macOS external volumes: /Volumes/Drive/... → Drive/...
		return strings.TrimPrefix(absPath, "/Volumes/")
	case strings.HasPrefix(absPath, "/media/"):
		// Linux user mounts: /media/username/Drive/... → Drive/...
		// Strip /media/ and the username directory
		pathAfterMedia := strings.TrimPrefix(absPath, "/media/")
		parts := strings.SplitN(pathAfterMedia, string(filepath.Separator), 2)
		if len(parts) > 1 {
			return parts[1] // Return everything after username
		}
		// Just username, no subdirectory (e.g., /media/david)
		return "."
	case strings.HasPrefix(absPath, "/mnt/"):
		// Linux system mounts: /mnt/storage/... → storage/...
		return strings.TrimPrefix(absPath, "/mnt/")
	}
	// No known mount point detected, return as-is
	return absPath
}
// NormalizeFolderPath strips mount points and cleans up a folder path
// Unlike a file path normalization, this expects a directory path
func NormalizeFolderPath(folderPath string) string {
	// Clean the path
	folderPath = filepath.Clean(folderPath)
	// Strip mount point
	relativePath := StripMountPoint(folderPath)
	// Clean up leading/trailing slashes
	relativePath = strings.Trim(relativePath, string(filepath.Separator))
	return relativePath
}

Insertion in tools/write_pattern.go at line 6 [3.22734]
[3.22777]
[3.22777]
```
	"skraak_mcp/db"
```
Replacement in tools/write_pattern.go at line 8 [3.22734]
B:BD[3.22778] → [3.22778:22795]
```
	"skraak_mcp/db"
```
[3.22778]
[3.22795]
```
	gonanoid "github.com/matoous/go-nanoid/v2"
```

Replacement in tools/write_pattern.go at line 61 [3.22734]

B:BD[3.24701] → [3.24701:24729]

	id, err := db.GenerateID()

[3.24701]

[3.24729]

	id, err := gonanoid.Generate("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 12)

Insertion in tools/write_location.go at line 6 [3.26122]
[3.26165]
[3.26165]
```
	"skraak_mcp/db"
```
Deletion in tools/write_location.go at line 9 [3.26122]
B:BD[3.26184] → [3.26184:26202]
```
	"skraak_mcp/db"
```
Insertion in tools/write_location.go at line 10 [3.26122]
[3.26203]
[3.26203]
```
	gonanoid "github.com/matoous/go-nanoid/v2"
```

Replacement in tools/write_location.go at line 107 [3.26122]

B:BD[3.29817] → [3.29817:29845]

	id, err := db.GenerateID()

[3.29817]

[3.29845]

	id, err := gonanoid.Generate("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 12)

Insertion in tools/write_dataset.go at line 6 [3.31510]
[3.31553]
[3.31553]
```
	"skraak_mcp/db"
```
Deletion in tools/write_dataset.go at line 8 [3.31510]
B:BD[3.31564] → [3.31564:31582]
```
	"skraak_mcp/db"
```
Insertion in tools/write_dataset.go at line 9 [3.31510]
[3.31583]
[3.31583]
```
	gonanoid "github.com/matoous/go-nanoid/v2"
```

Replacement in tools/write_dataset.go at line 83 [3.31510]

B:BD[3.34025] → [3.34025:34053]

	id, err := db.GenerateID()

[3.34025]

[3.34053]

	id, err := gonanoid.Generate("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 12)

Insertion in tools/write_cluster.go at line 6 [3.35410]
[3.35453]
[3.35453]
```
	"skraak_mcp/db"
```
Replacement in tools/write_cluster.go at line 9 [3.35410]
B:BD[3.35465] → [3.35465:35482]
```
	"skraak_mcp/db"
```
[3.35465]
[3.35482]
```
	gonanoid "github.com/matoous/go-nanoid/v2"
```

Replacement in tools/write_cluster.go at line 145 [3.35410]

B:BD[3.40963] → [3.40963:40991]

	id, err := db.GenerateID()

[3.40963]

[3.40991]

	id, err := gonanoid.Generate("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 12)

File addition: update_cluster.go (----------)

[3.22715]

package tools
import (
	"context"
	"fmt"
	"strings"
	"github.com/modelcontextprotocol/go-sdk/mcp"
	"skraak_mcp/db"
)
// UpdateClusterInput defines input parameters
type UpdateClusterInput struct {
	ClusterID   string  `json:"cluster_id" jsonschema:"required,Cluster ID (12 characters)"`
	Name        *string `json:"name,omitempty" jsonschema:"Cluster name (max 140 characters)"`
	Path        *string `json:"path,omitempty" jsonschema:"Normalized folder path (max 255 characters)"`
	SampleRate  *int    `json:"sample_rate,omitempty" jsonschema:"Sample rate in Hz"`
	Description *string `json:"description,omitempty" jsonschema:"Cluster description (max 255 characters)"`
}
// UpdateClusterOutput defines output structure
type UpdateClusterOutput struct {
	ClusterID string `json:"cluster_id" jsonschema:"Updated cluster ID"`
	Success   bool   `json:"success" jsonschema:"Whether update succeeded"`
	Message   string `json:"message" jsonschema:"Status message"`
}
// UpdateCluster implements the update_cluster MCP tool
func UpdateCluster(
	ctx context.Context,
	req *mcp.CallToolRequest,
	input UpdateClusterInput,
) (*mcp.CallToolResult, UpdateClusterOutput, error) {
	// Open writable database
	database, err := db.OpenWriteableDB(dbPath)
	if err != nil {
		return nil, UpdateClusterOutput{}, fmt.Errorf("failed to open database: %w", err)
	}
	defer database.Close()
	// Verify cluster exists
	var exists bool
	err = database.QueryRow("SELECT EXISTS(SELECT 1 FROM cluster WHERE id = ?)", input.ClusterID).Scan(&exists)
	if err != nil {
		return nil, UpdateClusterOutput{}, fmt.Errorf("failed to query cluster: %w", err)
	}
	if !exists {
		return nil, UpdateClusterOutput{}, fmt.Errorf("cluster not found: %s", input.ClusterID)
	}
	// Build dynamic UPDATE query based on provided fields
	updates := []string{}
	args := []any{}
	if input.Name != nil {
		updates = append(updates, "name = ?")
		args = append(args, *input.Name)
	}
	if input.Path != nil {
		updates = append(updates, "path = ?")
		args = append(args, *input.Path)
	}
	if input.SampleRate != nil {
		updates = append(updates, "sample_rate = ?")
		args = append(args, *input.SampleRate)
	}
	if input.Description != nil {
		updates = append(updates, "description = ?")
		args = append(args, *input.Description)
	}
	if len(updates) == 0 {
		return nil, UpdateClusterOutput{}, fmt.Errorf("no fields provided to update")
	}
	// Always update last_modified
	updates = append(updates, "last_modified = now()")
	args = append(args, input.ClusterID)
	// Execute update
	query := fmt.Sprintf("UPDATE cluster SET %s WHERE id = ?", strings.Join(updates, ", "))
	_, err = database.Exec(query, args...)
	if err != nil {
		return nil, UpdateClusterOutput{}, fmt.Errorf("failed to update cluster: %w", err)
	}
	output := UpdateClusterOutput{
		ClusterID: input.ClusterID,
		Success:   true,
		Message:   "Cluster updated successfully",
	}
	return &mcp.CallToolResult{}, output, nil
}

Deletion in tools/import_files.go at line 57 [3.50297]
B:BD[3.52391] → [3.52391:52414]
```
	FilePath       string
```

Insertion in tools/import_files.go at line 110 [3.50297]

[3.53841]

	// Phase 3.5: Set cluster path if empty
	err = ensureClusterPath(dbPath, input.ClusterID, input.FolderPath)
	if err != nil {
		return nil, output, fmt.Errorf("failed to set cluster path: %w", err)
	}

Insertion in tools/import_files.go at line 248 [3.50297]

[3.57762]

}
// ensureClusterPath sets the cluster's path field if it's currently empty
func ensureClusterPath(dbPath, clusterID, folderPath string) error {
	database, err := db.OpenWriteableDB(dbPath)
	if err != nil {
		return fmt.Errorf("failed to open database: %w", err)
	}
	defer database.Close()
	// Check if cluster already has a path
	var currentPath sql.NullString
	err = database.QueryRow("SELECT path FROM cluster WHERE id = ?", clusterID).Scan(&currentPath)
	if err != nil {
		return fmt.Errorf("failed to query cluster: %w", err)
	}
	// If path is already set, skip
	if currentPath.Valid && currentPath.String != "" {
		return nil
	}
	// Normalize folder path
	normalizedPath := utils.NormalizeFolderPath(folderPath)
	// Update cluster with normalized path
	_, err = database.Exec(
		"UPDATE cluster SET path = ?, last_modified = now() WHERE id = ?",
		normalizedPath,
		clusterID,
	)
	if err != nil {
		return fmt.Errorf("failed to update cluster path: %w", err)
	}
	return nil

Deletion in tools/import_files.go at line 481 [3.50297]
B:BD[3.63077] → [3.63077:63107]
```
			FilePath:       info.path,
```

Replacement in tools/import_files.go at line 528 [3.50297]

B:BD[3.64338] → [3.64338:64404]

			id, file_name, path, xxh64_hash, location_id, timestamp_local,

[3.64338]

[3.64404]

			id, file_name, xxh64_hash, location_id, timestamp_local,

Replacement in tools/import_files.go at line 531 [3.50297]

B:BD[3.64529] → [2.62958:63026]

		) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, now(), now(), true)

[3.64529]

[3.64617]

		) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, now(), now(), true)

Replacement in tools/import_files.go at line 609 [3.50297]
B:BD[3.66577] → [3.66577:66635]
```
			fileID, fd.FileName, fd.FilePath, fd.Hash, locationID,
```
[3.66577]
[3.66635]
```
			fileID, fd.FileName, fd.Hash, locationID,
```

Insertion in main.go at line 73 [3.149392]

[3.151589]

		Name:        "update_cluster",
		Description: "Update an existing cluster's metadata (name, path, sample_rate, description). Used internally by import_audio_files to set cluster path on first import.",
	}, tools.UpdateCluster)
	mcp.AddTool(server, &mcp.Tool{

File deletion: nanoid.go

BF:BFD[3.161589] → [3.330176:330209]

BF:BFD[3.330209] → [3.329765:329765]

B:BD[3.329765] → [3.329766:330175]

package db
import gonanoid "github.com/matoous/go-nanoid/v2"
// IDLength is the length of generated IDs (12 characters)
const IDLength = 12
// GenerateID generates a unique 12-character ID using nanoid
// Uses alphanumeric characters (62-character alphabet)
func GenerateID() (string, error) {
	return gonanoid.Generate(
		"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
		IDLength,
	)
}

Insertion in db/schema.sql at line 84 [3.305331]

[3.309002]

    path VARCHAR(255) NULL, -- optional hint for local access

Deletion in db/schema.sql at line 105 [3.305331]
B:BD[3.309987] → [3.309987:310049]
```
    path VARCHAR(255) NULL, -- optional hint for local access
```

new update cluster, now put path into cluster when importing files, I deleted ndb.nanoid function as its easier just to do it each time inline I think

Dependencies

In channels

Change contents

File addition: path_normalization_test.go (----------)

File addition: path_normalization.go (----------)

Insertion in tools/write_pattern.go at line 6 [3.22734]

Replacement in tools/write_pattern.go at line 8 [3.22734]

Replacement in tools/write_pattern.go at line 61 [3.22734]

Insertion in tools/write_location.go at line 6 [3.26122]

Deletion in tools/write_location.go at line 9 [3.26122]

Insertion in tools/write_location.go at line 10 [3.26122]

Replacement in tools/write_location.go at line 107 [3.26122]

Insertion in tools/write_dataset.go at line 6 [3.31510]

Deletion in tools/write_dataset.go at line 8 [3.31510]

Insertion in tools/write_dataset.go at line 9 [3.31510]

Replacement in tools/write_dataset.go at line 83 [3.31510]

Insertion in tools/write_cluster.go at line 6 [3.35410]

Replacement in tools/write_cluster.go at line 9 [3.35410]

Replacement in tools/write_cluster.go at line 145 [3.35410]

File addition: update_cluster.go (----------)

Deletion in tools/import_files.go at line 57 [3.50297]